@botbotgo/agent-harness 0.0.298 → 0.0.299

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -1,67 +1,477 @@
-import { isToolCallRecoveryFailure, resolveToolCallRecoveryInstruction, sanitizeVisibleText, } from "../../parsing/output-parsing.js";
+import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, shouldValidateExecutionWithoutToolEvidence, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, sanitizeVisibleText, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
 import { projectTextStreamChunks } from "../stream-text-consumption.js";
 import { computeRemainingTimeoutMs } from "../resilience.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
+function toVisibleContent(value) {
+    const extracted = extractVisibleOutput(value);
+    return extracted ? sanitizeVisibleText(extracted) : "";
+}
+function createProfileStep(id, kind, name, action, status, detail) {
+    return {
+        kind: "profile",
+        step: {
+            id,
+            kind,
+            name,
+            action,
+            status,
+            ...(detail ? { detail } : {}),
+        },
+    };
+}
+function startProfileStep(input) {
+    const startedAt = new Date().toISOString();
+    return {
+        startedAt,
+        chunk: createProfileStep(input.id, input.kind, input.name, input.action, "started", {
+            ...(input.detail ?? {}),
+            startedAt,
+        }),
+    };
+}
+function finishProfileStep(input) {
+    const endedAt = new Date().toISOString();
+    return createProfileStep(input.id, input.kind, input.name, input.action, input.status, {
+        ...(input.detail ?? {}),
+        startedAt: input.startedAt,
+        endedAt,
+        durationMs: Math.max(0, new Date(endedAt).getTime() - new Date(input.startedAt).getTime()),
+        ...(input.error !== undefined ? { error: input.error instanceof Error ? input.error.message : String(input.error) } : {}),
+    });
+}
 export async function* streamRuntimeExecution(options) {
     const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
+    let emittedUnsafeStreamSideEffects = false;
+    const shouldProfile = options.runtimeOptions.profiling === true;
+    const shouldValidateStreamOutput = shouldValidateExecutionWithoutToolEvidence(request);
+    const deferredStreamContent = [];
+    let sawRetrySafeInvalidToolSelectionError = false;
+    let sawNonRetrySafeToolSideEffects = false;
+    const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
+    const flushDeferredStreamContent = async function* () {
+        while (deferredStreamContent.length > 0) {
+            yield deferredStreamContent.shift();
+        }
+    };
     try {
         if (options.isLangChainBinding(options.binding) && options.canUseDirectModelStream && options.langChainStreamModel?.stream) {
-            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+            const modelStreamStart = startProfileStep({
+                id: "profile:agent:model-stream-start",
+                kind: "agent",
+                name: "model stream",
+                action: "start",
+            });
+            if (shouldProfile)
+                yield modelStreamStart.chunk;
+            let stream;
+            try {
+                stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:model-stream-start",
+                        kind: "agent",
+                        name: "model stream",
+                        action: "start",
+                        startedAt: modelStreamStart.startedAt,
+                        status: "completed",
+                    });
+            }
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:model-stream-start",
+                        kind: "agent",
+                        name: "model stream",
+                        action: "start",
+                        startedAt: modelStreamStart.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
+            }
             let emitted = false;
             const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "model stream", options.streamDeadlineAt, options.invokeTimeoutMs));
-            let nextChunk = await projected.next();
-            while (!nextChunk.done) {
-                if (nextChunk.value.kind === "content") {
-                    emitted = true;
+            const modelStreamConsume = startProfileStep({
+                id: "profile:agent:model-stream-consume",
+                kind: "agent",
+                name: "model stream",
+                action: "consume",
+            });
+            if (shouldProfile)
+                yield modelStreamConsume.chunk;
+            try {
+                let currentChunk = await projected.next();
+                while (!currentChunk.done) {
+                    if (currentChunk.value.kind === "content") {
+                        emitted = true;
+                        emittedUnsafeStreamSideEffects = true;
+                    }
+                    yield currentChunk.value;
+                    currentChunk = await projected.next();
+                }
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:model-stream-consume",
+                        kind: "agent",
+                        name: "model stream",
+                        action: "consume",
+                        startedAt: modelStreamConsume.startedAt,
+                        status: "completed",
+                    });
+                if (currentChunk.value.emittedContent || emitted) {
+                    return;
                 }
-                yield nextChunk.value;
-                nextChunk = await projected.next();
             }
