@aexol/spectral 0.9.229 → 0.9.231

package/dist/sdk/agent-core/agent-loop.js

@@ -2,7 +2,10 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { EventStream, formatPaymentRequiredMessage, formatRateLimitRetryMessage, getRateLimitRetryDelayMs, isPaymentRequiredError, MAX_RATE_LIMIT_RETRIES, streamSimple, isRateLimitError, isTransientApiError, validateToolArguments, } from "../ai/index.js";
+import { EventStream, formatPaymentRequiredMessage, formatRateLimitRetryMessage, getRateLimitRetryDelayMs, isPaymentRequiredError, MAX_RATE_LIMIT_RETRIES, streamSimple, isRateLimitError, isTransientApiError, } from "../ai/index.js";
+import { executeToolCalls } from "./tool-execution.js";
+// Re-exported for backwards compatibility (moved to tool-execution.ts).
+export { hasMissingRequiredArguments } from "./tool-execution.js";
 /** Maximum consecutive tool call errors before terminating the loop. */
 const MAX_CONSECUTIVE_TOOL_ERRORS = 10;
 /** Maximum retries for transient provider API errors. */
@@ -432,290 +435,3 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
     await emit({ type: "message_end", message: finalMessage });
     return finalMessage;
 }
-/**
- * Execute tool calls from an assistant message.
- */
-async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
-    const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
-    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode ===
-        "sequential");
-    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
-        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
-    }
-    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
-}
-async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
-    const finalizedCalls = [];
-    const messages = [];
-    for (const toolCall of toolCalls) {
-        await emit({
-            type: "tool_execution_start",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            args: toolCall.arguments,
-        });
-        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
-        let finalized;
-        if (preparation.kind === "immediate") {
-            finalized = {
-                toolCall,
-                result: preparation.result,
-                isError: preparation.isError,
-            };
-        }
-        else {
-            const executed = await executePreparedToolCall(preparation, signal, emit);
-            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
-        }
-        await emitToolExecutionEnd(finalized, emit);
-        const toolResultMessage = createToolResultMessage(finalized);
-        await emitToolResultMessage(toolResultMessage, emit);
-        finalizedCalls.push(finalized);
-        messages.push(toolResultMessage);
-        if (signal?.aborted) {
-            break;
-        }
-    }
-    return {
-        messages,
-        terminate: shouldTerminateToolBatch(finalizedCalls),
-    };
-}
-async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
-    const finalizedCalls = [];
-    for (const toolCall of toolCalls) {
-        await emit({
-            type: "tool_execution_start",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            args: toolCall.arguments,
-        });
-        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
-        if (preparation.kind === "immediate") {
-            const finalized = {
-                toolCall,
-                result: preparation.result,
-                isError: preparation.isError,
-            };
-            await emitToolExecutionEnd(finalized, emit);
-            finalizedCalls.push(finalized);
-            if (signal?.aborted) {
-                break;
-            }
-            continue;
-        }
-        finalizedCalls.push(async () => {
-            const executed = await executePreparedToolCall(preparation, signal, emit);
-            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
-            await emitToolExecutionEnd(finalized, emit);
-            return finalized;
-        });
-        if (signal?.aborted) {
-            break;
-        }
-    }
-    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => typeof entry === "function" ? entry() : Promise.resolve(entry)));
-    const messages = [];
-    for (const finalized of orderedFinalizedCalls) {
-        const toolResultMessage = createToolResultMessage(finalized);
-        await emitToolResultMessage(toolResultMessage, emit);
-        messages.push(toolResultMessage);
-    }
-    return {
-        messages,
-        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
-    };
-}
-function shouldTerminateToolBatch(finalizedCalls) {
-    return (finalizedCalls.length > 0 &&
-        finalizedCalls.every((finalized) => finalized.result.terminate === true));
-}
-function prepareToolCallArguments(tool, toolCall) {
-    if (!tool.prepareArguments) {
-        return toolCall;
-    }
-    const preparedArguments = tool.prepareArguments(toolCall.arguments);
-    if (preparedArguments === toolCall.arguments) {
-        return toolCall;
-    }
-    return {
-        ...toolCall,
-        arguments: preparedArguments,
-    };
-}
-async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
-    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
-    if (!tool) {
-        return {
-            kind: "immediate",
-            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
-            isError: true,
-        };
-    }
-    // If the provider truncated the response mid tool-call (stopReason "length"),
-    // the streaming JSON parser may have produced an empty or incomplete arguments
-    // object. Validating it would surface a raw `Validation failed ... You provided:
-    // {}` error to the model. Instead, return a soft error so the agent-session
-    // length-continuation path (which treats truncated tool calls as visible output)
-    // can resubmit and let the model re-emit the full tool call.
-    if (assistantMessage.stopReason === "length" && hasMissingRequiredArguments(tool, toolCall)) {
-        return {
-            kind: "immediate",
-            result: createErrorToolResult(`Tool "${toolCall.name}" was truncated before its arguments were fully emitted. ` +
-                `Retrying: please re-emit the complete tool call with all required parameters.`),
-            isError: true,
-        };
-    }
-    try {
-        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
-        const validatedArgs = validateToolArguments(tool, preparedToolCall);
-        if (config.beforeToolCall) {
-            const beforeResult = await config.beforeToolCall({
-                assistantMessage,
-                toolCall,
-                args: validatedArgs,
-                context: currentContext,
-            }, signal);
-            if (signal?.aborted) {
-                return {
-                    kind: "immediate",
-                    result: createErrorToolResult("Operation aborted"),
-                    isError: true,
-                };
-            }
-            if (beforeResult?.block) {
-                return {
-                    kind: "immediate",
-                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
-                    isError: true,
-                };
-            }
-        }
-        if (signal?.aborted) {
-            return {
-                kind: "immediate",
-                result: createErrorToolResult("Operation aborted"),
-                isError: true,
-            };
-        }
-        return {
-            kind: "prepared",
-            toolCall,
-            tool,
-            args: validatedArgs,
-        };
-    }
-    catch (error) {
-        return {
-            kind: "immediate",
-            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
-            isError: true,
-        };
-    }
-}
-async function executePreparedToolCall(prepared, signal, emit) {
-    const updateEvents = [];
-    try {
-        const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
-            updateEvents.push(Promise.resolve(emit({
-                type: "tool_execution_update",
-                toolCallId: prepared.toolCall.id,
-                toolName: prepared.toolCall.name,
-                args: prepared.toolCall.arguments,
-                partialResult,
-            })));
-        });
-        await Promise.all(updateEvents);
-        return { result, isError: false };
-    }
-    catch (error) {
-        await Promise.all(updateEvents);
-        return {
-            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
-            isError: true,
-        };
-    }
-}
-async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
-    let result = executed.result;
-    let isError = executed.isError;
-    if (config.afterToolCall) {
-        try {
-            const afterResult = await config.afterToolCall({
-                assistantMessage,
-                toolCall: prepared.toolCall,
-                args: prepared.args,
-                result,
-                isError,
-                context: currentContext,
-            }, signal);
-            if (afterResult) {
-                result = {
-                    content: afterResult.content ?? result.content,
-                    details: afterResult.details ?? result.details,
-                    terminate: afterResult.terminate ?? result.terminate,
-                };
-                isError = afterResult.isError ?? isError;
-            }
-        }
-        catch (error) {
-            result = createErrorToolResult(error instanceof Error ? error.message : String(error));
-            isError = true;
-        }
-    }
-    return {
-        toolCall: prepared.toolCall,
-        result,
-        isError,
-    };
-}
-function createErrorToolResult(message) {
-    return {
-        content: [{ type: "text", text: message }],
-        details: {},
-    };
-}
-/**
- * Detects whether a tool call is missing any required parameter, indicating the
- * provider truncated the response before the tool arguments were fully emitted.
- * Used together with `stopReason === "length"` to short-circuit tool validation
- * when a streamed tool call is incomplete (which would otherwise throw
- * `Validation failed ... You provided: {}`).
- */
-export function hasMissingRequiredArguments(tool, toolCall) {
-    const schema = tool.parameters;
-    const required = schema.required;
-    if (!Array.isArray(required) || required.length === 0)
-        return false;
-    const args = toolCall.arguments;
-    if (!args || typeof args !== "object")
-        return true;
-    return required.some((key) => !(key in args) ||
-        args[key] === undefined ||
-        args[key] === null ||
-        (typeof args[key] === "string" && args[key].trim() === ""));
-}
-async function emitToolExecutionEnd(finalized, emit) {
-    await emit({
-        type: "tool_execution_end",
-        toolCallId: finalized.toolCall.id,
-        toolName: finalized.toolCall.name,
-        result: finalized.result,
-        isError: finalized.isError,
-    });
-}
-function createToolResultMessage(finalized) {
-    return {
-        role: "toolResult",
-        toolCallId: finalized.toolCall.id,
-        toolName: finalized.toolCall.name,
-        content: finalized.result.content,
-        details: finalized.result.details,
-        isError: finalized.isError,
-        timestamp: Date.now(),
-    };
-}
-async function emitToolResultMessage(toolResultMessage, emit) {
-    await emit({ type: "message_start", message: toolResultMessage });
-    await emit({ type: "message_end", message: toolResultMessage });
-}

