@tangle-network/agent-runtime 0.17.1 → 0.18.0

package/dist/index.d.ts

@@ -187,12 +187,9 @@ declare function handleChatTurn(input: RunChatTurnInput): ChatTurnResult;
  * opaque id. Substrate executionIds are not a secrecy boundary.
  *
  * Wire integration:
- *   - `@tangle-network/sandbox@0.1.x` PromptOptions does not yet expose
- *     `executionId`. The SDK auto-reconnects in-call by extracting it
- *     from the response `execution.started` event; products do nothing.
- *   - For cross-process reconnect today, bypass the SDK and POST to the
- *     orchestrator's `/agents/run/stream` directly with this id in the
- *     `X-Execution-ID` header (see tax-agent's `sessions.ts`).
+ *   - Sandbox PromptOptions accepts `executionId` and `lastEventId`.
+ *     Products pass this id to make cross-process reconnect land on the
+ *     same substrate execution instead of spawning a duplicate run.
  */
 declare function deriveExecutionId(input: {
     projectId: string;

package/dist/index.js

@@ -177,6 +177,7 @@ function createOpenAICompatibleBackend(options) {
       const requestBody = JSON.stringify({
         model: options.model,
         stream: true,
+        stream_options: { include_usage: true },
         messages: input.messages ?? [
           { role: "user", content: input.message ?? context.task.intent }
         ]
@@ -231,7 +232,7 @@ function createOpenAICompatibleBackend(options) {
           status: lastStatus || 0
         });
       }
-      yield* streamResponseEvents(response, context);
+      yield* streamResponseEvents(response, context, options.model);
     }
   };
 }
@@ -337,12 +338,14 @@ function mapCommonBackendEvent(event, context) {
   }
   return void 0;
 }
