@effect/ai-openrouter 4.0.0-beta.7 → 4.0.0-beta.71

package/dist/OpenRouterLanguageModel.js

@@ -1,17 +1,57 @@
 /**
- * @since 1.0.0
+ * The `OpenRouterLanguageModel` module provides the OpenRouter implementation
+ * of Effect AI's `LanguageModel` service. It translates provider-neutral
+ * prompts, tools, files, structured output requests, reasoning metadata,
+ * cache-control hints, and telemetry annotations into OpenRouter chat
+ * completion requests, then converts responses and streams back into Effect AI
+ * response parts.
+ *
+ * **Mental model**
+ *
+ * `OpenRouterClient` owns HTTP transport and authentication. This module owns
+ * protocol translation: message assembly, tool conversion, structured output
+ * codec selection, streaming chunk handling, OpenRouter metadata round-trips,
+ * and GenAI telemetry annotations. {@link model}, {@link layer}, and
+ * {@link make} all build the same OpenRouter-backed
+ * `LanguageModel.LanguageModel` service from a model id and optional request
+ * defaults.
+ *
+ * **Common tasks**
+ *
+ * - Create an OpenRouter model descriptor for `Effect.provide`: {@link model}
+ * - Provide `LanguageModel.LanguageModel` as a `Layer`: {@link layer}
+ * - Construct the service effectfully from an existing `OpenRouterClient`:
+ *   {@link make}
+ * - Supply or scope OpenRouter request defaults: {@link Config},
+ *   {@link withConfigOverride}
+ * - Preserve OpenRouter reasoning and file metadata across turns:
+ *   {@link ReasoningDetails}, {@link FileAnnotation}
+ *
+ * **Gotchas**
+ *
+ * - OpenRouter routes to many underlying providers, so support for images,
+ *   files, tools, structured outputs, caching, and reasoning metadata depends
+ *   on the selected model and route.
+ * - Provider-specific prompt and response metadata lives under the `openrouter`
+ *   option namespace so later requests can replay reasoning details and file
+ *   annotations when the model supports them.
+ * - Provider-defined tools are not supported by this integration; requests that
+ *   include them fail before reaching OpenRouter.
+ *
+ * @since 4.0.0
  */
 /** @effect-diagnostics preferSchemaOverJson:skip-file */
 import * as Arr from "effect/Array";
+import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
 import { dual } from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Redactable from "effect/Redactable";
 import * as SchemaAST from "effect/SchemaAST";
-import * as ServiceMap from "effect/ServiceMap";
 import * as Stream from "effect/Stream";
 import * as AiError from "effect/unstable/ai/AiError";
 import { toCodecAnthropic } from "effect/unstable/ai/AnthropicStructuredOutput";
@@ -29,26 +69,72 @@ import { OpenRouterClient } from "./OpenRouterClient.js";
 /**
  * Service definition for OpenRouter language model configuration.
  *
- * @since 1.0.0
+ * **When to use**
+ *
+ * Use to provide scoped OpenRouter chat completion defaults or per-operation
+ * overrides for an OpenRouter language model service.
+ *
+ * @see {@link withConfigOverride} for scoping language model request overrides
+ *
  * @category services
+ * @since 4.0.0
  */
-export class Config extends /*#__PURE__*/ServiceMap.Service()("@effect/ai-openrouter/OpenRouterLanguageModel/Config") {}
+export class Config extends /*#__PURE__*/Context.Service()("@effect/ai-openrouter/OpenRouterLanguageModel/Config") {}
 // =============================================================================
 // Language Model
 // =============================================================================
 /**
- * @since 1.0.0
+ * Creates an OpenRouter model descriptor that can be provided with
+ * `Effect.provide`.
+ *
+ * **When to use**
+ *
+ * Use when you want an OpenRouter language model value that carries provider
+ * and model metadata and can be supplied directly to an Effect program.
+ *
+ * **Details**
+ *
+ * The returned model requires `OpenRouterClient` and provides
+ * `LanguageModel.LanguageModel`.
+ *
+ * @see {@link layer} for creating a `LanguageModel.LanguageModel` layer directly
+ * @see {@link make} for constructing the language model service effectfully
+ * @see {@link withConfigOverride} for scoping OpenRouter request overrides
+ *
  * @category constructors
+ * @since 4.0.0
  */
