@prestyj/agent 5.5.0 → 5.7.0

package/dist/index.cjs

@@ -296,10 +296,14 @@ async function* agentLoop(messages, options) {
   const initialHardTimeoutMs = isSakana ? STREAM_THINKING_HARD_TIMEOUT_MS : STREAM_HARD_TIMEOUT_MS;
   const MAX_TOOLCALL_DELTA_CHARS = 1e6;
   const MAX_TOOLCALL_DELTA_EVENTS = 2e4;
+  let logicalTurnStartedAt = 0;
+  let firstProviderEventAt;
+  let providerDurationMs = 0;
   try {
     while (turn < maxTurns) {
       options.signal?.throwIfAborted();
       turn++;
+      if (logicalTurnStartedAt === 0) logicalTurnStartedAt = Date.now();
       toolMap = new Map((options.tools ?? []).map((t) => [t.name, t]));
       if (_diagFn) {
         let msgChars = 0;
@@ -349,6 +353,7 @@ async function* agentLoop(messages, options) {
       let idleTimer = null;
       let hardTimer = null;
       let idleTimedOut = false;
+      let providerAttemptStartedAt;
       let streamEventCount = 0;
       let lastEventTime = Date.now();
       let streamCallStart = Date.now();
@@ -394,12 +399,14 @@ async function* agentLoop(messages, options) {
       try {
         diag("stream_call", { nonStreaming: useNonStreamingFallback });
         streamCallStart = Date.now();
+        providerAttemptStartedAt = streamCallStart;
         const result = (0, import_ai.stream)({
           provider: options.provider,
           model: options.model,
           messages,
           tools: options.tools,
           serverTools: options.serverTools,
+          toolChoice: options.toolChoice,
           webSearch: options.webSearch,
           maxTokens: options.maxTokens,
           temperature: options.temperature,
@@ -442,6 +449,7 @@ async function* agentLoop(messages, options) {
             maxConsumerLagMs = consumerLag;
           }
           streamEventCount++;
+          if (firstProviderEventAt === void 0) firstProviderEventAt = pullTime;
           eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
           lastEventType = event.type;
           if ((event.type === "text_delta" || event.type === "server_toolcall" || event.type === "toolcall_delta") && !hasReceivedEvent) {
@@ -534,6 +542,7 @@ async function* agentLoop(messages, options) {
           eventTypes: eventTypeCounts
         });
         response = await abortablePromise(result.response, streamController.signal);
+        if (firstProviderEventAt === void 0) firstProviderEventAt = Date.now();
       } catch (err) {
         if (streamController.signal.aborted) closeIterator(streamIterator);
         const errMsg = err instanceof Error ? err.message : String(err);
@@ -758,6 +767,9 @@ async function* agentLoop(messages, options) {
         });
         throw err;
       } finally {
+        if (providerAttemptStartedAt !== void 0) {
+          providerDurationMs += Date.now() - providerAttemptStartedAt;
+        }
         if (idleTimer) clearTimeout(idleTimer);
         if (hardTimer) clearTimeout(hardTimer);
         options.signal?.removeEventListener("abort", forwardAbort);
@@ -801,11 +813,27 @@ async function* agentLoop(messages, options) {
         totalUsage.cacheWrite = (totalUsage.cacheWrite ?? 0) + response.usage.cacheWrite;
       }
       messages.push(response.message);
+      const completedAt = Date.now();
+      const outputTokensPerSecond = providerDurationMs > 0 && response.usage.outputTokens > 0 ? response.usage.outputTokens / (providerDurationMs / 1e3) : void 0;
+      const timing = {
+        startedAt: logicalTurnStartedAt,
+        ...firstProviderEventAt !== void 0 ? {
+          firstProviderEventAt,
+          ttftMs: Math.max(0, firstProviderEventAt - logicalTurnStartedAt)
+        } : {},
+        completedAt,
+        providerDurationMs,
+        ...outputTokensPerSecond !== void 0 ? { outputTokensPerSecond } : {}
+      };
+      logicalTurnStartedAt = 0;
+      firstProviderEventAt = void 0;
+      providerDurationMs = 0;
       yield {
         type: "turn_end",
         turn,
         stopReason: response.stopReason,
-        usage: response.usage
+        usage: response.usage,
+        timing
       };
       if (response.stopReason === "pause_turn") {
         consecutivePauses++;
@@ -989,8 +1017,8 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         ctx.signal
       );
       const normalized = normalizeToolResult(raw);
-      resultContent = normalized.content;
-      details = normalized.details;
+      resultContent = (0, import_ai.redactValue)(normalized.content);
+      details = (0, import_ai.redactValue)(normalized.details);
       for (const key of options.invalidToolArgumentCounts.keys()) {
         if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
       }
@@ -1018,10 +1046,12 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
           );
         }
       } else {
-        resultContent = err instanceof Error ? err.message : String(err);
+        resultContent = (0, import_ai.redactValue)(err instanceof Error ? err.message : String(err));
       }
     }
   }
+  resultContent = (0, import_ai.redactValue)(resultContent);
+  details = (0, import_ai.redactValue)(details);
   const durationMs = Date.now() - startTime;
   pushEvent({
     type: "tool_call_end",