@botbotgo/agent-harness 0.0.101 → 0.0.102

package/dist/resource/mcp-tool-support.js

@@ -0,0 +1,173 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+import { AGENT_HARNESS_VERSION } from "../package-version.js";
+import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
+const mcpClientCache = new Map();
+function readStringRecord(value) {
+    if (typeof value !== "object" || !value) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeMcpTransport(value) {
+    if (value === "stdio" || value === "http" || value === "sse" || value === "websocket") {
+        return value;
+    }
+    return undefined;
+}
+export function readMcpServerConfig(workspace, tool) {
+    const mcpConfig = typeof tool.config?.mcp === "object" && tool.config?.mcp
+        ? tool.config.mcp
+        : undefined;
+    const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
+    if (serverRef) {
+        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
+        const server = workspace.mcpServers.get(serverId);
+        if (!server) {
+            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
+        }
+        return {
+            transport: server.transport,
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            cwd: server.cwd,
+            url: server.url,
+            token: server.token,
+            headers: server.headers,
+        };
+    }
+    const config = typeof tool.config === "object" && tool.config
+        ? tool.config
+        : undefined;
+    const mcpServer = typeof config?.mcpServer === "object" && config.mcpServer
+        ? config.mcpServer
+        : config;
+    if (!mcpServer) {
+        return null;
+    }
+    return {
+        transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
+        command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
+        args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
+        env: readStringRecord(mcpServer.env),
+        cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
+        url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
+        token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
+        headers: readStringRecord(mcpServer.headers),
+    };
+}
+function createMcpCacheKey(config) {
+    return JSON.stringify({
+        transport: config.transport ?? "stdio",
+        command: config.command,
+        args: config.args ?? [],
+        env: config.env ?? {},
+        cwd: config.cwd ?? "",
+        url: config.url ?? "",
+        token: config.token ?? "",
+        headers: config.headers ?? {},
+    });
+}
+export async function getOrCreateMcpClient(config) {
+    const cacheKey = createMcpCacheKey(config);
+    const cached = mcpClientCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const loading = (async () => {
+        const client = new Client({
+            name: "agent-harness",
+            version: AGENT_HARNESS_VERSION,
+        });
+        const headers = {
+            ...(config.headers ?? {}),
+            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
+        };
+        const transport = config.transport === "http"
+            ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
+                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+            })
+            : config.transport === "sse"
+                ? new SSEClientTransport(new URL(config.url ?? ""), {
+                    requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
+                })
+                : config.transport === "websocket"
+                    ? new WebSocketClientTransport(new URL(config.url ?? ""))
+                    : new StdioClientTransport({
+                        command: config.command ?? "",
+                        args: config.args,
+                        env: createRuntimeEnv(config.env),
+                        cwd: config.cwd,
+                    });
+        await client.connect(transport);
+        return client;
+    })();
+    mcpClientCache.set(cacheKey, loading);
+    return loading;
+}
+async function getRemoteMcpToolDescriptor(config, remoteToolName) {
+    const client = await getOrCreateMcpClient(config);
+    const result = await client.listTools();
+    const tool = result.tools.find((item) => typeof item.name === "string" && item.name === remoteToolName);
+    if (!tool || typeof tool.name !== "string") {
+        return null;
+    }
+    return {
+        name: tool.name,
+        description: typeof tool.description === "string" ? tool.description : undefined,
+        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
+    };
+}
+export async function listRemoteMcpTools(config) {
+    const client = await getOrCreateMcpClient(config);
+    const result = await client.listTools();
+    return result.tools
+        .filter((tool) => typeof tool.name === "string")
+        .map((tool) => ({
+        name: tool.name,
+        description: typeof tool.description === "string" ? tool.description : undefined,
+        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
+    }));
+}
+export function createMcpToolResolver(workspace) {
+    const mcpTools = new Map(Array.from(workspace.tools.values())
+        .filter((tool) => tool.type === "mcp")
+        .map((tool) => [tool.id, tool]));
+    return (toolIds) => toolIds.flatMap((toolId) => {
+        const tool = mcpTools.get(toolId);
+        if (!tool) {
+            return [];
+        }
+        const serverConfig = readMcpServerConfig(workspace, tool);
+        if (!serverConfig) {
+            throw new Error(`MCP tool ${tool.id} must define mcp.serverRef or inline MCP server config.`);
+        }
+        const remoteToolName = tool.mcpRef ?? tool.name;
+        const descriptorPromise = getRemoteMcpToolDescriptor(serverConfig, remoteToolName);
+        return [
+            {
+                name: tool.name,
+                description: tool.description,
+                inputSchemaPromise: descriptorPromise.then((descriptor) => descriptor?.inputSchema),
+                async invoke(input) {
+                    const client = await getOrCreateMcpClient(serverConfig);
+                    const result = await client.callTool({
+                        name: remoteToolName,
+                        arguments: typeof input === "object" && input !== null ? input : {},
+                    });
+                    const textParts = Array.isArray(result.content)
+                        ? result.content
+                            .filter((item) => typeof item === "object" && item !== null && "type" in item)
+                            .flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : [])
+                        : [];
+                    return textParts.length > 0 ? textParts.join("\n\n") : JSON.stringify(result);
+                },
+            },
+        ];
+    });
+}

