effect 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/unstable/ai/LanguageModel.js

@@ -1,6 +1,6 @@
 import * as Effect from "../../Effect.js";
 import * as FiberSet from "../../FiberSet.js";
-import { constFalse } from "../../Function.js";
+import { constFalse, identity, pipe } from "../../Function.js";
 import * as Option from "../../Option.js";
 import * as Predicate from "../../Predicate.js";
 import * as Queue from "../../Queue.js";
@@ -15,6 +15,7 @@ import { defaultIdGenerator, IdGenerator } from "./IdGenerator.js";
 import * as InternalCodecTransformer from "./internal/codec-transformer.js";
 import * as Prompt from "./Prompt.js";
 import * as Response from "./Response.js";
+import * as ResponseIdTracker from "./ResponseIdTracker.js";
 import { CurrentSpanTransformer } from "./Telemetry.js";
 import * as Toolkit from "./Toolkit.js";
 // =============================================================================
@@ -45,20 +46,6 @@ import * as Toolkit from "./Toolkit.js";
  * @category services
  */
 export class LanguageModel extends /*#__PURE__*/ServiceMap.Service()("effect/unstable/ai/LanguageModel") {}
-/**
- * A `ServiceMap.Reference` that holds the current `CodecTransformer` used by
- * `LanguageModel.generateObject` to adapt structured output schemas for the
- * active provider.
- *
- * By default, this is the identity function (no transformation). Provider
- * packages (e.g. `@effect/ai-anthropic`) override this reference with a
- * provider-specific transformer so that schemas are automatically rewritten
- * before being sent to the model as well as before decoding the generated value.
- *
- * @since 4.0.0
- * @category services
- */
-export const CurrentCodecTransformer = InternalCodecTransformer.CurrentCodecTransformer;
 /**
  * The default codec transformer that passes schemas through without
  * provider-specific rewrites.
@@ -221,7 +208,7 @@ export class GenerateObjectResponse extends GenerateTextResponse {
  * @category constructors
  */
 export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
-  const codecTransformer = yield* InternalCodecTransformer.CurrentCodecTransformer;
+  const codecTransformer = params.codecTransformer ?? defaultCodecTransformer;
   const parentSpanTransformer = yield* Effect.serviceOption(CurrentSpanTransformer);
   const getSpanTransformer = Effect.serviceOption(CurrentSpanTransformer).pipe(Effect.map(Option.orElse(() => parentSpanTransformer)));
   const idGenerator = yield* Effect.serviceOption(IdGenerator).pipe(Effect.map(Option.getOrElse(() => defaultIdGenerator)));
@@ -239,7 +226,9 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
       responseFormat: {
         type: "text"
       },
-      span
+      span,
+      previousResponseId: undefined,
+      incrementalPrompt: undefined
     };
     const content = yield* generateContent(options, providerOptions);
     applySpanTransformer(spanTransformer, content, providerOptions);