package/dist/sdk/agent-core/tool-execution.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Tool call execution for the agent loop.
+ *
+ * `executeToolCalls` runs every tool call of an assistant message —
+ * sequentially (`toolExecution: "sequential"` or any tool declaring
+ * `executionMode: "sequential"`) or in parallel — and returns the
+ * `ToolResultMessage`s plus a `terminate` flag for the loop.
+ *
+ * Extracted from `sdk/agent-core/agent-loop.ts` — the loop module
+ * re-exports `hasMissingRequiredArguments` so existing imports keep
+ * working.
+ */
+import { type AssistantMessage, type ToolResultMessage } from "../ai/index.js";
+import type { AgentContext, AgentLoopConfig, AgentTool, AgentToolCall } from "./types.js";
+import type { AgentEventSink } from "./agent-loop.js";
+/**
+ * Execute tool calls from an assistant message.
+ */
+export declare function executeToolCalls(currentContext: AgentContext, assistantMessage: AssistantMessage, config: AgentLoopConfig, signal: AbortSignal | undefined, emit: AgentEventSink): Promise<ExecutedToolCallBatch>;
+type ExecutedToolCallBatch = {
+    messages: ToolResultMessage[];
+    terminate: boolean;
+};
+/**
+ * Detects whether a tool call is missing any required parameter, indicating the
+ * provider truncated the response before the tool arguments were fully emitted.
+ * Used together with `stopReason === "length"` to short-circuit tool validation
+ * when a streamed tool call is incomplete (which would otherwise throw
+ * `Validation failed ... You provided: {}`).
+ */
+export declare function hasMissingRequiredArguments(tool: AgentTool<any>, toolCall: AgentToolCall): boolean;
+export {};
+//# sourceMappingURL=tool-execution.d.ts.map