package/dist/resource/resource-impl.d.ts

@@ -1,5 +1,5 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, type McpServerConfig, type McpToolDescriptor, } from "./mcp-tool-support.js";
 export declare function resolveLocalResourceProviderEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
 export type ResourceToolInfo = {
     toolPath: string;
@@ -12,23 +12,6 @@ export type ResourceToolInfo = {
         allow: Array<"approve" | "edit" | "reject">;
     };
 };
-export type McpServerConfig = {
-    transport?: "stdio" | "http" | "sse" | "websocket";
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    url?: string;
-    token?: string;
-    headers?: Record<string, string>;
-};
-export type McpToolDescriptor = {
-    name: string;
-    description?: string;
-    inputSchema?: Record<string, unknown>;
-};
-export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
-export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
 export declare function ensureResourceSources(sources?: string[], workspaceRoot?: string): Promise<void>;
 export declare function defaultResourceSkillsRoot(): string;
 export declare function defaultResourceConfigRoot(): string;

package/dist/resource/resource-impl.js

@@ -5,16 +5,12 @@ import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { CompositeBackend, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import { AGENT_HARNESS_VERSION } from "../package-version.js";
-import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
+import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
+import { createMcpToolResolver, } from "./mcp-tool-support.js";
 import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
+export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, } from "./mcp-tool-support.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 function installedResourceProviderEntry() {
@@ -237,7 +233,6 @@ async function findPackageRoot(startPath) {
     }
 }
 const functionToolModuleCache = new Map();
-const mcpClientCache = new Map();
 function readStringRecord(value) {
     if (typeof value !== "object" || !value) {
         return undefined;
@@ -272,127 +267,6 @@ async function loadFunctionToolModule(tool) {
     functionToolModuleCache.set(cacheKey, loading);
     return loading;
 }
-function normalizeMcpTransport(value) {
-    if (value === "stdio" || value === "http" || value === "sse" || value === "websocket") {
-        return value;
-    }
-    return undefined;
-}
-function readMcpServerConfig(workspace, tool) {
-    const mcpConfig = typeof tool.config?.mcp === "object" && tool.config?.mcp
-        ? tool.config.mcp
-        : undefined;
-    const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
-    if (serverRef) {
-        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
-        const server = workspace.mcpServers.get(serverId);
-        if (!server) {
-            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
-        }
-        return {
-            transport: server.transport,
-            command: server.command,
-            args: server.args,
-            env: server.env,
-            cwd: server.cwd,
-            url: server.url,
-            token: server.token,
-            headers: server.headers,
-        };
-    }
-    const config = typeof tool.config === "object" && tool.config
-        ? tool.config
-        : undefined;
-    const mcpServer = typeof config?.mcpServer === "object" && config.mcpServer
-        ? config.mcpServer
-        : config;
-    if (!mcpServer) {
-        return null;
-    }
-    return {
-        transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
-        command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
-        args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
-        env: readStringRecord(mcpServer.env),
-        cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
-        url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
-        token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
-        headers: readStringRecord(mcpServer.headers),
-    };
-}
-function createMcpCacheKey(config) {
-    return JSON.stringify({
-        transport: config.transport ?? "stdio",
-        command: config.command,
-        args: config.args ?? [],
-        env: config.env ?? {},
-        cwd: config.cwd ?? "",
-        url: config.url ?? "",
-        token: config.token ?? "",
-        headers: config.headers ?? {},
-    });
-}
-export async function getOrCreateMcpClient(config) {
-    const cacheKey = createMcpCacheKey(config);
-    const cached = mcpClientCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const loading = (async () => {
-        const client = new Client({
-            name: "agent-harness",
-            version: AGENT_HARNESS_VERSION,
-        });
-        const headers = {
-            ...(config.headers ?? {}),
-            ...(config.token ? { Authorization: `Bearer ${config.token}` } : {}),
-        };
-        const transport = config.transport === "http"
-            ? new StreamableHTTPClientTransport(new URL(config.url ?? ""), {
-                requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-            })
-            : config.transport === "sse"
-                ? new SSEClientTransport(new URL(config.url ?? ""), {
-                    requestInit: Object.keys(headers).length > 0 ? { headers } : undefined,
-                })
-                : config.transport === "websocket"
-                    ? new WebSocketClientTransport(new URL(config.url ?? ""))
-                    : new StdioClientTransport({
-                        command: config.command ?? "",
-                        args: config.args,
-                        env: createRuntimeEnv(config.env),
-                        cwd: config.cwd,
-                    });
-        await client.connect(transport);
-        return client;
-    })();
-    mcpClientCache.set(cacheKey, loading);
-    return loading;
-}
-async function getRemoteMcpToolDescriptor(config, remoteToolName) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
-    const tool = result.tools.find((item) => typeof item.name === "string" && item.name === remoteToolName);
-    if (!tool || typeof tool.name !== "string") {
-        return null;
-    }
-    return {
-        name: tool.name,
-        description: typeof tool.description === "string" ? tool.description : undefined,
-        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
-    };
-}
-export async function listRemoteMcpTools(config) {
-    const client = await getOrCreateMcpClient(config);
-    const result = await client.listTools();
-    return result.tools
-        .filter((tool) => typeof tool.name === "string")
-        .map((tool) => ({
-        name: tool.name,
-        description: typeof tool.description === "string" ? tool.description : undefined,
-        inputSchema: typeof tool.inputSchema === "object" && tool.inputSchema ? tool.inputSchema : undefined,
-    }));
-}
 function createFunctionToolResolver(workspace) {
     const functionTools = new Map(Array.from(workspace.tools.values())
         .filter((tool) => tool.type === "function" && isSupportedToolModulePath(tool.sourcePath))
@@ -421,43 +295,6 @@ function createFunctionToolResolver(workspace) {
         ];
     });
 }