@@ -250,7 +239,7 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
     reason: AiError.InvalidOutputError.fromSchemaError(error)
   }))), (effect, span) => Effect.withParentSpan(effect, span, {
     captureStackTrace: false
-  }), Effect.provideService(IdGenerator, idGenerator), Effect.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer)));
+  }), Effect.provideService(IdGenerator, idGenerator)));
   const generateObject = options => {
     const objectName = getObjectName(options.objectName, options.schema);
     return Effect.useSpan("LanguageModel.generateObject", {
@@ -270,7 +259,9 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           objectName,
           schema: options.schema
         },
-        span
+        span,
+        previousResponseId: undefined,
+        incrementalPrompt: undefined
       };
       const content = yield* generateContent(options, providerOptions);
       applySpanTransformer(spanTransformer, content, providerOptions);
@@ -294,7 +285,7 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
       reason: AiError.InvalidOutputError.fromSchemaError(error)
     }))), (effect, span) => Effect.withParentSpan(effect, span, {
       captureStackTrace: false
-    }), Effect.provideService(IdGenerator, idGenerator), Effect.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer)));
+    }), Effect.provideService(IdGenerator, idGenerator)));
   };
   const streamText = Effect.fnUntraced(function* (options) {
     const span = yield* Effect.makeSpanScoped("LanguageModel.streamText", {
@@ -310,7 +301,9 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
       responseFormat: {
         type: "text"
       },
-      span
+      span,
+      previousResponseId: undefined,
+      incrementalPrompt: undefined
     };
     // Resolve the content stream for the request
     const stream = yield* streamContent(options, providerOptions);
@@ -335,9 +328,23 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
     module: "LanguageModel",
     method: "streamText",
     reason: AiError.InvalidOutputError.fromSchemaError(error)
-  }) : error), Stream.provideService(IdGenerator, idGenerator), Stream.provideService(InternalCodecTransformer.CurrentCodecTransformer, codecTransformer));
+  }) : error), Stream.provideService(IdGenerator, idGenerator));
   const generateContent = Effect.fnUntraced(function* (options, providerOptions) {
+    const tracker = Option.getOrUndefined(yield* Effect.serviceOption(ResponseIdTracker.ResponseIdTracker));
     const toolChoice = options.toolChoice ?? "auto";
+    const generateWithNonIncrementalFallback = () => {
+      const requestOptions = {
+        ...providerOptions
+      };
+      const fallbackPrompt = requestOptions.prompt;
+      const fallbackOptions = {
+        ...requestOptions,
+        prompt: fallbackPrompt,
+        incrementalPrompt: undefined,
+        previousResponseId: undefined
+      };
+      return requestOptions.incrementalPrompt ? params.generateText(requestOptions).pipe(Effect.catchReason("AiError", "InvalidRequestError", _ => params.generateText(fallbackOptions))) : params.generateText(requestOptions);
+    };
     // Check for pending approvals that need resolution
     const {
       approved,
@@ -358,9 +365,22 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           })
         });
       }
+      if (tracker) {
+        const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+        if (Option.isSome(prepared)) {
+          providerOptions.previousResponseId = prepared.value.previousResponseId;
+          providerOptions.incrementalPrompt = prepared.value.prompt;
+        }
+      }
       const ResponseSchema = Schema.mutable(Schema.Array(Response.Part(Toolkit.empty)));
-      const rawContent = yield* params.generateText(providerOptions);
+      const rawContent = yield* generateWithNonIncrementalFallback();
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent);
+      if (tracker) {
+        const responseMetadata = content.find(part => part.type === "response-metadata");
+        if (Predicate.isNotUndefined(responseMetadata) && Predicate.isNotUndefined(responseMetadata.id)) {
+          tracker.markParts(providerOptions.prompt.content, responseMetadata.id);
+        }
+      }
       return content;
     }
     // If there is a toolkit resolve and apply it to the provider options
@@ -377,14 +397,26 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           })
         });
       }
+      if (tracker) {
+        const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+        if (Option.isSome(prepared)) {
+          providerOptions.previousResponseId = prepared.value.previousResponseId;
+          providerOptions.incrementalPrompt = prepared.value.prompt;
+        }
+      }
       const ResponseSchema = Schema.mutable(Schema.Array(Response.Part(Toolkit.empty)));
-      const rawContent = yield* params.generateText(providerOptions);
+      const rawContent = yield* generateWithNonIncrementalFallback();
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent);
+      if (tracker) {
+        const responseMetadata = content.find(part => part.type === "response-metadata");
+        if (Predicate.isNotUndefined(responseMetadata) && Predicate.isNotUndefined(responseMetadata.id)) {
+          tracker.markParts(providerOptions.prompt.content, responseMetadata.id);
+        }
+      }
       return content;
     }
