@ai-sdk/open-responses 0.0.0-6b196531-20260710185421

package/dist/index.js

@@ -0,0 +1,729 @@
+// src/version.ts
+var VERSION = true ? "0.0.0-6b196531-20260710185421" : "0.0.0-test";
+
+// src/open-responses-provider.ts
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  generateId,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+
+// src/responses/open-responses-language-model.ts
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  isCustomReasoning,
+  jsonSchema,
+  mapReasoningToProviderEffort,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/responses/convert-to-open-responses-input.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
+async function convertToOpenResponsesInput({
+  prompt
+}) {
+  var _a, _b, _c;
+  const input = [];
+  const warnings = [];
+  const systemMessages = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        systemMessages.push(content);
+        break;
+      }
+      case "user": {
+        const userContent = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              userContent.push({ type: "input_text", text: part.text });
+              break;
+            }
+            case "file": {
+              switch (part.data.type) {
+                case "reference": {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "file parts with provider references"
+                  });
+                }
+                case "text": {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "text file parts"
+                  });
+                }
+                case "url":
+                case "data": {
+                  const topLevel = getTopLevelMediaType(part.mediaType);
+                  if (topLevel === "image") {
+                    userContent.push({
+                      type: "input_image",
+                      ...part.data.type === "url" ? { image_url: part.data.url.toString() } : {
+                        image_url: `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                      }
+                    });
+                  } else if (part.data.type === "url") {
+                    userContent.push({
+                      type: "input_file",
+                      file_url: part.data.url.toString()
+                    });
+                  } else {
+                    const fullMediaType = resolveFullMediaType({ part });
+                    userContent.push({
+                      type: "input_file",
+                      filename: (_a = part.filename) != null ? _a : "data",
+                      file_data: `data:${fullMediaType};base64,${convertToBase64(part.data.data)}`
+                    });
+                  }
+                  break;
+                }
+              }
+              break;
+            }
+          }
+        }
+        input.push({ type: "message", role: "user", content: userContent });
+        break;
+      }
+      case "assistant": {
+        const assistantContent = [];
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              assistantContent.push({ type: "output_text", text: part.text });
+              break;
+            }
+            case "tool-call": {
+              const argumentsValue = typeof part.input === "string" ? part.input : JSON.stringify(part.input);
+              toolCalls.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: argumentsValue
+              });
+              break;
+            }
+          }
+        }
+        if (assistantContent.length > 0) {
+          input.push({
+            type: "message",
+            role: "assistant",
+            content: assistantContent
+          });
+        }
+        for (const toolCall of toolCalls) {
+          input.push(toolCall);
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of content) {
+          if (part.type === "tool-result") {
+            const output = part.output;
+            let contentValue;
+            switch (output.type) {
+              case "text":
+              case "error-text":
+                contentValue = output.value;
+                break;
+              case "execution-denied":
+                contentValue = (_b = output.reason) != null ? _b : "Tool call execution denied.";
+                break;
+              case "json":
+              case "error-json":
+                contentValue = JSON.stringify(output.value);
+                break;
+              case "content": {
+                const contentParts = [];
+                for (const item of output.value) {
+                  switch (item.type) {
+                    case "text": {
+                      contentParts.push({
+                        type: "input_text",
+                        text: item.text
+                      });
+                      break;
+                    }
+                    case "file": {
+                      const topLevel = getTopLevelMediaType(item.mediaType);
+                      if (item.data.type === "data") {
+                        const fullMediaType = resolveFullMediaType({
+                          part: item
+                        });
+                        if (topLevel === "image") {
+                          contentParts.push({
+                            type: "input_image",
+                            image_url: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`
+                          });
+                        } else {
+                          contentParts.push({
+                            type: "input_file",
+                            filename: (_c = item.filename) != null ? _c : "data",
+                            file_data: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`
+                          });
+                        }
+                      } else if (item.data.type === "url") {
+                        if (topLevel === "image") {
+                          contentParts.push({
+                            type: "input_image",
+                            image_url: item.data.url.toString()
+                          });
+                        } else {
+                          contentParts.push({
+                            type: "input_file",
+                            file_url: item.data.url.toString()
+                          });
+                        }
+                      } else {
+                        warnings.push({
+                          type: "other",
+                          message: `unsupported tool content part type: ${item.type} with data type: ${item.data.type}`
+                        });
+                      }
+                      break;
+                    }
+                    default: {
+                      warnings.push({
+                        type: "other",
+                        message: `unsupported tool content part type: ${item.type}`
+                      });
+                      break;
+                    }
+                  }
+                }
+                contentValue = contentParts;
+                break;
+              }
+            }
+            input.push({
+              type: "function_call_output",
+              call_id: part.toolCallId,
+              output: contentValue
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+  return {
+    input,
+    instructions: systemMessages.length > 0 ? systemMessages.join("\n") : void 0,
+    warnings
+  };
+}
+
+// src/responses/open-responses-api.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var openResponsesErrorSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      error: z.object({
+        message: z.string(),
+        type: z.string(),
+        param: z.string(),
+        code: z.string()
+      })
+    })
+  )
+);
+
+// src/responses/map-open-responses-finish-reason.ts
+function mapOpenResponsesFinishReason({
+  finishReason,
+  hasToolCalls
+}) {
+  switch (finishReason) {
+    case void 0:
+    case null:
+      return hasToolCalls ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasToolCalls ? "tool-calls" : "other";
+  }
+}
+
+// src/responses/open-responses-language-model-options.ts
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var openResponsesLanguageModelOptions = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      /**
+       * Controls reasoning summary output from the model.
+       * Valid values: 'concise', 'detailed', 'auto'.
+       */
+      reasoningSummary: z2.enum(["concise", "detailed", "auto"]).nullish()
+    })
+  )
+);
+
+// src/responses/open-responses-language-model.ts
+var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
+  constructor(modelId, config) {
+    this.specificationVersion = "v4";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/]
+    };
+    this.modelId = modelId;
+    this.config = config;
+  }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _OpenResponsesLanguageModel(options.modelId, options.config);
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    maxOutputTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    reasoning,
+    prompt,
+    providerOptions,
+    tools,
+    toolChoice,
+    responseFormat
+  }) {
+    var _a;
+    const warnings = [];
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported", feature: "stopSequences" });
+    }
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported", feature: "seed" });
+    }
+    const {
+      input,
+      instructions,
+      warnings: inputWarnings
+    } = await convertToOpenResponsesInput({
+      prompt
+    });
+    warnings.push(...inputWarnings);
+    const functionTools = tools == null ? void 0 : tools.filter((tool) => tool.type === "function").map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+      ...tool.strict != null ? { strict: tool.strict } : {}
+    }));
+    const convertedToolChoice = toolChoice == null ? void 0 : toolChoice.type === "tool" ? { type: "function", name: toolChoice.toolName } : toolChoice.type;
+    const textFormat = (responseFormat == null ? void 0 : responseFormat.type) === "json" ? {
+      type: "json_schema",
+      ...responseFormat.schema != null ? {
+        name: (_a = responseFormat.name) != null ? _a : "response",
+        description: responseFormat.description,
+        schema: responseFormat.schema,
+        strict: true
+      } : {}
+    } : void 0;
+    const openResponsesOptions = await parseProviderOptions({
+      provider: this.config.providerOptionsName,
+      providerOptions,
+      schema: openResponsesLanguageModelOptions
+    });
+    const resolvedReasoningEffort = isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: {
+        minimal: "low",
+        low: "low",
+        medium: "medium",
+        high: "high",
+        xhigh: "xhigh"
+      },
+      warnings
+    }) : void 0;
+    return {
+      body: {
+        model: this.modelId,
+        input,
+        instructions,
+        max_output_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        presence_penalty: presencePenalty,
+        frequency_penalty: frequencyPenalty,
+        reasoning: resolvedReasoningEffort != null || (openResponsesOptions == null ? void 0 : openResponsesOptions.reasoningSummary) != null ? {
+          ...resolvedReasoningEffort != null && {
+            effort: resolvedReasoningEffort
+          },
+          ...(openResponsesOptions == null ? void 0 : openResponsesOptions.reasoningSummary) != null && {
+            summary: openResponsesOptions.reasoningSummary
+          }
+        } : void 0,
+        tools: (functionTools == null ? void 0 : functionTools.length) ? functionTools : void 0,
+        tool_choice: convertedToolChoice,
+        ...textFormat != null && { text: { format: textFormat } }
+      },
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { body, warnings } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      body,
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: openResponsesErrorSchema,
+        errorToMessage: (error) => error.error.message
+      }),
+      successfulResponseHandler: createJsonResponseHandler(
+        // do not validate the response body, only apply types to the response body
+        jsonSchema(() => {
+          throw new Error("json schema not implemented");
+        })
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const content = [];
+    let hasToolCalls = false;
+    for (const part of response.output) {
+      switch (part.type) {
+        // TODO AI SDK 7 adjust reasoning in the specification to better support the reasoning structure from open responses.
+        case "reasoning": {
+          for (const contentPart of (_c = part.content) != null ? _c : []) {
+            content.push({
+              type: "reasoning",
+              text: contentPart.text
+            });
+          }
+          break;
+        }
+        case "message": {
+          for (const contentPart of part.content) {
+            content.push({
+              type: "text",
+              text: contentPart.text
+            });
+          }
+          break;
+        }
+        case "function_call": {
+          hasToolCalls = true;
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: part.name,
+            input: part.arguments
+          });
+          break;
+        }
+      }
+    }
+    const usage = response.usage;
+    const inputTokens = usage == null ? void 0 : usage.input_tokens;
+    const cachedInputTokens = (_d = usage == null ? void 0 : usage.input_tokens_details) == null ? void 0 : _d.cached_tokens;
+    const outputTokens = usage == null ? void 0 : usage.output_tokens;
+    const reasoningTokens = (_e = usage == null ? void 0 : usage.output_tokens_details) == null ? void 0 : _e.reasoning_tokens;
+    return {
+      content,
+      finishReason: {
+        unified: mapOpenResponsesFinishReason({
+          finishReason: (_f = response.incomplete_details) == null ? void 0 : _f.reason,
+          hasToolCalls
+        }),
+        raw: (_h = (_g = response.incomplete_details) == null ? void 0 : _g.reason) != null ? _h : void 0
+      },
+      usage: {
+        inputTokens: {
+          total: inputTokens,
+          noCache: (inputTokens != null ? inputTokens : 0) - (cachedInputTokens != null ? cachedInputTokens : 0),
+          cacheRead: cachedInputTokens,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: outputTokens,
+          text: (outputTokens != null ? outputTokens : 0) - (reasoningTokens != null ? reasoningTokens : 0),
+          reasoning: reasoningTokens
+        },
+        raw: response.usage
+      },
+      request: { body },
+      response: {
+        id: response.id,
+        timestamp: new Date(response.created_at * 1e3),
+        modelId: response.model,
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      providerMetadata: void 0,
+      warnings
+    };
+  }
+  async doStream(options) {
+    var _a, _b;
+    const { body, warnings } = await this.getArgs(options);
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      body: {
+        ...body,
+        stream: true
+      },
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: openResponsesErrorSchema,
+        errorToMessage: (error) => error.error.message
+      }),
+      successfulResponseHandler: createEventSourceResponseHandler(z3.any()),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const usage = {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      }
+    };
+    const updateUsage = (responseUsage) => {
+      var _a2, _b2;
+      if (!responseUsage) {
+        return;
+      }
+      const inputTokens = responseUsage.input_tokens;
+      const cachedInputTokens = (_a2 = responseUsage.input_tokens_details) == null ? void 0 : _a2.cached_tokens;
+      const outputTokens = responseUsage.output_tokens;
+      const reasoningTokens = (_b2 = responseUsage.output_tokens_details) == null ? void 0 : _b2.reasoning_tokens;
+      usage.inputTokens = {
+        total: inputTokens,
+        noCache: (inputTokens != null ? inputTokens : 0) - (cachedInputTokens != null ? cachedInputTokens : 0),
+        cacheRead: cachedInputTokens,
+        cacheWrite: void 0
+      };
+      usage.outputTokens = {
+        total: outputTokens,
+        text: (outputTokens != null ? outputTokens : 0) - (reasoningTokens != null ? reasoningTokens : 0),
+        reasoning: reasoningTokens
+      };
+      usage.raw = responseUsage;
+    };
+    let isActiveReasoning = false;
+    let hasToolCalls = false;
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    const toolCallsByItemId = /* @__PURE__ */ new Map();
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(parseResult, controller) {
+            var _a2, _b2, _c, _d, _e, _f, _g, _h;
+            if (options.includeRawChunks) {
+              controller.enqueue({
+                type: "raw",
+                rawValue: parseResult.rawValue
+              });
+            }
+            if (!parseResult.success) {
+              controller.enqueue({ type: "error", error: parseResult.error });
+              return;
+            }
+            const chunk = parseResult.value;
+            if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
+              toolCallsByItemId.set(chunk.item.id, {
+                toolName: chunk.item.name,
+                toolCallId: chunk.item.call_id,
+                arguments: chunk.item.arguments
+              });
+            } else if (chunk.type === "response.function_call_arguments.delta") {
+              const functionCallChunk = chunk;
+              const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
+              if (toolCall == null) {
+                toolCallsByItemId.set(functionCallChunk.item_id, {
+                  arguments: functionCallChunk.delta
+                });
+                return;
+              }
+              toolCall.arguments = ((_a2 = toolCall.arguments) != null ? _a2 : "") + functionCallChunk.delta;
+            } else if (chunk.type === "response.function_call_arguments.done") {
+              const functionCallChunk = chunk;
+              const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
+              if (toolCall == null) {
+                toolCallsByItemId.set(functionCallChunk.item_id, {
+                  arguments: functionCallChunk.arguments
+                });
+                return;
+              }
+              toolCall.arguments = functionCallChunk.arguments;
+            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "function_call") {
+              const toolCall = toolCallsByItemId.get(chunk.item.id);
+              const toolName = (_b2 = toolCall == null ? void 0 : toolCall.toolName) != null ? _b2 : chunk.item.name;
+              const toolCallId = (_c = toolCall == null ? void 0 : toolCall.toolCallId) != null ? _c : chunk.item.call_id;
+              const input = (_e = (_d = toolCall == null ? void 0 : toolCall.arguments) != null ? _d : chunk.item.arguments) != null ? _e : "";
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId,
+                toolName,
+                input
+              });
+              hasToolCalls = true;
+              toolCallsByItemId.delete(chunk.item.id);
+            } else if (chunk.type === "response.output_item.added" && chunk.item.type === "reasoning") {
+              controller.enqueue({
+                type: "reasoning-start",
+                id: chunk.item.id
+              });
+              isActiveReasoning = true;
+            } else if (chunk.type === "response.reasoning_text.delta") {
+              const reasoningChunk = chunk;
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: reasoningChunk.item_id,
+                delta: reasoningChunk.delta
+              });
+            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "reasoning") {
+              controller.enqueue({ type: "reasoning-end", id: chunk.item.id });
+              isActiveReasoning = false;
+            } else if (chunk.type === "response.output_item.added" && chunk.item.type === "message") {
+              controller.enqueue({ type: "text-start", id: chunk.item.id });
+            } else if (chunk.type === "response.output_text.delta") {
+              controller.enqueue({
+                type: "text-delta",
+                id: chunk.item_id,
+                delta: chunk.delta
+              });
+            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "message") {
+              controller.enqueue({ type: "text-end", id: chunk.item.id });
+            } else if (chunk.type === "response.completed" || chunk.type === "response.incomplete") {
+              const reason = (_f = chunk.response.incomplete_details) == null ? void 0 : _f.reason;
+              finishReason = {
+                unified: mapOpenResponsesFinishReason({
+                  finishReason: reason,
+                  hasToolCalls
+                }),
+                raw: reason != null ? reason : void 0
+              };
+              updateUsage(chunk.response.usage);
+            } else if (chunk.type === "response.failed") {
+              finishReason = {
+                unified: "error",
+                raw: (_h = (_g = chunk.response.error) == null ? void 0 : _g.code) != null ? _h : chunk.response.status
+              };
+              updateUsage(chunk.response.usage);
+            }
+          },
+          flush(controller) {
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata: void 0
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+
+// src/open-responses-provider.ts
+function createOpenResponses(options) {
+  const providerName = options.name;
+  const getHeaders = () => withUserAgentSuffix(
+    {
+      ...options.apiKey ? {
+        Authorization: `Bearer ${options.apiKey}`
+      } : {},
+      ...options.headers
+    },
+    `ai-sdk/open-responses/${VERSION}`
+  );
+  const createResponsesModel = (modelId) => {
+    return new OpenResponsesLanguageModel(modelId, {
+      provider: `${providerName}.responses`,
+      providerOptionsName: providerName,
+      headers: getHeaders,
+      url: options.url,
+      fetch: options.fetch,
+      generateId: () => generateId()
+    });
+  };
+  const createLanguageModel = (modelId) => {
+    if (new.target) {
+      throw new Error(
+        "The OpenAI model function cannot be called with the new keyword."
+      );
+    }
+    return createResponsesModel(modelId);
+  };
+  const provider = function(modelId) {
+    return createLanguageModel(modelId);
+  };
+  provider.specificationVersion = "v4";
+  provider.languageModel = createLanguageModel;
+  provider.embeddingModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  return provider;
+}
+export {
+  VERSION,
+  createOpenResponses
+};
+//# sourceMappingURL=index.js.map