-            if (nextChunk.value.emittedContent || emitted) {
-                return;
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:model-stream-consume",
+                        kind: "agent",
+                        name: "model stream",
+                        action: "consume",
+                        startedAt: modelStreamConsume.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
             }
         }
-        const runnable = await options.createRunnable();
+        const createRunnableStep = startProfileStep({
+            id: "profile:agent:create-runnable",
+            kind: "agent",
+            name: "create runnable",
+            action: "startup",
+        });
+        if (shouldProfile)
+            yield createRunnableStep.chunk;
+        let runnable;
+        try {
+            runnable = await options.createRunnable();
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:create-runnable",
+                    kind: "agent",
+                    name: "create runnable",
+                    action: "startup",
+                    startedAt: createRunnableStep.startedAt,
+                    status: "completed",
+                });
+        }
+        catch (error) {
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:create-runnable",
+                    kind: "agent",
+                    name: "create runnable",
+                    action: "startup",
+                    startedAt: createRunnableStep.startedAt,
+                    status: "failed",
+                    error,
+                });
+            throw error;
+        }
         if (!options.forceInvokeFallback && typeof runnable.streamEvents === "function") {
-            const events = await options.withTimeout(() => runnable.streamEvents(request, { configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId }, version: "v2", ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}) }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
+            const streamEventsStart = startProfileStep({
+                id: "profile:agent:stream-events-start",
+                kind: "agent",
+                name: "streamEvents",
+                action: "start",
+            });
+            if (shouldProfile)
+                yield streamEventsStart.chunk;
+            let events;
+            try {
+                events = await options.withTimeout(() => runnable.streamEvents(request, {
+                    configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId },
+                    version: "v2",
+                    ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}),
+                    ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
+                }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-events-start",
+                        kind: "agent",
+                        name: "streamEvents",
+                        action: "start",
+                        startedAt: streamEventsStart.startedAt,
+                        status: "completed",
+                    });
+            }
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-events-start",
+                        kind: "agent",
+                        name: "streamEvents",
+                        action: "start",
+                        startedAt: streamEventsStart.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
+            }
             const projectionState = createStreamEventProjectionState();
