sentinelayer-cli 0.31.4 → 0.31.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.31.4",
+  "version": "0.31.5",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/ai/client.js

@@ -146,6 +146,70 @@ function extractTextFromResponse(provider, payload) {
   return "";
 }
 
+function normalizeUsageNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 0;
+  }
+  return Math.floor(parsed);
+}
+
+function buildUsagePayload({ provider, model, inputTokens = 0, outputTokens = 0, totalTokens = 0 } = {}) {
+  const input = normalizeUsageNumber(inputTokens);
+  const output = normalizeUsageNumber(outputTokens);
+  const total = normalizeUsageNumber(totalTokens) || input + output;
+  if (total <= 0 && input + output <= 0) {
+    return null;
+  }
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: total,
+    model,
+    provider,
+  };
+}
+
+function extractUsageFromResponse(provider, payload, model) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+
+  if (provider === "openai") {
+    const usage = payload.usage || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.prompt_tokens ?? usage.input_tokens,
+      outputTokens: usage.completion_tokens ?? usage.output_tokens,
+      totalTokens: usage.total_tokens,
+    });
+  }
+
+  if (provider === "anthropic") {
+    const usage = payload.usage || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+    });
+  }
+
+  if (provider === "google") {
+    const usage = payload.usageMetadata || payload.usage_metadata || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.promptTokenCount ?? usage.prompt_token_count,
+      outputTokens: usage.candidatesTokenCount ?? usage.candidates_token_count,
+      totalTokens: usage.totalTokenCount ?? usage.total_token_count,
+    });
+  }
+
+  return null;
+}
+
 function buildProviderRequest({ provider, apiKey, model, prompt, stream }) {
   const normalizedProvider = normalizeProvider(provider);
   const normalizedPrompt = normalizePrompt(prompt);
@@ -527,6 +591,13 @@ export class MultiProviderApiClient {
         } else {
           const payload = await response.json();
           text = extractTextFromResponse(resolvedProvider, payload);
+          const usage = extractUsageFromResponse(resolvedProvider, payload, resolvedModel);
+          return {
+            provider: resolvedProvider,
+            model: resolvedModel,
+            text,
+            usage: usage || undefined,
+          };
         }
 
         return {

package/src/session/daemon.js

@@ -44,6 +44,7 @@ import { stopRuntimeRunsForSession } from "./runtime-bridge.js";
 import { getSession, renewSession } from "./store.js";
 import { appendToStream, readStream, tailStream } from "./stream.js";
 import { handleTaskDirective } from "./tasks.js";
+import { emitLLMInteraction } from "./usage.js";
 
 const DAEMON_TICK_INTERVAL_MS = 30_000;
 const HELP_REQUEST_TIMEOUT_MS = 1_200;
@@ -653,6 +654,28 @@ async function maybeRespondToHelpRequest(
       nowIso,
     }
   );
+  if (normalizeUsageNumber(response.usage.inputTokens) + normalizeUsageNumber(response.usage.outputTokens) > 0) {
+    // The managed proxy already records the durable API billing/v1 row for
+    // this same idempotency key. Keep this copy local for immediate transcript
+    // and recap usage without double-counting Session.total_cost_usd remotely.
+    await emitLLMInteraction(daemonState.sessionId, {
+      agentId: SENTI_IDENTITY.id,
+      agentModel: response.usage.model || daemonState.model,
+      role: SENTI_IDENTITY.role,
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      costUsd: response.usage.costUsd,
+      durationMs: response.usage.latencyMs,
+      action: "proxy_llm",
+      provider: response.usage.provider || "sentinelayer",
+      billingTier: "internal",
+      prompt: normalizeString(requestEvent?.payload?.message) || normalizeString(requestEvent?.payload?.request),
+      response: response.message,
+      interactionId: `senti:${daemonState.sessionId}:help:${requestId}`,
+      targetPath,
+      syncRemote: false,
+    });
+  }
   return responseEvent;
 }
 

package/src/session/usage.js

@@ -111,6 +111,7 @@ function computedCost({ model, inputTokens, outputTokens }) {
  * @param {string} [params.response]          full response text (clipped)
  * @param {string} [params.interactionId]     opaque id for cross-event correlation
  * @param {string} [params.targetPath]        workspace path (default cwd)
+ * @param {boolean} [params.syncRemote]       sync local usage event to API (default true)
  * @returns {Promise<{ event: string, interactionId: string, totalTokens: number, costUsd: number }>}
  */
 export async function emitLLMInteraction(
@@ -132,6 +133,7 @@ export async function emitLLMInteraction(
     response = "",
     interactionId = "",
     targetPath = process.cwd(),
+    syncRemote = true,
   } = {},
 ) {
   const sid = n(sessionId);
@@ -219,7 +221,7 @@ export async function emitLLMInteraction(
     ts,
   });
 
-  await appendToStream(paths.sessionId, envelope, { targetPath });
+  await appendToStream(paths.sessionId, envelope, { targetPath, syncRemote });
   return {
     event: SESSION_USAGE_EVENT,
     interactionId: id,