-    // Pre-resolve tool approvals before calling the LLM
+    // Pre-resolve pending tool approvals before calling the LLM
     if (hasPendingApprovals) {
-      // Validate all approved tools exist in the toolkit
       for (const approval of approved) {
         if (approval.toolCall && !toolkit.tools[approval.toolCall.name]) {
           return yield* AiError.make({
@@ -397,39 +429,80 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           });
         }
       }
-      // Execute approved tools and create denial results
       const approvedResults = yield* executeApprovedToolCalls(approved, toolkit, options.concurrency);
       const deniedResults = createDenialResults(denied);
       const preResolvedResults = [...approvedResults, ...deniedResults];
-      // Add pre-resolved results to the prompt
       if (preResolvedResults.length > 0) {
-        const toolMessage = Prompt.makeMessage("tool", {
+        providerOptions.prompt = Prompt.fromMessages([...providerOptions.prompt.content, Prompt.makeMessage("tool", {
           content: preResolvedResults
-        });
-        providerOptions.prompt = Prompt.fromMessages([...providerOptions.prompt.content, toolMessage]);
+        })]);
+      }
+    }
+    // Strip all resolved approval artifacts (both current and from previous
+    // rounds) in a single pass before sending to the provider.
+    {
+      const {
+        approved: allResolved,
+        denied: allDenied
+      } = collectToolApprovals(providerOptions.prompt.content);
+      if (allResolved.length > 0 || allDenied.length > 0) {
+        providerOptions.prompt = stripResolvedApprovals(providerOptions.prompt, allResolved, allDenied);
       }
     }
     const tools = typeof toolChoice === "object" && "oneOf" in toolChoice ? Object.values(toolkit.tools).filter(tool => toolChoice.oneOf.includes(tool.name)) : Object.values(toolkit.tools);
     providerOptions.tools = tools;
     providerOptions.toolChoice = toolChoice;
+    if (tracker) {
+      const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+      if (Option.isSome(prepared)) {
+        providerOptions.previousResponseId = prepared.value.previousResponseId;
+        providerOptions.incrementalPrompt = prepared.value.prompt;
+      }
+    }
     // Construct the response schema with the tools from the toolkit
     const ResponseSchema = Schema.mutable(Schema.Array(Response.Part(toolkit)));
     // If tool call resolution is disabled, return the response without
     // resolving the tool calls that were generated
     if (options.disableToolCallResolution === true) {
-      const rawContent = yield* params.generateText(providerOptions);
+      const rawContent = yield* generateWithNonIncrementalFallback();
       const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent);
+      if (tracker) {
+        const responseMetadata = content.find(part => part.type === "response-metadata");
+        if (Predicate.isNotUndefined(responseMetadata) && Predicate.isNotUndefined(responseMetadata.id)) {
+          tracker.markParts(providerOptions.prompt.content, responseMetadata.id);
+        }
+      }
       return content;
     }
-    const rawContent = yield* params.generateText(providerOptions);
+    const rawContent = yield* generateWithNonIncrementalFallback();
     // Resolve the generated tool calls
     const toolResults = yield* resolveToolCalls(rawContent, toolkit, providerOptions.prompt.content, options.concurrency).pipe(Stream.filter(result => result.type === "tool-approval-request" || result.preliminary === false), Stream.runCollect);
     const content = yield* Schema.decodeEffect(ResponseSchema)(rawContent);
+    if (tracker) {
+      const responseMetadata = content.find(part => part.type === "response-metadata");
+      if (Predicate.isNotUndefined(responseMetadata) && Predicate.isNotUndefined(responseMetadata.id)) {
+        tracker.markParts(providerOptions.prompt.content, responseMetadata.id);
+      }
+    }
     // Return the content merged with the tool call results
     return [...content, ...toolResults];
   });
   const streamContent = Effect.fnUntraced(function* (options, providerOptions) {
+    const tracker = Option.getOrUndefined(yield* Effect.serviceOption(ResponseIdTracker.ResponseIdTracker));
     const toolChoice = options.toolChoice ?? "auto";
+    const streamWithNonIncrementalFallback = () => {
+      const requestOptions = {
+        ...providerOptions
+      };
+      const fallbackPrompt = requestOptions.prompt;
+      const fallbackOptions = {
+        ...requestOptions,
+        prompt: fallbackPrompt,
+        incrementalPrompt: undefined,
+        previousResponseId: undefined
+      };
+      return requestOptions.incrementalPrompt ? params.streamText(requestOptions).pipe(Stream.catchReason("AiError", "InvalidRequestError", _ => params.streamText(fallbackOptions))) : params.streamText(requestOptions);
+    };
     // Check for pending approvals that need resolution
     const {
       approved: pendingApproved,
@@ -450,12 +523,26 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           })
         });
       }