-            for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
-                const projectedChunks = projectRuntimeStreamEvent({
-                    event,
-                    allowVisibleStreamDeltas: options.isLangChainBinding(options.binding),
-                    includeStateStreamOutput: options.isDeepAgentBinding(options.binding),
-                    toolNameMapping: options.toolNameMapping,
-                    primaryTools: options.primaryTools,
-                    state: projectionState,
+            const streamEventsConsume = startProfileStep({
+                id: "profile:agent:stream-events-consume",
+                kind: "agent",
+                name: "streamEvents",
+                action: "consume",
+            });
+            if (shouldProfile)
+                yield streamEventsConsume.chunk;
+            try {
+                for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
+                    const projectedChunks = projectRuntimeStreamEvent({
+                        event,
+                        allowVisibleStreamDeltas: options.isLangChainBinding(options.binding),
+                        includeStateStreamOutput: options.isDeepAgentBinding(options.binding),
+                        toolNameMapping: options.toolNameMapping,
+                        primaryTools: options.primaryTools,
+                        state: projectionState,
+                    });
+                    const eventContainsNonTodoToolResult = projectedChunks.some((chunk) => chunk.kind === "tool-result"
+                        && chunk.toolName !== "write_todos"
+                        && !(chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)));
+                    const eventContainsNonRetrySafeChunk = projectedChunks.some((chunk) => chunk.kind !== "upstream-event"
+                        && chunk.kind !== "content"
+                        && !(chunk.kind === "tool-result" && chunk.toolName === "write_todos")
+                        && !(chunk.kind === "tool-result" && chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)));
+                    for (const chunk of projectedChunks) {
+                        if (chunk.kind === "tool-result" && chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)) {
+                            sawRetrySafeInvalidToolSelectionError = true;
+                        }
+                        if ((eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) && deferredStreamContent.length > 0) {
+                            yield* flushDeferredStreamContent();
+                        }
+                        if (eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) {
+                            emittedUnsafeStreamSideEffects = true;
+                            sawNonRetrySafeToolSideEffects = true;
+                        }
+                        if (chunk.kind === "content" && shouldDeferStreamContent()) {
+                            deferredStreamContent.push(chunk);
+                            continue;
+                        }
+                        yield chunk;
+                    }
+                }
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-events-consume",
+                        kind: "agent",
+                        name: "streamEvents",
+                        action: "consume",
+                        startedAt: streamEventsConsume.startedAt,
+                        status: "completed",
+                    });
+            }
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-events-consume",
+                        kind: "agent",
+                        name: "streamEvents",
+                        action: "consume",
+                        startedAt: streamEventsConsume.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
+            }
+            const streamRecoveryInstruction = resolveExecutionWithoutToolEvidenceTextInstruction(request, projectionState.emittedOutput, projectionState.emittedToolResult || (projectionState.emittedToolError && (sawNonRetrySafeToolSideEffects || !sawRetrySafeInvalidToolSelectionError)));
+            const terminalRecoveryInstruction = streamRecoveryInstruction
+                ?? (!emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION : null);
+            if (!emittedUnsafeStreamSideEffects && terminalRecoveryInstruction) {
+                const toolRecovery = startProfileStep({
+                    id: "profile:agent:stream-output-recovery-fallback",
+                    kind: "agent",
+                    name: "stream output recovery fallback",
+                    action: "invoke",
+                    detail: {
+                        recoveryInstruction: terminalRecoveryInstruction,
+                    },
                 });
-                for (const chunk of projectedChunks) {
-                    yield chunk;
+                if (shouldProfile)
+                    yield toolRecovery.chunk;
+                let retried;
+                try {
+                    retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, terminalRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+                    if (shouldProfile)
+                        yield finishProfileStep({
+                            id: "profile:agent:stream-output-recovery-fallback",
+                            kind: "agent",
+                            name: "stream output recovery fallback",
+                            action: "invoke",
+                            startedAt: toolRecovery.startedAt,
+                            status: "completed",
+                            detail: {
+                                recoveryInstruction: terminalRecoveryInstruction,
+                            },
+                        });
+                }
+                catch (retryError) {
+                    if (shouldProfile)
+                        yield finishProfileStep({
+                            id: "profile:agent:stream-output-recovery-fallback",
+                            kind: "agent",
+                            name: "stream output recovery fallback",
+                            action: "invoke",
+                            startedAt: toolRecovery.startedAt,
+                            status: "failed",
+                            detail: {
+                                recoveryInstruction: terminalRecoveryInstruction,
+                            },
+                            error: retryError,
+                        });
+                    throw retryError;
+                }
+                const executedToolResults = Array.isArray(retried.metadata?.executedToolResults)
+                    ? retried.metadata.executedToolResults
+                    : [];
+                for (const toolResult of executedToolResults) {
+                    yield {
+                        kind: "tool-result",
+                        toolName: toolResult.toolName,
+                        output: toolResult.output,
+                        isError: toolResult.isError,
+                    };
                 }
+                if (retried.output) {
+                    const visible = toVisibleContent(retried.output);
+                    if (visible) {
+                        yield { kind: "content", content: visible };
+                    }
+                }
+                return;
+            }
+            if (deferredStreamContent.length > 0) {
+                yield* flushDeferredStreamContent();
             }
             if (projectionState.emittedOutput || projectionState.emittedToolResult || projectionState.emittedToolError) {
                 return;
             }
         }
         if (!options.forceInvokeFallback && options.isLangChainBinding(options.binding) && typeof runnable.stream === "function") {
-            const stream = await options.withTimeout(() => runnable.stream(request, { configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId } }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
+            const streamStart = startProfileStep({
+                id: "profile:agent:stream-start",
+                kind: "agent",
+                name: "stream",
+                action: "start",
+            });
+            if (shouldProfile)
+                yield streamStart.chunk;
+            let stream;
+            try {
+                stream = await options.withTimeout(() => runnable.stream(request, {
+                    configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId },
+                    ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
+                }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-start",
+                        kind: "agent",
+                        name: "stream",
+                        action: "start",
+                        startedAt: streamStart.startedAt,
+                        status: "completed",
+                    });
+            }
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-start",
+                        kind: "agent",
+                        name: "stream",
+                        action: "start",
+                        startedAt: streamStart.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
+            }
             let emitted = false;
             const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "agent stream", options.streamDeadlineAt, options.invokeTimeoutMs));