-function createMcpToolResolver(workspace) {
-    const mcpTools = new Map(Array.from(workspace.tools.values())
-        .filter((tool) => tool.type === "mcp")
-        .map((tool) => [tool.id, tool]));
-    return (toolIds) => toolIds.flatMap((toolId) => {
-        const tool = mcpTools.get(toolId);
-        if (!tool) {
-            return [];
-        }
-        const serverConfig = readMcpServerConfig(workspace, tool);
-        if (!serverConfig) {
-            throw new Error(`MCP tool ${tool.id} must define mcp.serverRef or inline MCP server config.`);
-        }
-        const remoteToolName = tool.mcpRef ?? tool.name;
-        const descriptorPromise = getRemoteMcpToolDescriptor(serverConfig, remoteToolName);
-        return [
-            {
-                name: tool.name,
-                description: tool.description,
-                inputSchemaPromise: descriptorPromise.then((descriptor) => descriptor?.inputSchema),
-                async invoke(input) {
-                    const client = await getOrCreateMcpClient(serverConfig);
-                    const result = await client.callTool({
-                        name: remoteToolName,
-                        arguments: typeof input === "object" && input !== null ? input : {},
-                    });
-                    const textParts = Array.isArray(result.content)
-                        ? result.content
-                            .filter((item) => typeof item === "object" && item !== null && "type" in item)
-                            .flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : [])
-                        : [];
-                    return textParts.length > 0 ? textParts.join("\n\n") : JSON.stringify(result);
-                },
-            },
-        ];
-    });
-}
 function resolvePackageEntry(packageRoot, pkg) {
     const exportsField = pkg.exports;
     if (typeof exportsField === "string") {

package/dist/runtime/adapter/invoke-runtime.d.ts

@@ -0,0 +1,22 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import type { ExecutedToolResult } from "./invocation-result.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+export type ExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+export declare function invokeRuntimeWithLocalTools(options: {
+    binding: CompiledAgentBinding;
+    request: unknown;
+    resumePayload?: unknown;
+    primaryTools: CompiledTool[];
+    defersToUpstreamHitlExecution: boolean;
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, ExecutableTool>;
+    builtinExecutableTools: Map<string, ExecutableTool>;
+    callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+}): Promise<{
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+}>;

package/dist/runtime/adapter/invoke-runtime.js

