Built for agents who run at machine speed.

// Simplified gateway request handler
async function handleRequest(req, res) {
  const identity = resolveIdentity(req.headers);
  if (!identity) return res.status(401).json({
    error: 'invalid_key'
  });

  // Rate limit check (token bucket)
  const allowed = await checkRateLimit(identity);
  if (!allowed) return res.status(429).json({
    error: 'rate_limited',
    retry_after: allowed.retryAfter
  });

  // Policy evaluation
  const decision = await evaluatePolicies(
    identity, req.body
  );

  if (decision.action === 'block') {
    await recordBlock(identity, decision);
    return res.status(403).json({
      error: 'policy_blocked',
      rule: decision.rule_name,
      reason: decision.reason
    });
  }

  // Forward to vendor
  const vendorRes = await proxyToVendor(
    identity, req
  );

  // Async: record transaction + update budget
  recordTransaction(identity, vendorRes)
    .catch(err => logError(err));

  return pipeResponse(vendorRes, res);
}

// Policy evaluation with short-circuit
async function evaluatePolicies(identity, req) {
  const rules = await getRulesForTenant(
    identity.tenant_id
  );

  for (const rule of rules) {
    const ctx = {
      agent: identity.agent_id,
      team: identity.team_id,
      model: req.model,
      vendor: detectVendor(req),
      spend: await getCurrentSpend(
        identity, rule.window
      ),
      time: new Date()
    };

    if (matchesConditions(rule.conditions, ctx)) {
      if (rule.action === 'block') {
        return {
          action: 'block',
          rule_name: rule.name,
          reason: formatReason(rule, ctx)
        };
      }
      if (rule.action === 'alert') {
        emitAlert(identity, rule, ctx);
      }
      if (rule.action === 'downgrade') {
        req.model = rule.downgrade_to;
      }
    }
  }

  return { action: 'allow' };
}

// Cost calculation from API response
function calculateCost(vendorResponse) {
  const usage = vendorResponse.usage;
  const model = vendorResponse.model;
  const pricing = getPricing(model);

  const inputCost =
    usage.prompt_tokens * pricing.input_per_token;
  const outputCost =
    usage.completion_tokens * pricing.output_per_token;

  return {
    total: inputCost + outputCost,
    breakdown: {
      input_tokens: usage.prompt_tokens,
      output_tokens: usage.completion_tokens,
      input_cost: inputCost,
      output_cost: outputCost,
      model: model,
      vendor: pricing.vendor,
      timestamp: new Date()
    }
  };
}

// Rolling spend aggregation
async function updateSpend(identity, cost) {
  await db.query(`
    INSERT INTO transactions
      (agent_id, team_id, org_id, amount,
       vendor, model, created_at)
    VALUES ($1, $2, $3, $4, $5, $6, NOW())
  `, [
    identity.agent_id,
    identity.team_id,
    identity.org_id,
    cost.total,
    cost.breakdown.vendor,
    cost.breakdown.model
  ]);
}

// Batched async audit writer
class AuditWriter {
  constructor() {
    this.buffer = [];
    this.flushInterval = setInterval(
      () => this.flush(), 500
    );
  }

  record(entry) {
    this.buffer.push({
      ...entry,
      id: generateULID(),
      created_at: new Date()
    });

    if (this.buffer.length >= 100) {
      this.flush();
    }
  }

  async flush() {
    if (this.buffer.length === 0) return;

    const batch = this.buffer.splice(
      0, 100
    );

    try {
      await db.batchInsert(
        'transactions', batch
      );
    } catch (err) {
      // Re-queue on failure
      this.buffer.unshift(...batch);
      metrics.increment(
        'audit.write_failure'
      );
    }
  }
}