-            let nextChunk = await projected.next();
-            while (!nextChunk.done) {
-                if (nextChunk.value.kind === "content") {
-                    emitted = true;
+            const streamConsume = startProfileStep({
+                id: "profile:agent:stream-consume",
+                kind: "agent",
+                name: "stream",
+                action: "consume",
+            });
+            if (shouldProfile)
+                yield streamConsume.chunk;
+            try {
+                let nextChunk = await projected.next();
+                while (!nextChunk.done) {
+                    if (nextChunk.value.kind === "content") {
+                        emitted = true;
+                        emittedUnsafeStreamSideEffects = true;
+                    }
+                    yield nextChunk.value;
+                    nextChunk = await projected.next();
+                }
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-consume",
+                        kind: "agent",
+                        name: "stream",
+                        action: "consume",
+                        startedAt: streamConsume.startedAt,
+                        status: "completed",
+                    });
+                if (nextChunk.value.emittedContent || emitted) {
+                    return;
                 }
-                yield nextChunk.value;
-                nextChunk = await projected.next();
             }
-            if (nextChunk.value.emittedContent || emitted) {
-                return;
+            catch (error) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:stream-consume",
+                        kind: "agent",
+                        name: "stream",
+                        action: "consume",
+                        startedAt: streamConsume.startedAt,
+                        status: "failed",
+                        error,
+                    });
+                throw error;
             }
         }
-        const result = await options.invoke(options.binding, options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+        const invokeFallback = startProfileStep({
+            id: "profile:agent:invoke-fallback",
+            kind: "agent",
+            name: "invoke fallback",
+            action: "invoke",
+        });
+        if (shouldProfile)
+            yield invokeFallback.chunk;
+        let result;
+        try {
+            result = await options.invoke(options.binding, options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:invoke-fallback",
+                    kind: "agent",
+                    name: "invoke fallback",
+                    action: "invoke",
+                    startedAt: invokeFallback.startedAt,
+                    status: "completed",
+                });
+        }
+        catch (error) {
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:invoke-fallback",
+                    kind: "agent",
+                    name: "invoke fallback",
+                    action: "invoke",
+                    startedAt: invokeFallback.startedAt,
+                    status: "failed",
+                    error,
+                });
+            throw error;
+        }
         const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
             ? result.metadata.executedToolResults
             : [];