+      if (tracker) {
+        const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+        if (Option.isSome(prepared)) {
+          providerOptions.previousResponseId = prepared.value.previousResponseId;
+          providerOptions.incrementalPrompt = prepared.value.prompt;
+        }
+      }
       const schema = Schema.NonEmptyArray(Response.StreamPart(Toolkit.empty));
       const decodeParts = Schema.decodeEffect(schema);
-      return params.streamText(providerOptions).pipe(Stream.mapArrayEffect(parts => decodeParts(parts)));
+      return pipe(streamWithNonIncrementalFallback(), Stream.mapArrayEffect(parts => decodeParts(parts).pipe(tracker ? Effect.tap(decodedParts => {
+        for (const part of decodedParts) {
+          if (part.type === "response-metadata" && Predicate.isNotUndefined(part.id)) {
+            tracker.markParts(providerOptions.prompt.content, part.id);
+          }
+        }
+        return Effect.void;
+      }) : identity)));
     }
     // If there is a toolkit resolve and apply it to the provider options
-    const toolkit = "asEffect" in options.toolkit ? yield* options.toolkit : options.toolkit;
+    const toolkit = yield* resolveToolkit(options.toolkit);
     // If the toolkit is empty, return immediately
     if (Object.values(toolkit.tools).length === 0) {
       // But first check if we have pending approvals that require a toolkit
@@ -468,13 +555,27 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           })
         });
       }
+      if (tracker) {
+        const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+        if (Option.isSome(prepared)) {
+          providerOptions.previousResponseId = prepared.value.previousResponseId;
+          providerOptions.incrementalPrompt = prepared.value.prompt;
+        }
+      }
       const schema = Schema.NonEmptyArray(Response.StreamPart(Toolkit.empty));
       const decodeParts = Schema.decodeEffect(schema);
-      return params.streamText(providerOptions).pipe(Stream.mapArrayEffect(parts => decodeParts(parts)));
+      return pipe(streamWithNonIncrementalFallback(), Stream.mapArrayEffect(parts => decodeParts(parts).pipe(tracker ? Effect.tap(decodedParts => {
+        for (const part of decodedParts) {
+          if (part.type === "response-metadata" && part.id) {
+            tracker.markParts(providerOptions.prompt.content, part.id);
+          }
+        }
+        return Effect.void;
+      }) : identity)));
     }
-    // Pre-resolve tool approvals before calling the LLM
+    // Pre-resolve pending tool approvals before calling the LLM
+    let preResolvedStreamParts = [];
     if (hasPendingApprovals) {
-      // Validate all approved tools exist in the toolkit
       for (const approval of pendingApproved) {
         if (approval.toolCall && !toolkit.tools[approval.toolCall.name]) {
           return yield* AiError.make({
@@ -487,40 +588,81 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
           });
         }
       }
-      // Execute approved tools and create denial results
       const approvedResults = yield* executeApprovedToolCalls(pendingApproved, toolkit, options.concurrency);
       const deniedResults = createDenialResults(pendingDenied);
       const preResolvedResults = [...approvedResults, ...deniedResults];
-      // Add pre-resolved results to the prompt
       if (preResolvedResults.length > 0) {
-        const toolMessage = Prompt.makeMessage("tool", {
+        providerOptions.prompt = Prompt.fromMessages([...providerOptions.prompt.content, Prompt.makeMessage("tool", {
           content: preResolvedResults
-        });
-        providerOptions.prompt = Prompt.fromMessages([...providerOptions.prompt.content, toolMessage]);
+        })]);
       }
+      // Emit pre-resolved tool-results as stream parts so Chat.streamText
+      // persists them to history. This lets collectToolApprovals find them
+      // on subsequent rounds and skip the now-resolved approvals.
+      // Note: r.result is already encoded (from executeApprovedToolCalls /
+      // createDenialResults), so it goes into both result and encodedResult.
+      for (const r of preResolvedResults) {
+        preResolvedStreamParts.push(Response.makePart("tool-result", {
+          id: r.id,
+          name: r.name,
+          providerExecuted: false,
+          preliminary: false,
+          result: r.result,
+          encodedResult: r.result,
+          isFailure: r.isFailure
+        }));
+      }
+    }
+    // Strip all resolved approval artifacts (both current and from previous
+    // rounds) in a single pass before sending to the provider.
+    const {
+      approved: allResolved,
+      denied: allDenied
+    } = collectToolApprovals(providerOptions.prompt.content);
+    if (allResolved.length > 0 || allDenied.length > 0) {
+      providerOptions.prompt = stripResolvedApprovals(providerOptions.prompt, allResolved, allDenied);
     }
     const tools = typeof toolChoice === "object" && "oneOf" in toolChoice ? Object.values(toolkit.tools).filter(tool => toolChoice.oneOf.includes(tool.name)) : Object.values(toolkit.tools);
     providerOptions.tools = tools;
     providerOptions.toolChoice = toolChoice;
