chainlesschain 0.166.77 → 0.166.79

package/src/lib/token-tracker.js

@@ -7,45 +7,7 @@
 
 import { createHash } from "crypto";
 
-/**
- * Pricing data per million tokens (USD)
- */
-const PRICING = {
-  ollama: { input: 0, output: 0 },
-  openai: {
-    "gpt-4o": { input: 2.5, output: 10 },
-    "gpt-4o-mini": { input: 0.15, output: 0.6 },
-    "gpt-4-turbo": { input: 10, output: 30 },
-    "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
-    o1: { input: 15, output: 60 },
-    _default: { input: 2.5, output: 10 },
-  },
-  anthropic: {
-    // Current Anthropic list prices (USD/1M), verified 2026-06-21 vs the
-    // claude-api reference. Lookup is EXACT-key (calculateCost), so keep current
-    // model ids listed or they fall back to the Sonnet _default and mis-price —
-    // e.g. claude-opus-4-8 would otherwise be billed at $3/$15 not $5/$25. The
-    // Opus tier dropped to $5/$25 with Opus 4.5; Haiku 4.5 is $1/$5.
-    "claude-opus-4-8": { input: 5, output: 25 },
-    "claude-opus-4-7": { input: 5, output: 25 },
-    "claude-opus-4-6": { input: 5, output: 25 },
-    "claude-opus-4-5": { input: 5, output: 25 },
-    "claude-sonnet-4-6": { input: 3, output: 15 },
-    "claude-haiku-4-5": { input: 1, output: 5 },
-    "claude-haiku-4-5-20251001": { input: 1, output: 5 },
-    "claude-fable-5": { input: 10, output: 50 },
-    _default: { input: 3, output: 15 },
-  },
-  deepseek: {
-    "deepseek-chat": { input: 0.14, output: 0.28 },
-    _default: { input: 0.14, output: 0.28 },
-  },
-  dashscope: {
-    "qwen-turbo": { input: 0.3, output: 0.6 },
-    "qwen-plus": { input: 0.8, output: 2 },
-    _default: { input: 0.3, output: 0.6 },
-  },
-};
+import { estimateCost } from "./llm-pricing.js";
 
 function ensureTokenTable(db) {
   db.exec(`
@@ -67,19 +29,22 @@ function ensureTokenTable(db) {
 /**
  * Calculate cost for a given usage
  */
-export function calculateCost(provider, model, inputTokens, outputTokens) {
-  const providerPricing = PRICING[provider];
-  if (!providerPricing) return 0;
-
-  // Ollama is free
-  if (provider === "ollama") return 0;
-
-  const modelPricing = providerPricing[model] || providerPricing._default;
-  if (!modelPricing) return 0;
-
-  const inputCost = (inputTokens / 1_000_000) * modelPricing.input;
-  const outputCost = (outputTokens / 1_000_000) * modelPricing.output;
-  return inputCost + outputCost;
+export function calculateCost(
+  provider,
+  model,
+  inputTokens,
+  outputTokens,
+  options = {},
+) {
+  const estimate = estimateCost({
+    ...options,
+    provider,
+    model,
+    inputTokens,
+    outputTokens,
+  });
+  // SQL NULL represents unpriced usage; it must never be confused with free.
+  return estimate.matched ? estimate.totalCost : null;
 }
 
 /**
@@ -98,7 +63,13 @@ export function recordUsage(db, params) {
   } = params;
 
   const totalTokens = inputTokens + outputTokens;
-  const costUsd = calculateCost(provider, model, inputTokens, outputTokens);
+  const costUsd = calculateCost(
+    provider,
+    model,
+    inputTokens,
+    outputTokens,
+    params,
+  );
 
   const id = createHash("sha256")
     .update(`${Date.now()}-${Math.random()}`)
@@ -120,7 +91,7 @@ export function recordUsage(db, params) {
     endpoint,
   );
 
-  return { id, totalTokens, costUsd };
+  return { id, totalTokens, costUsd, priced: costUsd !== null };
 }
 
 /**
@@ -132,6 +103,7 @@ export function getUsageStats(db, options = {}) {
   const { startDate, endDate, provider, model } = options;
   let sql = `SELECT
     COUNT(*) as total_calls,
+    COUNT(cost_usd) as priced_calls,
     COALESCE(SUM(input_tokens), 0) as total_input_tokens,
     COALESCE(SUM(output_tokens), 0) as total_output_tokens,
     COALESCE(SUM(total_tokens), 0) as total_tokens,
@@ -165,6 +137,11 @@ export function getUsageStats(db, options = {}) {
     total_tokens: result?.total_tokens || 0,
     total_cost_usd: result?.total_cost_usd || 0,
     avg_response_time_ms: result?.avg_response_time_ms || 0,
+    unpriced_calls: Math.max(
+      0,
+      (result?.total_calls || 0) -
+        (result?.priced_calls ?? result?.total_calls ?? 0),
+    ),
   };
 }
 
@@ -178,6 +155,7 @@ export function getCostBreakdown(db) {
     .prepare(
       `SELECT provider, model,
        COUNT(*) as calls,
+       COUNT(*) - COUNT(cost_usd) as unpriced_calls,
        SUM(input_tokens) as input_tokens,
        SUM(output_tokens) as output_tokens,
        SUM(total_tokens) as total_tokens,

package/src/lib/usage-pricing-context.js

@@ -0,0 +1,93 @@
+import {
+  DOCUMENTED_OPENAI_MODELS,
+  GPT6_PRICING_TERMS,
+} from "./model-context-catalog.js";
+
+/** Only bounded, non-secret pricing labels may enter the durable usage ledger. */
+export function projectUsagePricingContext(usage = {}) {
+  const projected = {};
+  for (const [key, alias] of [
+    ["service_tier", "serviceTier"],
+    ["regional_processing", "regionalProcessing"],
+  ]) {
+    if (!Object.hasOwn(usage, key) && !Object.hasOwn(usage, alias)) continue;
+    if (
+      Object.hasOwn(usage, key) &&
+      Object.hasOwn(usage, alias) &&
+      usage[key] !== usage[alias]
+    ) {
+      throw new TypeError(`usage pricing aliases conflict: ${key}`);
+    }
+    const value = Object.hasOwn(usage, key) ? usage[key] : usage[alias];
+    if (key === "service_tier") {
+      projected[key] =
+        typeof value === "string" &&
+        Object.hasOwn(GPT6_PRICING_TERMS.serviceMultipliers, value)
+          ? value
+          : "unknown";
+    } else {
+      if (typeof value !== "boolean")
+        throw new TypeError("usage regional processing must be boolean");
+      projected[key] = value;
+    }
+  }
+  return projected;
+}
+
+/** Preserve per-request thresholds in a bounded set of aggregate price buckets. */
+export function mergeUsagePricingBucket(entry, usage) {
+  if (
+    String(entry.provider).toLowerCase() !== "openai" ||
+    !DOCUMENTED_OPENAI_MODELS[String(entry.model).toLowerCase()]?.pricing
+  )
+    return;
+  const metadata = projectUsagePricingContext(usage);
+  const promptTokens =
+    usage.requestInputTokens ??
+    usage.inputTokens +
+      (usage.cacheReadTokens || 0) +
+      (usage.cacheCreationTokens || 0);
+  const long = promptTokens > GPT6_PRICING_TERMS.longContext.threshold;
+  const serviceTier = metadata.service_tier || "standard";
+  const regionalProcessing = metadata.regional_processing === true;
+  entry.pricingBuckets ||= [];
+  let bucket = entry.pricingBuckets.find(
+    (item) =>
+      item.serviceTier === serviceTier &&
+      item.regionalProcessing === regionalProcessing &&
+      item.requestInputTokens > GPT6_PRICING_TERMS.longContext.threshold ===
+        long,
+  );
+  if (!bucket) {
+    bucket = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      totalTokens: 0,
+      calls: 0,
+      serviceTier,
+      regionalProcessing,
+      requestInputTokens: promptTokens,
+    };
+    entry.pricingBuckets.push(bucket);
+  }
+  for (const key of [
+    "inputTokens",
+    "outputTokens",
+    "cacheReadTokens",
+    "cacheCreationTokens",
+    "totalTokens",
+    "calls",
+  ]) {
+    const value = usage[key] ?? (key === "calls" ? 1 : 0);
+    if (
+      !Number.isSafeInteger(value) ||
+      value < 0 ||
+      !Number.isSafeInteger(bucket[key] + value)
+    ) {
+      throw new TypeError(`invalid pricing bucket ${key}`);
+    }
+    bucket[key] += value;
+  }
+}

package/src/runtime/agent-core.js

@@ -6637,34 +6637,55 @@ async function executeToolInner(
           );
         }
         await admitShellDispatch();
-        const { executeSandboxedShell, sandboxSummary } =
-          await import("../lib/agent-sandbox.js");
-        // Domain-restricted networking is ENFORCED by routing the sandboxed
-        // process's egress through a local filtering proxy (see
-        // sandbox-egress-proxy.js). Start it only when the policy actually
-        // restricts domains and network is on; tear it down after the command.
+        const {
+          assessAgentSandboxCapabilities,
+          executeDockerEgressShell,
+          executeSandboxedShell,
+          sandboxSummary,
+        } = await import("../lib/agent-sandbox.js");
+        // Keep the proxy on a separate event loop: the legacy sandbox dispatch
+        // below is synchronous. The sandbox still refuses domain-restricted
+        // execution until a non-bypassable network backend is available.
         const sboxPolicy = shellSandbox.policy || {};
         const needsEgress =
           shellSandbox.network === true &&
           (sboxPolicy.allowedDomains?.length || 0) +
             (sboxPolicy.deniedDomains?.length || 0) >
             0;
+        const dockerEgress = shellSandbox.engine === "docker-egress";
         let egressProxy = null;
         let proxyHandle = null;
+        let privateSocketDir = null;
+        let dockerEgressSession = null;
+        let proxyFailed = false;
         if (needsEgress) {
           try {
-            const { createEgressProxy } =
-              await import("../lib/sandbox-egress-proxy.js");
-            proxyHandle = createEgressProxy(
+            const { startEgressProxyWorker } =
+              await import("../lib/sandbox-egress-worker.js");
+            if (dockerEgress) {
+              privateSocketDir = fs.mkdtempSync(
+                path.join(os.tmpdir(), "cc-egress-"),
+              );
+              fs.chmodSync(privateSocketDir, 0o700);
+            }
+            proxyHandle = await startEgressProxyWorker(
               {
                 allowedDomains: sboxPolicy.allowedDomains || [],
                 deniedDomains: sboxPolicy.deniedDomains || [],
                 allowPrivate: sboxPolicy.allowPrivate === true,
               },
-              { bindHost: "0.0.0.0" }, // reachable from the container/netns
+              {
+                bindHost: "127.0.0.1",
+                ...(privateSocketDir
+                  ? { socketPath: path.join(privateSocketDir, "broker.sock") }
+                  : {}),
+                onFailure() {
+                  proxyFailed = true;
+                  void dockerEgressSession?.close().catch(() => {});
+                },
+              },
             );
-            const listened = await proxyHandle.listen();
-            egressProxy = { port: listened.port };
+            if (proxyHandle.port) egressProxy = { port: proxyHandle.port };
           } catch {
             // If the proxy can't start, leave egressProxy null so the sandbox
             // fails closed (refuses) rather than running without enforcement.
@@ -6687,15 +6708,72 @@ async function executeToolInner(
             error.pluginBinFailClosed = true;
             throw error;
           }
-          result = executeSandboxedShell(args.command, shellSandbox, {
-            cwd: args.cwd || cwd,
-            timeout: _resolveShellTimeout(args.timeout),
-            maxBuffer: 1024 * 1024,
-            egressProxy,
-            env: sandboxChildEnvironment,
-            auditContext: createShellProcessAuditContext(),
-          });
+          if (dockerEgress && !proxyHandle?.socketPath) {
+            result = {
+              stdout: "",
+              stderr: "Docker egress policy broker is unavailable",
+              exitCode: 1,
+              failedToStart: true,
+              sandboxCapabilities: assessAgentSandboxCapabilities(
+                shellSandbox,
+                {
+                  execution: { attempted: true, started: false },
+                  availability: {
+                    available: false,
+                    reason: "egress-broker-unavailable",
+                  },
+                },
+              ),
+            };
+          } else if (dockerEgress) {
+            result = await executeDockerEgressShell(
+              args.command,
+              shellSandbox,
+              {
+                cwd: args.cwd || cwd,
+                timeoutMs: _resolveShellTimeout(args.timeout),
+                brokerSocketPath: proxyHandle.socketPath,
+                env: sandboxChildEnvironment,
+                auditContext: createShellProcessAuditContext(),
+                onSession(session) {
+                  dockerEgressSession = session;
+                  if (proxyFailed) void session.close().catch(() => {});
+                },
+                async beforeStart() {
+                  await shellDispatchPolicyAuthority?.revalidate?.();
+                  refreshPluginExecutionAuthority();
+                  if (
+                    proxyFailed ||
+                    proxyHandle.revision !== 0 ||
+                    pluginBinSandboxPolicy
+                  ) {
+                    const error = new Error(
+                      "Docker egress authority changed before target start",
+                    );
+                    error.code = "CC_DOCKER_EGRESS_AUTHORITY_CHANGED";
+                    throw error;
+                  }
+                },
+              },
+            );
+          } else {
+            result = executeSandboxedShell(args.command, shellSandbox, {
+              cwd: args.cwd || cwd,
+              timeout: _resolveShellTimeout(args.timeout),
+              maxBuffer: 1024 * 1024,
+              egressProxy,
+              env: sandboxChildEnvironment,
+              auditContext: createShellProcessAuditContext(),
+            });
+          }
         } finally {
+          if (dockerEgressSession) {
+            try {
+              await dockerEgressSession.close();
+            } catch {
+              /* execution result retains its cleanup status */
+            }
+          }
           if (proxyHandle) {
             try {
               await proxyHandle.close();
@@ -6703,10 +6781,26 @@ async function executeToolInner(
               /* best-effort teardown */
             }
           }
+          if (privateSocketDir) {
+            try {
+              fs.rmSync(path.join(privateSocketDir, "broker.sock"), {
+                force: true,
+              });
+              fs.rmdirSync(privateSocketDir);
+            } catch {
+              /* a failed broker cleanup remains visible via failed-to-start */
+            }
+          }
         }
         const common = {
           sandbox: sandboxSummary(shellSandbox),
           sandboxCapabilities: result.sandboxCapabilities || null,
+          ...(result.executionOutcome
+            ? {
+                executionOutcome: result.executionOutcome,
+                retrySafe: result.retrySafe,
+              }
+            : {}),
           shellCommandPolicy: shellPolicy,
           approval: approvalOutcome,
           policyTrace: ["shell-policy", "approval", "sandbox"],
@@ -11740,7 +11834,33 @@ export async function chatWithTools(rawMessages, options) {
     throw new Error("Invalid API response: no choices returned");
   }
   const choice = data.choices[0];
-  const out = { message: choice.message };
+  const providerMessage = choice.message;
+  if (
+    !providerMessage ||
+    typeof providerMessage !== "object" ||
+    Array.isArray(providerMessage) ||
+    providerMessage.role !== "assistant" ||
+    (providerMessage.content !== null &&
+      providerMessage.content !== undefined &&
+      typeof providerMessage.content !== "string") ||
+    (Object.hasOwn(providerMessage, "tool_calls") &&
+      !Array.isArray(providerMessage.tool_calls)) ||
+    (Object.hasOwn(providerMessage, "reasoning_content") &&
+      providerMessage.reasoning_content !== null &&
+      typeof providerMessage.reasoning_content !== "string") ||
+    Object.keys(providerMessage).some(
+      (key) =>
+        !["role", "content", "tool_calls", "reasoning_content"].includes(key),
+    )
+  ) {
+    throw new TypeError("Invalid API response: unsupported assistant message");
+  }
+  // Provider reasoning text is not part of the governed replay protocol.
+  const message = { role: "assistant", content: providerMessage.content };
+  if (Object.hasOwn(providerMessage, "tool_calls")) {
+    message.tool_calls = providerMessage.tool_calls;
+  }
+  const out = { message };
   const providerReceipt = supportsOpenAIRequestIdentity
     ? _openAIProviderRequestReceipt(response, data, providerRequestId)
     : null;