@@ -74,10 +484,76 @@ export async function* streamRuntimeExecution(options) {
             };
         }
         if (result.output) {
-            yield { kind: "content", content: sanitizeVisibleText(result.output) };
+            const visible = toVisibleContent(result.output);
+            if (visible) {
+                yield { kind: "content", content: visible };
+            }
         }
     }
     catch (error) {
+        if (!emittedUnsafeStreamSideEffects && options.isRetryableProviderError?.(options.binding, error)) {
+            const providerRetry = startProfileStep({
+                id: "profile:agent:provider-retry-fallback",
+                kind: "agent",
+                name: "provider retry fallback",
+                action: "invoke",
+                detail: {
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            if (shouldProfile)
+                yield providerRetry.chunk;
+            let recovered;
+            try {
+                recovered = await options.invoke(options.binding, options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:provider-retry-fallback",
+                        kind: "agent",
+                        name: "provider retry fallback",
+                        action: "invoke",
+                        startedAt: providerRetry.startedAt,
+                        status: "completed",
+                        detail: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+            }
+            catch (retryError) {
+                if (shouldProfile)
+                    yield finishProfileStep({
+                        id: "profile:agent:provider-retry-fallback",
+                        kind: "agent",
+                        name: "provider retry fallback",
+                        action: "invoke",
+                        startedAt: providerRetry.startedAt,
+                        status: "failed",
+                        detail: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                        error: retryError,
+                    });
+                throw retryError;
+            }
+            const executedToolResults = Array.isArray(recovered.metadata?.executedToolResults)
+                ? recovered.metadata.executedToolResults
+                : [];
+            for (const toolResult of executedToolResults) {
+                yield {
+                    kind: "tool-result",
+                    toolName: toolResult.toolName,
+                    output: toolResult.output,
+                    isError: toolResult.isError,
+                };
+            }
+            if (recovered.output) {
+                const visible = toVisibleContent(recovered.output);
+                if (visible) {
+                    yield { kind: "content", content: visible };
+                }
+            }
+            return;
+        }
         if (options.countConfiguredTools(options.binding) > 0 &&
             error instanceof Error &&
             error.message.includes("does not support tool binding")) {
@@ -90,9 +566,54 @@ export async function* streamRuntimeExecution(options) {
         if (!recoveryInstruction) {
             throw error;
         }
-        const retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, recoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+        const toolRecovery = startProfileStep({
+            id: "profile:agent:tool-recovery-fallback",
+            kind: "agent",
+            name: "tool recovery fallback",
+            action: "invoke",
+            detail: {
+                recoveryInstruction,
+            },
+        });
+        if (shouldProfile)
+            yield toolRecovery.chunk;
+        let retried;
+        try {
+            retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, recoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:tool-recovery-fallback",
+                    kind: "agent",
+                    name: "tool recovery fallback",
+                    action: "invoke",
+                    startedAt: toolRecovery.startedAt,
+                    status: "completed",
+                    detail: {
+                        recoveryInstruction,
+                    },
+                });
+        }
+        catch (retryError) {
+            if (shouldProfile)
+                yield finishProfileStep({
+                    id: "profile:agent:tool-recovery-fallback",
+                    kind: "agent",
+                    name: "tool recovery fallback",
+                    action: "invoke",
+                    startedAt: toolRecovery.startedAt,
+                    status: "failed",
+                    detail: {
+                        recoveryInstruction,
+                    },
+                    error: retryError,
+                });
+            throw retryError;
+        }
         if (retried.output) {
-            yield { kind: "content", content: sanitizeVisibleText(retried.output) };
+            const visible = toVisibleContent(retried.output);
+            if (visible) {
+                yield { kind: "content", content: visible };
+            }
         }
     }
 }

package/dist/runtime/adapter/invocation-result.js

@@ -1,4 +1,4 @@
-import { extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
+import { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
 import { buildStateSnapshot } from "./model/message-assembly.js";
 import { asRecord } from "./tool/resolved-tool.js";
 export function finalizeRequestResult(params) {
@@ -11,7 +11,8 @@ export function finalizeRequestResult(params) {
     if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
         throw new Error(emptyAssistantMessageFailure);
     }
-    const output = visibleOutput || toolFallback || JSON.stringify(result, null, 2);
+    const serializedResult = JSON.stringify(result, null, 2);
+    const output = visibleOutput || toolFallback || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
     const outputContent = extractOutputContent(result);
     const contentBlocks = extractContentBlocks(result);

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -4,7 +4,7 @@ import type { ExecutedToolResult } from "./invocation-result.js";
 type ExecutableTool = {
     name: string;
     schema: unknown;
-    invoke: (input: unknown) => Promise<unknown>;
+    invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
 };
 type LocalToolInvocationParams = {
     binding: CompiledAgentBinding;