+    if (tracker) {
+      const prepared = tracker.prepareUnsafe(providerOptions.prompt);
+      if (Option.isSome(prepared)) {
+        providerOptions.previousResponseId = prepared.value.previousResponseId;
+        providerOptions.incrementalPrompt = prepared.value.prompt;
+      }
+    }
     // If tool call resolution is disabled, return the response without
     // resolving the tool calls that were generated
     if (options.disableToolCallResolution === true) {
       const schema = Schema.NonEmptyArray(Response.StreamPart(toolkit));
       const decodeParts = Schema.decodeEffect(schema);
-      return params.streamText(providerOptions).pipe(Stream.mapArrayEffect(parts => decodeParts(parts)));
+      return streamWithNonIncrementalFallback().pipe(Stream.mapArrayEffect(parts => decodeParts(parts).pipe(tracker ? Effect.tap(decodedParts => {
+        for (const part of decodedParts) {
+          if (part.type === "response-metadata" && Predicate.isNotUndefined(part.id)) {
+            tracker.markParts(providerOptions.prompt.content, part.id);
+          }
+        }
+        return Effect.void;
+      }) : identity)));
     }
     const ResponseSchema = Schema.NonEmptyArray(Response.StreamPart(toolkit));
     const decodeParts = Schema.decodeEffect(ResponseSchema);
     // Queue for decoded parts and tool results
     const queue = yield* Queue.make();
+    const deferredFinishParts = [];
+    // Emit pre-resolved tool results so Chat.streamText persists them to
+    // history. This ensures collectToolApprovals({ excludeResolved }) can
+    // find the corresponding tool-results on future rounds.
+    if (preResolvedStreamParts.length > 0) {
+      yield* Queue.offerAll(queue, preResolvedStreamParts);
+    }
     // FiberSet to track concurrent tool call handlers
     const toolCallFibers = yield* FiberSet.make();
     // Helper function to handle tool calls with approval logic
-    const handleToolCall = part => Effect.gen(function* () {
+    const handleToolCall = Effect.fnUntraced(function* (part) {
       const tool = toolkit.tools[part.name];
-      if (!tool) {
-        return;
-      }
+      if (!tool) return;
       const needsApproval = yield* isApprovalNeeded(tool, part, providerOptions.prompt.content);
       if (needsApproval) {
         const idGen = yield* IdGenerator;
@@ -542,10 +684,28 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
         return Queue.offer(queue, toolResultPart);
       }));
     });