-async function* streamResponseEvents(response, context) {
+async function* streamResponseEvents(response, context, requestedModel) {
   const body = response.body;
   if (!body) return;
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  const usage = { saw: false };
+  const startedAt = Date.now();
   for (; ; ) {
     const { done, value } = await reader.read();
     if (done) break;
@@ -352,16 +355,32 @@ async function* streamResponseEvents(response, context) {
   buffer += decoder.decode().replace(/\r\n/g, "\n");
   for (const event of drainStreamBuffer(true)) yield event;
   if (buffer.trim()) {
-    const event = parseStreamChunk(buffer, context);
+    const event = parseStreamChunk(buffer, context, usage);
     if (event) yield event;
   }
+  if (usage.saw) {
+    yield {
+      type: "llm_call",
+      task: context.task,
+      session: context.session,
+      model: usage.model ?? requestedModel,
+      tokensIn: usage.tokensIn,
+      tokensOut: usage.tokensOut,
+      // `costUsd` is intentionally absent — pricing tables live in consumers
+      // (agent-eval's `estimateCost`, MetricsCollector). Emitting a wrong
+      // number here is worse than emitting none.
+      latencyMs: Date.now() - startedAt,
+      finishReason: usage.finishReason,
+      timestamp: nowIso()
+    };
+  }
   function* drainStreamBuffer(flush) {
     for (; ; ) {
       const sseBoundary = buffer.indexOf("\n\n");
       if (sseBoundary >= 0) {
         const chunk = buffer.slice(0, sseBoundary);
         buffer = buffer.slice(sseBoundary + 2);
-        const event = parseStreamChunk(chunk, context);
+        const event = parseStreamChunk(chunk, context, usage);
         if (event) yield event;
         continue;
       }
@@ -369,14 +388,14 @@ async function* streamResponseEvents(response, context) {
       if (newline >= 0 && !buffer.slice(0, newline).startsWith("data:")) {
         const line = buffer.slice(0, newline);
         buffer = buffer.slice(newline + 1);
-        const event = parseStreamChunk(line, context);
+        const event = parseStreamChunk(line, context, usage);
         if (event) yield event;
         continue;
       }
       if (flush && buffer.trim() && !buffer.trimStart().startsWith("data:")) {
         const line = buffer;
         buffer = "";
-        const event = parseStreamChunk(line, context);
+        const event = parseStreamChunk(line, context, usage);
         if (event) yield event;
         continue;
       }
@@ -384,13 +403,14 @@ async function* streamResponseEvents(response, context) {
     }
   }
 }
-function parseStreamChunk(chunk, context) {
+function parseStreamChunk(chunk, context, usage) {
   const lines = chunk.split(/\r?\n/);
   const dataLines = lines.filter((line) => line.startsWith("data:"));
   const data = dataLines.length > 0 ? dataLines.map((line) => line.slice(5).trimStart()).join("\n") : chunk.trim();
   if (!data || data === "[DONE]") return void 0;
   try {
     const parsed = JSON.parse(data);
+    captureStreamUsage(parsed, usage);
     const choices = parsed.choices;
     const choice = Array.isArray(choices) ? choices[0] : void 0;
     const delta = choice?.delta;
@@ -405,6 +425,19 @@ function parseStreamChunk(chunk, context) {
         timestamp: nowIso()
       };
     }
+    if (stringValue(parsed.type) === "content_block_delta") {
+      const d = parsed.delta;
+      const text2 = stringValue(d?.text);
+      if (text2) {
+        return {
+          type: "text_delta",
+          task: context.task,
+          session: context.session,
+          text: text2,
+          timestamp: nowIso()
+        };
+      }
+    }
     return mapCommonBackendEvent(parsed, context);
   } catch {
     return {
@@ -416,6 +449,63 @@ function parseStreamChunk(chunk, context) {
     };
   }
 }
+function captureStreamUsage(parsed, usage) {
+  const model = stringValue(parsed.model);
+  if (model && !usage.model) usage.model = model;
+  const openAiUsage = parsed.usage;
+  if (openAiUsage && typeof openAiUsage === "object") {
+    const promptTokens = numberValue(openAiUsage.prompt_tokens);
+    const completionTokens = numberValue(openAiUsage.completion_tokens);
+    const inputTokens = numberValue(openAiUsage.input_tokens);
+    const outputTokens = numberValue(openAiUsage.output_tokens);
+    if (promptTokens !== void 0) {
+      usage.tokensIn = promptTokens;
+      usage.saw = true;
+    } else if (inputTokens !== void 0) {
+      usage.tokensIn = (usage.tokensIn ?? 0) + inputTokens;
+      usage.saw = true;
+    }
+    if (completionTokens !== void 0) {
+      usage.tokensOut = completionTokens;
+      usage.saw = true;
+    } else if (outputTokens !== void 0) {
+      usage.tokensOut = (usage.tokensOut ?? 0) + outputTokens;
+      usage.saw = true;
+    }
+  }
+  const type = stringValue(parsed.type);
+  if (type === "message_start") {
+    const message = parsed.message;
+    const messageModel = stringValue(message?.model);
+    if (messageModel && !usage.model) usage.model = messageModel;
+    const messageUsage = message?.usage;
+    const inputTokens = numberValue(messageUsage?.input_tokens);
+    if (inputTokens !== void 0) {
+      usage.tokensIn = inputTokens;
+      usage.saw = true;
+    }
+    const outputTokens = numberValue(messageUsage?.output_tokens);
+    if (outputTokens !== void 0) {
+      usage.tokensOut = (usage.tokensOut ?? 0) + outputTokens;
+      usage.saw = true;
+    }
+  }
+  if (type === "message_delta") {
+    const delta = parsed.delta;
+    const stopReason = stringValue(delta?.stop_reason);
+    if (stopReason) usage.finishReason = stopReason;
+  }
+  const choices = parsed.choices;
+  if (Array.isArray(choices)) {
+    const finishReason = stringValue(
+      choices[0]?.finish_reason
+    );
+    if (finishReason) usage.finishReason = finishReason;
+  }
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -462,13 +552,7 @@ function handleChatTurn(input) {
         }
         const rawFinal = producer.finalText();
         const finalText = hooks.transformFinalText ? await hooks.transformFinalText(rawFinal) : rawFinal;
-        try {
-          await hooks.persistAssistantMessage({ identity, finalText });
-        } catch (err) {
-          log("[chat-engine] persistAssistantMessage threw", {
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
+        await hooks.persistAssistantMessage({ identity, finalText });
         if (hooks.onTurnComplete) {
           try {
             await hooks.onTurnComplete({ identity, finalText });