-export const model = (model, config) => AiModel.make("openai", layer({
+export const model = (model, config) => AiModel.make("openai", model, layer({
   model,
   config
 }));
 /**
- * Creates an OpenRouter language model service.
+ * Creates an OpenRouter `LanguageModel` service from a model identifier and
+ * optional request defaults.
+ *
+ * **When to use**
+ *
+ * Use when an Effect needs to construct a `LanguageModel.Service` value backed
+ * by `OpenRouterClient`.
+ *
+ * **Details**
+ *
+ * The returned effect requires `OpenRouterClient`. Request defaults from the
+ * `config` option are merged with any `Config` service in the context, with
+ * context values taking precedence. The service supports both `generateText`
+ * and `streamText`.
+ *
+ * **Gotchas**
+ *
+ * Provider-defined tools are not supported by this provider integration;
+ * requests that include them fail with an `InvalidUserInputError`.
+ *
+ * @see {@link layer} for providing the service as a `Layer`
+ * @see {@link model} for creating a model descriptor for `Effect.provide`
+ * @see {@link withConfigOverride} for scoping request defaults around operations
  *
- * @since 1.0.0
  * @category constructors
+ * @since 4.0.0
  */
 export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
   model,
@@ -57,7 +143,7 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
   const client = yield* OpenRouterClient;
   const codecTransformer = getCodecTransformer(model);
   const makeConfig = Effect.gen(function* () {
-    const services = yield* Effect.services();
+    const services = yield* Effect.context();
     return {
       model,
       ...providerConfig,
@@ -99,6 +185,7 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
     return request;
   });
   return yield* LanguageModel.make({
+    codecTransformer: toCodecOpenAI,
     generateText: Effect.fnUntraced(function* (options) {
       const config = yield* makeConfig;
       const request = yield* makeRequest({
@@ -129,20 +216,43 @@ export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
       annotateStreamResponse(options.span, response);
       return response;
     })))
-  }).pipe(Effect.provideService(LanguageModel.CurrentCodecTransformer, codecTransformer));
+  });
 });
 /**
  * Creates a layer for the OpenRouter language model.
  *
- * @since 1.0.0
+ * **When to use**
+ *
+ * Use when composing application layers and you want OpenRouter to satisfy
+ * `LanguageModel.LanguageModel` while supplying `OpenRouterClient` from another
+ * layer.
+ *
+ * @see {@link make} for constructing the language model service effectfully
+ * @see {@link model} for creating a model descriptor for `Effect.provide`
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer = options => Layer.effect(LanguageModel.LanguageModel, make(options));
 /**
  * Provides config overrides for OpenRouter language model operations.
  *
- * @since 1.0.0
+ * **When to use**
+ *
+ * Use to apply OpenRouter request configuration to one effect without changing
+ * the model's default configuration.
+ *
+ * **Details**
+ *
+ * The overrides are merged with any existing `Config` service for the duration
+ * of the supplied effect. Fields in `overrides` take precedence over existing
+ * config, and the helper supports both pipe form and
+ * `withConfigOverride(effect, overrides)`.
+ *
+ * @see {@link Config} for available OpenRouter request configuration fields
+ *
  * @category configuration
+ * @since 4.0.0
  */
 export const withConfigOverride = /*#__PURE__*/dual(2, (self, overrides) => Effect.flatMap(Effect.serviceOption(Config), config => Effect.provideService(self, Config, {
   ...(config._tag === "Some" ? config.value : {}),
@@ -344,7 +454,7 @@ const buildHttpRequestDetails = request => ({
   method: request.method,
   url: request.url,
   urlParams: Array.from(request.urlParams),
-  hash: request.hash,
+  hash: Option.getOrUndefined(request.hash),
   headers: Redactable.redact(request.headers)
 });
 const buildHttpResponseDetails = response => ({
@@ -636,267 +746,260 @@ const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
       usage.outputTokens = computed.outputTokens;
     }
     const choice = event.choices[0];
-    if (Predicate.isUndefined(choice)) {
-      return yield* AiError.make({
-        module: "OpenRouterLanguageModel",
-        method: "makeStreamResponse",
-        reason: new AiError.InvalidOutputError({
-          description: "Received response with empty choices"
-        })
-      });
-    }
-    if (Predicate.isNotNull(choice.finish_reason)) {
-      finishReason = resolveFinishReason(choice.finish_reason);
-    }
-    const delta = choice.delta;
-    if (Predicate.isNullish(delta)) {
-      return parts;
-    }
-    const emitReasoning = Effect.fnUntraced(function* (delta, metadata) {
-      if (!reasoningStarted) {
-        activeReasoningId = openRouterResponseId ?? (yield* idGenerator.generateId());
+    if (Predicate.isNotUndefined(choice)) {
+      if (Predicate.isNotNullish(choice.finish_reason)) {
+        finishReason = resolveFinishReason(choice.finish_reason);
+      }
+      const delta = choice.delta;
+      if (Predicate.isNullish(delta)) {
+        return parts;
+      }
+      const emitReasoning = Effect.fnUntraced(function* (delta, metadata) {
+        if (!reasoningStarted) {
+          activeReasoningId = openRouterResponseId ?? (yield* idGenerator.generateId());
+          parts.push({
+            type: "reasoning-start",
+            id: activeReasoningId,
+            metadata
+          });
+          reasoningStarted = true;
+        }
         parts.push({
-          type: "reasoning-start",
+          type: "reasoning-delta",
           id: activeReasoningId,
+          delta,
           metadata
         });
-        reasoningStarted = true;
-      }
-      parts.push({
-        type: "reasoning-delta",
-        id: activeReasoningId,
-        delta,
-        metadata
       });
-    });
-    const reasoningDetails = delta.reasoning_details;
-    if (Predicate.isNotUndefined(reasoningDetails) && reasoningDetails.length > 0) {
-      // Accumulate reasoning_details to preserve for multi-turn conversations
-      // Merge consecutive reasoning.text items into a single entry
-      for (const detail of reasoningDetails) {
-        if (detail.type === "reasoning.text") {
-          const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1];
-          if (Predicate.isNotUndefined(lastDetail) && lastDetail.type === "reasoning.text") {
-            // Merge with the previous text detail
-            lastDetail.text = (lastDetail.text ?? "") + (detail.text ?? "");
-            lastDetail.signature = lastDetail.signature ?? detail.signature ?? null;
-            lastDetail.format = lastDetail.format ?? detail.format ?? null;
+      const reasoningDetails = delta.reasoning_details;
+      if (Predicate.isNotUndefined(reasoningDetails) && reasoningDetails.length > 0) {
+        // Accumulate reasoning_details to preserve for multi-turn conversations
+        // Merge consecutive reasoning.text items into a single entry
+        for (const detail of reasoningDetails) {
+          if (detail.type === "reasoning.text") {
+            const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1];
+            if (Predicate.isNotUndefined(lastDetail) && lastDetail.type === "reasoning.text") {
+              // Merge with the previous text detail
+              lastDetail.text = (lastDetail.text ?? "") + (detail.text ?? "");
+              lastDetail.signature = lastDetail.signature ?? detail.signature ?? null;
+              lastDetail.format = lastDetail.format ?? detail.format ?? null;
+            } else {
+              // Start a new text detail
+              accumulatedReasoningDetails.push({
+                ...detail
+              });
+            }
           } else {
-            // Start a new text detail
-            accumulatedReasoningDetails.push({
-              ...detail
-            });
+            // Non-text details (encrypted, summary) are pushed as-is
+            accumulatedReasoningDetails.push(detail);
           }
-        } else {
-          // Non-text details (encrypted, summary) are pushed as-is
-          accumulatedReasoningDetails.push(detail);
         }
-      }
-      // Emit reasoning_details in providerMetadata for each delta chunk
-      // so users can accumulate them on their end before sending back
-      const metadata = {
-        openrouter: {
-          reasoningDetails
-        }
-      };
-      for (const detail of reasoningDetails) {
-        switch (detail.type) {
-          case "reasoning.text":
-            {
-              if (Predicate.isNotNullish(detail.text)) {
-                yield* emitReasoning(detail.text, metadata);
+        // Emit reasoning_details in providerMetadata for each delta chunk
+        // so users can accumulate them on their end before sending back
+        const metadata = {
+          openrouter: {
+            reasoningDetails
+          }
+        };
+        for (const detail of reasoningDetails) {
+          switch (detail.type) {
+            case "reasoning.text":
+              {
+                if (Predicate.isNotNullish(detail.text)) {
+                  yield* emitReasoning(detail.text, metadata);
+                }
+                break;
               }
-              break;
-            }
-          case "reasoning.summary":
-            {
-              if (Predicate.isNotNullish(detail.summary)) {
-                yield* emitReasoning(detail.summary, metadata);
+            case "reasoning.summary":
+              {
+                if (Predicate.isNotNullish(detail.summary)) {
+                  yield* emitReasoning(detail.summary, metadata);
+                }
+                break;
               }
-              break;
-            }
-          case "reasoning.encrypted":
-            {
-              if (Predicate.isNotNullish(detail.data)) {
-                yield* emitReasoning("[REDACTED]", metadata);
+            case "reasoning.encrypted":
+              {
+                if (Predicate.isNotNullish(detail.data)) {
+                  yield* emitReasoning("[REDACTED]", metadata);
+                }
+                break;
               }
-              break;
-            }
+          }
         }
+      } else if (Predicate.isNotNullish(delta.reasoning)) {
+        yield* emitReasoning(delta.reasoning);
       }
-    } else if (Predicate.isNotNullish(delta.reasoning)) {
-      yield* emitReasoning(delta.reasoning);
-    }
-    const content = delta.content;
-    if (Predicate.isNotNullish(content)) {
-      // If reasoning was previously active and now we're starting text content,
-      // we should end the reasoning first to maintain proper order
-      if (reasoningStarted && !textStarted) {
-        parts.push({
-          type: "reasoning-end",
-          id: activeReasoningId,
-          // Include accumulated reasoning_details so the we can update the
-          // reasoning part's provider metadata with the correct signature.
-          // The signature typically arrives in the last reasoning delta,
-          // but reasoning-start only carries the first delta's metadata.
-          metadata: accumulatedReasoningDetails.length > 0 ? {
-            openRouter: {
-              reasoningDetails: accumulatedReasoningDetails
-            }
-          } : undefined
-        });
-        reasoningStarted = false;
-      }
-      if (!textStarted) {
-        activeTextId = openRouterResponseId ?? (yield* idGenerator.generateId());
-        parts.push({
-          type: "text-start",
-          id: activeTextId
-        });
-        textStarted = true;
-      }
-      parts.push({
-        type: "text-delta",
-        id: activeTextId,
-        delta: content
-      });
-    }
-    const annotations = delta.annotations;
-    if (Predicate.isNotNullish(annotations)) {
-      for (const annotation of annotations) {
-        if (annotation.type === "url_citation") {
+      const content = delta.content;
+      if (Predicate.isNotNullish(content)) {
+        // If reasoning was previously active and now we're starting text content,
+        // we should end the reasoning first to maintain proper order
+        if (reasoningStarted && !textStarted) {
           parts.push({
-            type: "source",
-            sourceType: "url",
-            id: annotation.url_citation.url,
-            url: annotation.url_citation.url,
-            title: annotation.url_citation.title ?? "",
-            metadata: {
-              openrouter: {
-                ...(Predicate.isNotUndefined(annotation.url_citation.content) ? {
-                  content: annotation.url_citation.content
-                } : undefined),
-                ...(Predicate.isNotUndefined(annotation.url_citation.start_index) ? {
-                  startIndex: annotation.url_citation.start_index
-                } : undefined),
-                ...(Predicate.isNotUndefined(annotation.url_citation.end_index) ? {
-                  startIndex: annotation.url_citation.end_index
-                } : undefined)
+            type: "reasoning-end",
+            id: activeReasoningId,
+            // Include accumulated reasoning_details so the we can update the
+            // reasoning part's provider metadata with the correct signature.
+            // The signature typically arrives in the last reasoning delta,
+            // but reasoning-start only carries the first delta's metadata.
+            metadata: accumulatedReasoningDetails.length > 0 ? {
+              openRouter: {
+                reasoningDetails: accumulatedReasoningDetails
               }
-            }
+            } : undefined
           });
-        } else if (annotation.type === "file") {
-          accumulatedFileAnnotations.push(annotation);
+          reasoningStarted = false;
         }
+        if (!textStarted) {
+          activeTextId = openRouterResponseId ?? (yield* idGenerator.generateId());
+          parts.push({
+            type: "text-start",
+            id: activeTextId
+          });
+          textStarted = true;
+        }
+        parts.push({
+          type: "text-delta",
+          id: activeTextId,
+          delta: content
+        });
       }
-    }
-    const toolCalls = delta.tool_calls;
-    if (Predicate.isNotNullish(toolCalls)) {
-      for (const toolCall of toolCalls) {
-        const index = toolCall.index ?? toolCalls.length - 1;
-        let activeToolCall = activeToolCalls[index];
-        // Tool call start - OpenRouter returns all information except the
-        // tool call parameters in the first chunk
-        if (Predicate.isUndefined(activeToolCall)) {
-          if (toolCall.type !== "function") {
-            return yield* AiError.make({
-              module: "OpenRouterLanguageModel",
-              method: "makeStreamResponse",
-              reason: new AiError.InvalidOutputError({
-                description: "Received tool call delta that was not of type: 'function'"
-              })
-            });
-          }
-          if (Predicate.isUndefined(toolCall.id)) {
-            return yield* AiError.make({
-              module: "OpenRouterLanguageModel",
-              method: "makeStreamResponse",
-              reason: new AiError.InvalidOutputError({
-                description: "Received tool call delta without a tool call identifier"
-              })
+      const annotations = delta.annotations;
+      if (Predicate.isNotNullish(annotations)) {
+        for (const annotation of annotations) {
+          if (annotation.type === "url_citation") {
+            parts.push({
+              type: "source",
+              sourceType: "url",
+              id: annotation.url_citation.url,
+              url: annotation.url_citation.url,
+              title: annotation.url_citation.title ?? "",
+              metadata: {
+                openrouter: {
+                  ...(Predicate.isNotUndefined(annotation.url_citation.content) ? {
+                    content: annotation.url_citation.content
+                  } : undefined),
+                  ...(Predicate.isNotUndefined(annotation.url_citation.start_index) ? {
+                    startIndex: annotation.url_citation.start_index
+                  } : undefined),
+                  ...(Predicate.isNotUndefined(annotation.url_citation.end_index) ? {
+                    startIndex: annotation.url_citation.end_index
+                  } : undefined)
+                }
+              }
             });
+          } else if (annotation.type === "file") {
+            accumulatedFileAnnotations.push(annotation);
           }
-          if (Predicate.isUndefined(toolCall.function?.name)) {
-            return yield* AiError.make({
-              module: "OpenRouterLanguageModel",
-              method: "makeStreamResponse",
-              reason: new AiError.InvalidOutputError({
-                description: "Received tool call delta without a tool call name"
-              })
+        }
+      }
+      const toolCalls = delta.tool_calls;
+      if (Predicate.isNotNullish(toolCalls)) {
+        for (const toolCall of toolCalls) {
+          const index = toolCall.index ?? toolCalls.length - 1;
+          let activeToolCall = activeToolCalls[index];
+          // Tool call start - OpenRouter returns all information except the
+          // tool call parameters in the first chunk
+          if (Predicate.isUndefined(activeToolCall)) {
+            if (toolCall.type !== "function") {
+              return yield* AiError.make({
+                module: "OpenRouterLanguageModel",
+                method: "makeStreamResponse",
+                reason: new AiError.InvalidOutputError({
+                  description: "Received tool call delta that was not of type: 'function'"
+                })
+              });
+            }
+            if (Predicate.isNullish(toolCall.id)) {
+              return yield* AiError.make({
+                module: "OpenRouterLanguageModel",
+                method: "makeStreamResponse",
+                reason: new AiError.InvalidOutputError({
+                  description: "Received tool call delta without a tool call identifier"
+                })
+              });
+            }
+            if (Predicate.isNullish(toolCall.function?.name)) {
+              return yield* AiError.make({
+                module: "OpenRouterLanguageModel",
+                method: "makeStreamResponse",
+                reason: new AiError.InvalidOutputError({
+                  description: "Received tool call delta without a tool call name"
+                })
+              });
+            }
+            activeToolCall = {
+              id: toolCall.id,
+              type: "function",
+              name: toolCall.function.name,
+              params: toolCall.function.arguments ?? ""
+            };
+            activeToolCalls[index] = activeToolCall;
+            parts.push({
+              type: "tool-params-start",
+              id: activeToolCall.id,
+              name: activeToolCall.name
             });
-          }
-          activeToolCall = {
-            id: toolCall.id,
-            type: "function",
-            name: toolCall.function.name,
-            params: toolCall.function.arguments ?? ""
-          };
-          activeToolCalls[index] = activeToolCall;
-          parts.push({
-            type: "tool-params-start",
-            id: activeToolCall.id,
-            name: activeToolCall.name
-          });
-          // Emit a tool call delta part if parameters were also sent
-          if (activeToolCall.params.length > 0) {
+            // Emit a tool call delta part if parameters were also sent
+            if (activeToolCall.params.length > 0) {
+              parts.push({
+                type: "tool-params-delta",
+                id: activeToolCall.id,
+                delta: activeToolCall.params
+              });
+            }
+          } else {
+            // If an active tool call was found, update and emit the delta for
+            // the tool call's parameters
+            activeToolCall.params += toolCall.function?.arguments ?? "";
             parts.push({
               type: "tool-params-delta",
               id: activeToolCall.id,
               delta: activeToolCall.params
             });
           }
-        } else {
-          // If an active tool call was found, update and emit the delta for
-          // the tool call's parameters
-          activeToolCall.params += toolCall.function?.arguments ?? "";
-          parts.push({
-            type: "tool-params-delta",
-            id: activeToolCall.id,
-            delta: activeToolCall.params
-          });
+          // Check if the tool call is complete
+          // @effect-diagnostics-next-line tryCatchInEffectGen:off
+          try {
+            const params = Tool.unsafeSecureJsonParse(activeToolCall.params);
+            parts.push({
+              type: "tool-params-end",
+              id: activeToolCall.id
+            });
+            parts.push({
+              type: "tool-call",
+              id: activeToolCall.id,
+              name: activeToolCall.name,
+              params,
+              // Only attach reasoning_details to the first tool call to avoid
+              // duplicating thinking blocks for parallel tool calls (Claude)
+              metadata: reasoningDetailsAttachedToToolCall ? undefined : {
+                openrouter: {
+                  reasoningDetails: accumulatedReasoningDetails
+                }
+              }
+            });
+            reasoningDetailsAttachedToToolCall = true;
+            // Increment the total tool calls emitted by the stream and
+            // remove the active tool call
+            totalToolCalls += 1;
+            delete activeToolCalls[toolCall.index];
+          } catch {
+            // Tool call incomplete, continue parsing
+            continue;
+          }
         }
-        // Check if the tool call is complete
-        // @effect-diagnostics-next-line tryCatchInEffectGen:off
-        try {
-          const params = Tool.unsafeSecureJsonParse(activeToolCall.params);
+      }
+      const images = delta.images;
+      if (Predicate.isNotNullish(images)) {
+        for (const image of images) {
           parts.push({
-            type: "tool-params-end",
-            id: activeToolCall.id
+            type: "file",
+            mediaType: getMediaType(image.image_url.url, "image/jpeg"),
+            data: getBase64FromDataUrl(image.image_url.url)
           });
-          parts.push({
-            type: "tool-call",
-            id: activeToolCall.id,
-            name: activeToolCall.name,
-            params,
-            // Only attach reasoning_details to the first tool call to avoid
-            // duplicating thinking blocks for parallel tool calls (Claude)
-            metadata: reasoningDetailsAttachedToToolCall ? undefined : {
-              openrouter: {
-                reasoningDetails: accumulatedReasoningDetails
-              }
-            }
-          });
-          reasoningDetailsAttachedToToolCall = true;
-          // Increment the total tool calls emitted by the stream and
-          // remove the active tool call
-          totalToolCalls += 1;
-          delete activeToolCalls[toolCall.index];
-        } catch {
-          // Tool call incomplete, continue parsing
-          continue;
         }
       }
     }
-    const images = delta.images;
-    if (Predicate.isNotNullish(images)) {
-      for (const image of images) {
-        parts.push({
-          type: "file",
-          mediaType: getMediaType(image.image_url.url, "image/jpeg"),
-          data: getBase64FromDataUrl(image.image_url.url)
-        });
-      }
-    }
     // Usage is only emitted by the last part of the stream, so we need to
     // handle flushing any remaining text / reasoning / tool calls
     if (Predicate.isNotUndefined(event.usage)) {