-    yield* params.streamText(providerOptions).pipe(Stream.runForEachArray(Effect.fnUntraced(function* (chunk) {
+    yield* streamWithNonIncrementalFallback().pipe(Stream.runForEachArray(Effect.fnUntraced(function* (chunk) {
       const parts = yield* decodeParts(chunk);
-      // Add decoded response parts to the output queue
-      yield* Queue.offerAll(queue, parts);
+      if (tracker) {
+        for (const part of parts) {
+          if (part.type === "response-metadata" && part.id) {
+            tracker.markParts(providerOptions.prompt.content, part.id);
+          }
+        }
+      }
+      // Defer finish parts until all tool handlers complete. This guarantees
+      // tool results are emitted before finish in streaming mode.
+      const immediateParts = [];
+      for (const part of parts) {
+        if (part.type === "finish") {
+          deferredFinishParts.push(part);
+        } else {
+          immediateParts.push(part);
+        }
+      }
+      if (immediateParts.length > 0) {
+        yield* Queue.offerAll(queue, immediateParts);
+      }
       // Fork tool call handlers - use the raw chunk for encoded params
       for (const part of chunk) {
         if (part.type === "tool-call" && part.providerExecuted !== true) {
@@ -556,15 +716,15 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* (params) {
     // Wait for all tool calls to either:
     // - complete (FiberSet.awaitEmpty)
     // - fail (FiberSet.join)
-    Effect.andThen(Effect.raceFirst(FiberSet.join(toolCallFibers), FiberSet.awaitEmpty(toolCallFibers))),
+    Effect.andThen(Effect.raceFirst(FiberSet.join(toolCallFibers), FiberSet.awaitEmpty(toolCallFibers))), Effect.andThen(Queue.offerAll(queue, deferredFinishParts)),
     // And then end the queue
     Effect.andThen(Queue.end(queue)), Effect.tapCause(cause => Queue.failCause(queue, cause)), Effect.forkScoped);
     return Stream.fromQueue(queue);
   });
   return {
-    generateText,
+    generateText: generateText,
     generateObject,
-    streamText
+    streamText: streamText
   };
 });
 // =============================================================================
@@ -714,6 +874,43 @@ const collectToolApprovals = (messages, options) => {
     denied
   };
 };
+/**
+ * Strip resolved approval artifacts from the prompt before sending to the
+ * provider. After pre-resolving approvals (executing approved tools and
+ * creating denial results), the original `tool-approval-request` parts in
+ * assistant messages and `tool-approval-response` parts in tool messages are
+ * no longer needed. Leaving them in causes provider-specific errors (e.g.
+ * OpenAI rejects `mcp_approval_response` items that reference approval
+ * requests it never issued).
+ */
+const stripResolvedApprovals = (prompt, approved, denied) => {
+  const resolvedApprovalIds = new Set();
+  for (const a of approved) resolvedApprovalIds.add(a.approvalId);
+  for (const d of denied) resolvedApprovalIds.add(d.approvalId);
+  const cleanedMessages = [];
+  for (const message of prompt.content) {
+    if (message.role === "assistant") {
+      const filteredContent = message.content.filter(part => part.type !== "tool-approval-request" || !resolvedApprovalIds.has(part.approvalId));
+      if (filteredContent.length > 0) {
+        cleanedMessages.push(Prompt.makeMessage("assistant", {
+          content: filteredContent,
+          options: message.options
+        }));
+      }
+    } else if (message.role === "tool") {
+      const filteredContent = message.content.filter(part => part.type !== "tool-approval-response" || !resolvedApprovalIds.has(part.approvalId));
+      if (filteredContent.length > 0) {
+        cleanedMessages.push(Prompt.makeMessage("tool", {
+          content: filteredContent,
+          options: message.options
+        }));
+      }
+    } else {
+      cleanedMessages.push(message);
+    }
+  }
+  return Prompt.fromMessages(cleanedMessages);
+};
 const isApprovalNeeded = /*#__PURE__*/Effect.fnUntraced(function* (tool, toolCall, messages) {
   if (Predicate.isUndefined(tool.needsApproval)) {
     return false;
@@ -868,26 +1065,28 @@ export const getObjectName = (objectName, schema) => {
   return "generateObject";
 };
 const resolveStructuredOutput = /*#__PURE__*/Effect.fnUntraced(function* (response, schema) {
-  const text = [];
+  const texts = [];
   for (const part of response) {
     if (part.type === "text") {
-      text.push(part.text);
+      texts.push(part.text);
     }
   }
+  const text = texts.join("");
   if (text.length === 0) {
     return yield* AiError.make({
       module: "LanguageModel",
       method: "generateObject",
       reason: new AiError.StructuredOutputError({
-        description: "No text content in response"
+        description: "No text content in response",
+        responseText: text
       })
     });
   }
   const decode = Schema.decodeEffect(Schema.fromJsonString(schema));
-  return yield* Effect.mapError(decode(text.join("")), error => AiError.make({
+  return yield* Effect.mapError(decode(text), error => AiError.make({
     module: "LanguageModel",
     method: "generateObject",
-    reason: AiError.StructuredOutputError.fromSchemaError(error)
+    reason: AiError.StructuredOutputError.fromSchemaError(error, text)
   }));
 });
 const applySpanTransformer = (transformer, response, options) => {