@@ -0,0 +1,18 @@
+import { runLocalToolInvocationLoop } from "./local-tool-invocation.js";
+export async function invokeRuntimeWithLocalTools(options) {
+    if (options.resumePayload !== undefined || options.defersToUpstreamHitlExecution) {
+        return {
+            result: await options.callRuntimeWithToolParseRecovery(options.request),
+            executedToolResults: [],
+        };
+    }
+    return runLocalToolInvocationLoop({
+        binding: options.binding,
+        request: options.request,
+        primaryTools: options.primaryTools,
+        toolNameMapping: options.toolNameMapping,
+        executableTools: options.executableTools,
+        builtinExecutableTools: options.builtinExecutableTools,
+        callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+    });
+}

package/dist/runtime/adapter/stream-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { CompiledAgentBinding, CompiledTool, MessageContent, TranscriptMessage } from "../../contracts/types.js";
+import type { RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+type RunnableLike = {
+    stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+    streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
+};
+export declare function streamRuntimeExecution(options: {
+    binding: CompiledAgentBinding;
+    input: MessageContent;
+    threadId: string;
+    history: TranscriptMessage[];
+    runtimeOptions: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        runId?: string;
+    };
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+    forceInvokeFallback: boolean;
+    canUseDirectModelStream: boolean;
+    langChainStreamModel?: {
+        stream?: (input: unknown) => Promise<AsyncIterable<unknown>>;
+    };
+    createRunnable: () => Promise<RunnableLike>;
+    withTimeout: <T>(producer: () => T | Promise<T>, timeoutMs: number | undefined, operation: string, stage?: "stream" | "invoke") => Promise<T>;
+    iterateWithTimeout: <T>(iterable: AsyncIterable<T>, timeoutMs: number | undefined, operation: string, deadlineAt?: number, deadlineTimeoutMs?: number) => AsyncGenerator<T>;
+    invokeTimeoutMs?: number;
+    streamIdleTimeoutMs?: number;
+    streamDeadlineAt?: number;
+    invoke: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, history?: TranscriptMessage[], options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+    }) => Promise<{
+        output: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    applyStrictToolJsonInstruction: (binding: CompiledAgentBinding) => CompiledAgentBinding;
+    getSystemPrompt: (binding: CompiledAgentBinding) => string | undefined;
+    isLangChainBinding: (binding: CompiledAgentBinding) => boolean;
+    isDeepAgentBinding: (binding: CompiledAgentBinding) => boolean;
+    countConfiguredTools: (binding: CompiledAgentBinding) => number;
+}): AsyncGenerator<RuntimeStreamChunk | string>;
+export {};

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

@@ -0,0 +1,93 @@
+import { isToolCallParseFailure, sanitizeVisibleText, } 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";
+export async function* streamRuntimeExecution(options) {
+    const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
+    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)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+            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;
+                }
+                yield nextChunk.value;
+                nextChunk = await projected.next();
+            }
+            if (nextChunk.value.emittedContent || emitted) {
+                return;
+            }
+        }
+        const runnable = await options.createRunnable();
+        if (!options.forceInvokeFallback && typeof runnable.streamEvents === "function") {
+            const events = await options.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: options.threadId, run_id: options.runtimeOptions.runId }, version: "v2", ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}) }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
+            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,
+                });
+                for (const chunk of projectedChunks) {
+                    yield chunk;
+                }
+            }
+            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: { thread_id: options.threadId, run_id: options.runtimeOptions.runId } }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
+            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;
+                }
+                yield nextChunk.value;
+                nextChunk = await projected.next();
+            }
+            if (nextChunk.value.emittedContent || emitted) {
+                return;
+            }
+        }
+        const result = await options.invoke(options.binding, options.input, options.threadId, options.runtimeOptions.runId ?? options.threadId, undefined, options.history, options.runtimeOptions);
+        const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+            ? result.metadata.executedToolResults
+            : [];
+        for (const toolResult of executedToolResults) {
+            yield {
+                kind: "tool-result",
+                toolName: toolResult.toolName,
+                output: toolResult.output,
+                isError: toolResult.isError,
+            };
+        }
+        if (result.output) {
+            yield { kind: "content", content: sanitizeVisibleText(result.output) };
+        }
+    }
+    catch (error) {
+        if (options.countConfiguredTools(options.binding) > 0 &&
+            error instanceof Error &&
+            error.message.includes("does not support tool binding")) {
+            throw error;
+        }
+        if (!isToolCallParseFailure(error)) {
+            throw error;
+        }
+        const retried = await options.invoke(options.applyStrictToolJsonInstruction(options.binding), options.input, options.threadId, options.runtimeOptions.runId ?? options.threadId, undefined, options.history, options.runtimeOptions);
+        if (retried.output) {
+            yield { kind: "content", content: sanitizeVisibleText(retried.output) };
+        }
+    }
+}