@opencode-ai/ai 0.0.0-next-15809 → 0.0.0-next-15811

package/dist/protocols/utils/tool-stream.js

@@ -14,6 +14,7 @@ const withoutTool = (tools, key) => {
 const inputStart = (tool) => LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
+    providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
 });
 const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
@@ -21,13 +22,27 @@ const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
     name: tool.name,
     text,
 });
-const toolCall = (route, tool, inputOverride) => parseToolInput(route, tool.name, inputOverride ?? tool.input).pipe(Effect.map((input) => LLMEvent.toolCall({
-    id: tool.id,
-    name: tool.name,
-    input,
-    providerExecuted: tool.providerExecuted ? true : undefined,
-    providerMetadata: tool.providerMetadata,
-})));
+const toolCall = (route, tool, inputOverride) => {
+    const raw = inputOverride ?? tool.input;
+    return parseToolInput(route, tool.name, raw).pipe(Effect.map((input) => LLMEvent.toolCall({
+        id: tool.id,
+        name: tool.name,
+        input,
+        providerExecuted: tool.providerExecuted ? true : undefined,
+        providerMetadata: tool.providerMetadata,
+    })), Effect.catch((error) => tool.providerExecuted
+        ? Effect.fail(error)
+        : Effect.succeed(LLMEvent.toolInputError({
+            id: tool.id,
+            name: tool.name,
+            raw,
+            message: error.reason.message,
+            providerMetadata: tool.providerMetadata,
+        }))));
+};
+const finishEvents = (tool, event) => event.type === "tool-input-error"
+    ? [event]
+    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event];
 /** Store the updated tool and produce the optional public delta event. */
 const appendTool = (tools, key, tool, text) => {
     const events = [];
@@ -86,8 +101,9 @@ export const appendExisting = (route, tools, key, text, missingToolMessage) => {
 };
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return the optional public `tool-call` event. Missing keys are
- * a no-op because some providers emit stop events for non-tool content blocks.
+ * from state, and return either a call or a non-executable local input error.
+ * Missing keys are a no-op because some providers emit stop events for
+ * non-tool content blocks.
  */
 export const finish = (route, tools, key) => Effect.gen(function* () {
     const tool = tools[key];
@@ -95,10 +111,7 @@ export const finish = (route, tools, key) => Effect.gen(function* () {
         return { tools };
     return {
         tools: withoutTool(tools, key),
-        events: [
-            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
-            yield* toolCall(route, tool),
-        ],
+        events: finishEvents(tool, yield* toolCall(route, tool)),
     };
 });
 /**
@@ -112,25 +125,19 @@ export const finishWithInput = (route, tools, key, input) => Effect.gen(function
         return { tools };
     return {
         tools: withoutTool(tools, key),
-        events: [
-            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
-            yield* toolCall(route, tool, input),
-        ],
+        events: finishEvents(tool, yield* toolCall(route, tool, input)),
     };
 });
 /**
  * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
- * not emit per-tool stop events, so all accumulated calls finish when the choice
- * receives a terminal `finish_reason`.
+ * not emit per-tool stop events, so all accumulated calls finish independently
+ * when the choice receives a terminal `finish_reason`.
  */
 export const finishAll = (route, tools) => Effect.gen(function* () {
     const pending = Object.values(tools).filter((tool) => tool !== undefined);
     return {
         tools: empty(),
-        events: yield* Effect.forEach(pending, (tool) => toolCall(route, tool).pipe(Effect.map((call) => [
-            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
-            call,
-        ]))).pipe(Effect.map((events) => events.flat())),
+        events: yield* Effect.forEach(pending, (tool) => toolCall(route, tool).pipe(Effect.map((event) => finishEvents(tool, event)))).pipe(Effect.map((events) => events.flat())),
     };
 });
 export * as ToolStream from "./tool-stream";

package/dist/route/client.d.ts

@@ -208,6 +208,7 @@ export declare const streamRequest: (request: LLMRequest) => Stream.Stream<Schem
             readonly [x: string]: unknown;
         };
     } | undefined;
+    readonly providerExecuted?: boolean | undefined;
 } | Schema.Struct.ReadonlySide<{
     readonly type: Schema.tag<"tool-input-delta">;
     readonly id: Schema.String;
@@ -222,6 +223,17 @@ export declare const streamRequest: (request: LLMRequest) => Stream.Stream<Schem
             readonly [x: string]: unknown;
         };
     } | undefined;
+} | {
+    readonly type: "tool-input-error";
+    readonly name: string;
+    readonly id: string;
+    readonly message: string;
+    readonly raw: string;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "tool-call";
     readonly name: string;