package/dist/sdk/agent-core/tool-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-execution.d.ts","sourceRoot":"","sources":["../../../src/sdk/agent-core/tool-execution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,SAAS,EACT,aAAa,EAEd,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,cAAc,EAAE,YAAY,EAC5B,gBAAgB,EAAE,gBAAgB,EAClC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,qBAAqB,CAAC,CA2BhC;AAED,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmXF;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAYlG"}

package/dist/sdk/agent-core/tool-execution.js

@@ -0,0 +1,300 @@
+/**
+ * Tool call execution for the agent loop.
+ *
+ * `executeToolCalls` runs every tool call of an assistant message —
+ * sequentially (`toolExecution: "sequential"` or any tool declaring
+ * `executionMode: "sequential"`) or in parallel — and returns the
+ * `ToolResultMessage`s plus a `terminate` flag for the loop.
+ *
+ * Extracted from `sdk/agent-core/agent-loop.ts` — the loop module
+ * re-exports `hasMissingRequiredArguments` so existing imports keep
+ * working.
+ */
+import { validateToolArguments, } from "../ai/index.js";
+/**
+ * Execute tool calls from an assistant message.
+ */
+export async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
+    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode ===
+        "sequential");
+    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    const messages = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        let finalized;
+        if (preparation.kind === "immediate") {
+            finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+        }
+        else {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        finalizedCalls.push(finalized);
+        messages.push(toolResultMessage);
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments,
+        });
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        if (preparation.kind === "immediate") {
+            const finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+            await emitToolExecutionEnd(finalized, emit);
+            finalizedCalls.push(finalized);
+            if (signal?.aborted) {
+                break;
+            }
+            continue;
+        }
+        finalizedCalls.push(async () => {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        });
+        if (signal?.aborted) {
+            break;
+        }
+    }
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => typeof entry === "function" ? entry() : Promise.resolve(entry)));
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+function shouldTerminateToolBatch(finalizedCalls) {
+    return (finalizedCalls.length > 0 &&
+        finalizedCalls.every((finalized) => finalized.result.terminate === true));
+}
+function prepareToolCallArguments(tool, toolCall) {
+    if (!tool.prepareArguments) {
+        return toolCall;
+    }
+    const preparedArguments = tool.prepareArguments(toolCall.arguments);
+    if (preparedArguments === toolCall.arguments) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        arguments: preparedArguments,
+    };
+}
+async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
+        };
+    }
+    // If the provider truncated the response mid tool-call (stopReason "length"),
+    // the streaming JSON parser may have produced an empty or incomplete arguments
+    // object. Validating it would surface a raw `Validation failed ... You provided:
+    // {}` error to the model. Instead, return a soft error so the agent-session
+    // length-continuation path (which treats truncated tool calls as visible output)
+    // can resubmit and let the model re-emit the full tool call.
+    if (assistantMessage.stopReason === "length" && hasMissingRequiredArguments(tool, toolCall)) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(`Tool "${toolCall.name}" was truncated before its arguments were fully emitted. ` +
+                `Retrying: please re-emit the complete tool call with all required parameters.`),
+            isError: true,
+        };
+    }
+    try {
+        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
+        const validatedArgs = validateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal);
+            if (signal?.aborted) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult("Operation aborted"),
+                    isError: true,
+                };
+            }
+            if (beforeResult?.block) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
+                    isError: true,
+                };
+            }
+        }
+        if (signal?.aborted) {
+            return {
+                kind: "immediate",
+                result: createErrorToolResult("Operation aborted"),
+                isError: true,
+            };
+        }
+        return {
+            kind: "prepared",
+            toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function executePreparedToolCall(prepared, signal, emit) {
+    const updateEvents = [];
+    try {
+        const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
+            updateEvents.push(Promise.resolve(emit({
+                type: "tool_execution_update",
+                toolCallId: prepared.toolCall.id,
+                toolName: prepared.toolCall.name,
+                args: prepared.toolCall.arguments,
+                partialResult,
+            })));
+        });
+        await Promise.all(updateEvents);
+        return { result, isError: false };
+    }
+    catch (error) {
+        await Promise.all(updateEvents);
+        return {
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
+    let result = executed.result;
+    let isError = executed.isError;
+    if (config.afterToolCall) {
+        try {
+            const afterResult = await config.afterToolCall({
+                assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                result,
+                isError,
+                context: currentContext,
+            }, signal);
+            if (afterResult) {
+                result = {
+                    content: afterResult.content ?? result.content,
+                    details: afterResult.details ?? result.details,
+                    terminate: afterResult.terminate ?? result.terminate,
+                };
+                isError = afterResult.isError ?? isError;
+            }
+        }
+        catch (error) {
+            result = createErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function createErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        details: {},
+    };
+}
+/**
+ * Detects whether a tool call is missing any required parameter, indicating the
+ * provider truncated the response before the tool arguments were fully emitted.
+ * Used together with `stopReason === "length"` to short-circuit tool validation
+ * when a streamed tool call is incomplete (which would otherwise throw
+ * `Validation failed ... You provided: {}`).
+ */
+export function hasMissingRequiredArguments(tool, toolCall) {
+    const schema = tool.parameters;
+    const required = schema.required;
+    if (!Array.isArray(required) || required.length === 0)
+        return false;
+    const args = toolCall.arguments;
+    if (!args || typeof args !== "object")
+        return true;
+    return required.some((key) => !(key in args) ||
+        args[key] === undefined ||
+        args[key] === null ||
+        (typeof args[key] === "string" && args[key].trim() === ""));
+}
+async function emitToolExecutionEnd(finalized, emit) {
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
+    });
+}
+function createToolResultMessage(finalized) {
+    return {
+        role: "toolResult",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        content: finalized.result.content,
+        details: finalized.result.details,
+        isError: finalized.isError,
+        timestamp: Date.now(),
+    };
+}
+async function emitToolResultMessage(toolResultMessage, emit) {
+    await emit({ type: "message_start", message: toolResultMessage });
+    await emit({ type: "message_end", message: toolResultMessage });
+}

package/dist/sdk/ai/env-api-keys.js

@@ -1,8 +1,16 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 // NEVER convert to top-level imports - breaks browser/Vite builds
 let _existsSync = null;
 let _homedir = null;
 let _join = null;
-const dynamicImport = (specifier) => import(specifier);
+const dynamicImport = (specifier) => import(__rewriteRelativeImportExtension(specifier));
 const NODE_FS_SPECIFIER = "node:" + "fs";
 const NODE_OS_SPECIFIER = "node:" + "os";
 const NODE_PATH_SPECIFIER = "node:" + "path";