@jerome-benoit/sap-ai-provider-v2 5.0.3 → 5.1.0

package/dist/responses-language-model-strategy-UYTV6TPM.js

@@ -0,0 +1,738 @@
+import {createRequire as __createRequire} from 'module';var require=__createRequire(import.meta.url);
+import {
+  ERROR_BODY_READ_FAILURE,
+  destroyHttpResponse,
+  findFailedHttpRequest,
+  isDestroyableRequest,
+  preserveResponseBodyTimeout,
+  readHttpErrorBody
+} from "./chunk-4ILJD6PI.js";
+import {
+  getURLHref
+} from "./chunk-FKHOJ3ZC.js";
+import {
+  buildModelDeployment,
+  createAISDKRequestBodySummary,
+  createAbortError,
+  mergeRequestConfig,
+  throwIfAborted,
+  waitWithAbort
+} from "./chunk-DLGBK3C3.js";
+import {
+  VERSION,
+  getProviderName
+} from "./chunk-BHA5MIN6.js";
+import {
+  convertToAISDKError,
+  normalizeHeaders
+} from "./chunk-QFMHNGLB.js";
+
+// src/responses-language-model-strategy.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
+import { z } from "zod";
+
+// src/responses-adapters-v3-to-v4.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { getTopLevelMediaType } from "@ai-sdk/provider-utils";
+function convertResponsesCallToV4(options) {
+  return {
+    ...options,
+    prompt: options.prompt.map((message) => {
+      switch (message.role) {
+        case "assistant":
+          return { ...message, content: message.content.map(convertPromptPart) };
+        case "system":
+          return message;
+        case "tool":
+          return {
+            ...message,
+            content: message.content.map(
+              (part) => part.type === "tool-result" ? convertToolResult(part) : part
+            )
+          };
+        case "user":
+          return {
+            ...message,
+            content: message.content.map(
+              (part) => part.type === "file" ? convertFile(part) : part
+            )
+          };
+      }
+    })
+  };
+}
+function convertFile(part) {
+  const data = part.data;
+  const href = getURLHref(data);
+  if (href !== void 0) {
+    const url = data instanceof URL && data.toString === URL.prototype.toString ? data : new URL(href);
+    return { ...part, data: { type: "url", url } };
+  }
+  return { ...part, data: { data, type: "data" } };
+}
+function convertPromptPart(part) {
+  if (part.type === "file") {
+    throw new UnsupportedFunctionalityError({
+      functionality: "Responses assistant file history is not supported."
+    });
+  }
+  if (part.type === "tool-result") return convertToolResult(part);
+  return part;
+}
+function convertToolItem(item) {
+  switch (item.type) {
+    case "custom":
+    case "text":
+      return item;
+    case "file-data":
+    case "image-data": {
+      const delegateIsImage = getTopLevelMediaType(item.mediaType) === "image";
+      if (delegateIsImage !== (item.type === "image-data")) {
+        throw new UnsupportedFunctionalityError({
+          functionality: "Responses tool-result media whose legacy category disagrees with its media type."
+        });
+      }
+      return { ...item, data: { data: item.data, type: "data" }, type: "file" };
+    }
+    case "file-id":
+    case "image-file-id":
+      return {
+        data: {
+          reference: typeof item.fileId === "string" ? { openai: item.fileId } : item.fileId,
+          type: "reference"
+        },
+        mediaType: item.type === "image-file-id" ? "image" : "application/octet-stream",
+        providerOptions: item.providerOptions,
+        type: "file"
+      };
+    case "file-url":
+    case "image-url":
+      return {
+        data: { type: "url", url: new URL(item.url) },
+        mediaType: item.type === "image-url" ? "image" : "application/octet-stream",
+        providerOptions: item.providerOptions,
+        type: "file"
+      };
+  }
+}
+function convertToolResult(part) {
+  return part.output.type === "content" ? { ...part, output: { ...part.output, value: part.output.value.map(convertToolItem) } } : { ...part, output: part.output };
+}
+
+// src/responses-adapters-v4-to-v3.ts
+import { UnsupportedFunctionalityError as UnsupportedFunctionalityError2 } from "@ai-sdk/provider";
+
+// src/adapter-metadata.ts
+var ORIGINAL_V4_FINISH_REASON = /* @__PURE__ */ Symbol.for(
+  "@jerome-benoit/sap-ai-provider/adapter-metadata.originalV4FinishReason"
+);
+
+// src/responses-adapters-v4-to-v3.ts
+function convertResponsesResultToV3(result) {
+  return {
+    ...result,
+    content: result.content.map(convertContent),
+    finishReason: convertFinishReason(result.finishReason),
+    warnings: result.warnings.map(convertWarning)
+  };
+}
+function convertResponsesStreamPartToV3(part) {
+  switch (part.type) {
+    case "custom":
+    case "reasoning-file":
+      throw new UnsupportedFunctionalityError2({
+        functionality: `Responses '${part.type}' output has no V3 equivalent.`
+      });
+    case "file":
+      return convertGeneratedFile(part);
+    case "finish":
+      return { ...part, finishReason: convertFinishReason(part.finishReason) };
+    case "stream-start":
+      return { ...part, warnings: part.warnings.map(convertWarning) };
+    default:
+      return part;
+  }
+}
+function convertContent(part) {
+  if (part.type === "custom" || part.type === "reasoning-file") {
+    throw new UnsupportedFunctionalityError2({
+      functionality: `Responses '${part.type}' output has no V3 equivalent.`
+    });
+  }
+  return part.type === "file" ? convertGeneratedFile(part) : part;
+}
+function convertFinishReason(reason) {
+  if (reason.unified !== "interrupted") return reason;
+  const converted = { ...reason, unified: "other" };
+  return Object.defineProperty(converted, ORIGINAL_V4_FINISH_REASON, { value: reason });
+}
+function convertGeneratedFile(part) {
+  if (part.data.type !== "data") {
+    throw new UnsupportedFunctionalityError2({
+      functionality: "Responses generated file URLs have no V3 equivalent and are not fetched."
+    });
+  }
+  return { ...part, data: part.data.data };
+}
+function convertWarning(warning) {
+  return warning.type === "deprecated" ? { message: `${warning.setting}: ${warning.message}`, type: "other" } : warning;
+}
+
+// src/responses-http-transport.ts
+import { APICallError } from "@ai-sdk/provider";
+import { getFoundationModelDeploymentId, getResourceGroup } from "@sap-ai-sdk/ai-api/internal.js";
+import { executeRequest, getAiCoreDestination } from "@sap-ai-sdk/core";
+import { getTargetUrl } from "@sap-ai-sdk/core/internal.js";
+async function createResponsesTransport(config, settings, options) {
+  throwIfAborted(options.abortSignal);
+  const deployment = buildModelDeployment(config, settings.modelVersion);
+  const [deploymentId, destination] = await waitWithAbort(
+    Promise.all([
+      getFoundationModelDeploymentId(deployment, "azure-openai", config.destination),
+      getAiCoreDestination(config.destination)
+    ]),
+    options.abortSignal
+  );
+  throwIfAborted(options.abortSignal);
+  const deploymentPath = `/inference/deployments/${encodeURIComponent(deploymentId)}`;
+  const baseURL = getTargetUrl(destination.url, deploymentPath);
+  const endpoint = new URL(`${baseURL}/responses`);
+  const requestConfig = mergeRequestConfig(
+    config.requestConfig,
+    options.abortSignal,
+    options.headers
+  );
+  const activeRequests = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let disposalReason;
+  const dispose = (reason) => {
+    if (disposed) return;
+    disposed = true;
+    disposalReason = reason;
+    for (const release of activeRequests) {
+      try {
+        release(reason);
+      } catch {
+      }
+    }
+    activeRequests.clear();
+  };
+  const fetch = async (input, init) => {
+    if (disposed) throw createAbortError(disposalReason);
+    const url = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+    if (url.origin !== endpoint.origin || url.pathname !== endpoint.pathname) {
+      throw new TypeError("SAP Responses requests must target the configured deployment.");
+    }
+    if (init?.method !== "POST" || typeof init.body !== "string") {
+      throw new TypeError("SAP Responses requires a POST request with a JSON body.");
+    }
+    const body = JSON.parse(init.body);
+    const operation = typeof body === "object" && body !== null && "stream" in body && body.stream === true ? "doStream" : "doGenerate";
+    const controller = new AbortController();
+    const signal = options.abortSignal ?? init.signal;
+    const bodyTimeoutCleanups = /* @__PURE__ */ new Set();
+    let abortFailedRequest;
+    let activeResponse;
+    const onAbort = () => {
+      controller.abort(signal?.reason);
+    };
+    const cleanup = () => {
+      activeRequests.delete(disposeRequest);
+      signal?.removeEventListener("abort", onAbort);
+      if (abortFailedRequest) controller.signal.removeEventListener("abort", abortFailedRequest);
+      for (const dispose2 of bodyTimeoutCleanups) dispose2();
+      activeResponse = void 0;
+    };
+    const disposeRequest = (reason) => {
+      try {
+        controller.abort(reason);
+      } finally {
+        try {
+          if (activeResponse) destroyHttpResponse(activeResponse);
+        } finally {
+          cleanup();
+        }
+      }
+    };
+    throwIfAborted(signal ?? void 0);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    activeRequests.add(disposeRequest);
+    const headers = new Headers(init.headers);
+    headers.delete("authorization");
+    const configuredHeaders = Object.fromEntries(
+      Object.entries(requestConfig?.headers ?? {}).map(([key, value]) => [
+        key.toLowerCase(),
+        value
+      ])
+    );
+    let failedRequest;
+    let failedError;
+    const watchResponse = (response, request) => {
+      activeResponse = response;
+      if (controller.signal.aborted) destroyHttpResponse(response);
+      else preserveResponseBodyTimeout(response, request, bodyTimeoutCleanups);
+      return response;
+    };
+    const preserveBodyTimeout = ({ fn }) => async (request) => {
+      try {
+        return watchResponse(await fn(request), request);
+      } catch (error) {
+        const failed = findFailedHttpRequest(error);
+        if (failed) watchResponse(failed.response, request);
+        throw error;
+      }
+    };
+    const preserveErrorResponse = ({ fn }) => async (request) => {
+      try {
+        return await fn(request);
+      } catch (error) {
+        const failed = findFailedHttpRequest(error);
+        if (!failed) throw error;
+        failedRequest = failed;
+        failedError = error;
+        const request2 = failed.response.request;
+        if (isDestroyableRequest(request2)) {
+          abortFailedRequest = () => {
+            request2.destroy();
+          };
+          if (controller.signal.aborted) abortFailedRequest();
+          else controller.signal.addEventListener("abort", abortFailedRequest, { once: true });
+        }
+        return failed.response;
+      }
+    };
+    try {
+      const pendingResponse = executeRequest(
+        {
+          apiVersion: "2024-10-21",
+          resourceGroup: getResourceGroup(deployment),
+          url: `${deploymentPath}/responses`
+        },
+        body,
+        {
+          ...requestConfig,
+          headers: { ...Object.fromEntries(headers), ...configuredHeaders },
+          middleware: [
+            preserveErrorResponse,
+            ...requestConfig?.middleware ?? [],
+            preserveBodyTimeout
+          ],
+          responseType: "stream",
+          signal: controller.signal
+        },
+        config.destination
+      );
+      const response = await waitWithAbort(pendingResponse, controller.signal, destroyHttpResponse);
+      activeResponse = response;
+      if (controller.signal.aborted) {
+        destroyHttpResponse(response);
+        throw createAbortError(controller.signal.reason);
+      }
+      const responseBody = response.data;
+      const responseStream = createByteStream(
+        responseBody,
+        controller,
+        cleanup,
+        config,
+        options,
+        operation
+      );
+      if (failedRequest) {
+        const readFailure = await readHttpErrorBody(
+          failedRequest.response,
+          responseStream,
+          signal ?? void 0
+        );
+        const failure = convertToAISDKError(failedError, {
+          modelId: config.modelId,
+          modelType: "languageModel",
+          operation,
+          requestBody: createAISDKRequestBodySummary(options),
+          url: "sap-ai:responses"
+        });
+        if (readFailure !== void 0 && APICallError.isInstance(failure)) {
+          Object.defineProperty(failure, ERROR_BODY_READ_FAILURE, { value: readFailure });
+        }
+        throw failure;
+      }
+      return new Response(responseStream, {
+        headers: normalizeHeaders(response.headers),
+        status: response.status
+      });
+    } catch (error) {
+      dispose(error);
+      throw error;
+    }
+  };
+  return { baseURL, dispose, fetch };
+}
+function createByteStream(body, requestController, cleanup, config, options, operation) {
+  if (typeof body !== "object" || body === null || !(Symbol.asyncIterator in body) || typeof body[Symbol.asyncIterator] !== "function") {
+    requestController.abort();
+    cleanup();
+    throw new TypeError("SAP Responses did not return a readable response body.");
+  }
+  const source = body;
+  const iterator = source[Symbol.asyncIterator]();
+  const encoder = new TextEncoder();
+  const onAbort = () => source.destroy?.();
+  const cleanupStream = () => {
+    requestController.signal.removeEventListener("abort", onAbort);
+    cleanup();
+  };
+  requestController.signal.addEventListener("abort", onAbort, { once: true });
+  if (requestController.signal.aborted) onAbort();
+  return new ReadableStream(
+    {
+      async cancel(reason) {
+        requestController.abort(reason);
+        cleanupStream();
+        if (source.destroy) {
+          source.destroy();
+        } else {
+          await iterator.return?.();
+        }
+      },
+      async pull(controller) {
+        try {
+          throwIfAborted(requestController.signal);
+          const chunk = await iterator.next();
+          throwIfAborted(requestController.signal);
+          if (chunk.done) {
+            cleanupStream();
+            controller.close();
+          } else if (typeof chunk.value === "string") {
+            controller.enqueue(encoder.encode(chunk.value));
+          } else if (chunk.value instanceof Uint8Array) {
+            controller.enqueue(chunk.value);
+          } else {
+            throw new TypeError("SAP Responses returned a non-byte response chunk.");
+          }
+        } catch (error) {
+          const failure = requestController.signal.aborted ? createAbortError(requestController.signal.reason) : error;
+          requestController.abort(error);
+          cleanupStream();
+          source.destroy?.();
+          controller.error(
+            convertToAISDKError(failure, {
+              modelId: config.modelId,
+              modelType: "languageModel",
+              operation,
+              requestBody: createAISDKRequestBodySummary(options),
+              url: "sap-ai:responses"
+            })
+          );
+        }
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+
+// src/responses-language-model-strategy.ts
+var MODEL_PARAMETERS = /* @__PURE__ */ new Set([
+  "frequencyPenalty",
+  "maxTokens",
+  "parallel_tool_calls",
+  "presencePenalty",
+  "temperature",
+  "topP"
+]);
+var OPENAI_STREAM_ERROR_SCHEMA = z.object({
+  data: z.object({ type: z.enum(["error", "response.failed"]) }).loose(),
+  isRetryable: z.boolean(),
+  message: z.string(),
+  statusCode: z.number().int().min(400).max(599)
+});
+var ResponsesLanguageModelStrategy = class {
+  async doGenerate(config, settings, options) {
+    let dispose;
+    try {
+      const prepared = await prepareModel(config, settings, options);
+      dispose = prepared.dispose;
+      const { input, model, providerName, warnings } = prepared;
+      const result = convertResponsesResultToV3(await model.doGenerate(input));
+      return {
+        ...result,
+        content: result.content.map((part) => fromOpenAIContent(part, providerName)),
+        providerMetadata: responseMetadata(result.providerMetadata, providerName),
+        warnings: [...warnings, ...result.warnings]
+      };
+    } catch (error) {
+      const failure = convertError(error, config, options, "doGenerate");
+      dispose?.(failure);
+      throw failure;
+    }
+  }
+  async doStream(config, settings, options) {
+    let dispose;
+    try {
+      const prepared = await prepareModel(config, settings, options);
+      dispose = prepared.dispose;
+      const { input, model, providerName, warnings } = prepared;
+      const result = await model.doStream(input);
+      const reader = result.stream.getReader();
+      let cancelled = false;
+      const isCancelled = () => cancelled;
+      return {
+        ...result,
+        stream: new ReadableStream(
+          {
+            async cancel(reason) {
+              cancelled = true;
+              dispose?.(reason);
+              try {
+                await reader.cancel(reason);
+              } finally {
+                reader.releaseLock();
+              }
+            },
+            async pull(controller) {
+              try {
+                if (options.abortSignal?.aborted)
+                  throw createAbortError(options.abortSignal.reason);
+                const next = await reader.read();
+                if (isCancelled()) return;
+                if (options.abortSignal?.aborted)
+                  throw createAbortError(options.abortSignal.reason);
+                if (next.done) {
+                  reader.releaseLock();
+                  controller.close();
+                  return;
+                }
+                const part = convertResponsesStreamPartToV3(next.value);
+                if (part.type === "stream-start") {
+                  controller.enqueue({ ...part, warnings: [...warnings, ...part.warnings] });
+                } else if (part.type === "finish") {
+                  controller.enqueue({
+                    ...part,
+                    providerMetadata: responseMetadata(part.providerMetadata, providerName)
+                  });
+                } else if (part.type === "error") {
+                  controller.enqueue({
+                    ...part,
+                    error: convertError(part.error, config, options, "doStream")
+                  });
+                } else if ("providerMetadata" in part || part.type === "text-end") {
+                  controller.enqueue(fromOpenAIContent(part, providerName));
+                } else {
+                  controller.enqueue(part);
+                }
+              } catch (error) {
+                if (isCancelled()) return;
+                const failure = convertError(error, config, options, "doStream");
+                dispose?.(failure);
+                await reader.cancel(error).catch(() => void 0);
+                if (isCancelled()) return;
+                reader.releaseLock();
+                controller.enqueue({
+                  error: failure,
+                  type: "error"
+                });
+                controller.close();
+              }
+            }
+          },
+          { highWaterMark: 0 }
+        )
+      };
+    } catch (error) {
+      const failure = convertError(error, config, options, "doStream");
+      dispose?.(failure);
+      throw failure;
+    }
+  }
+};
+function convertError(error, config, options, operation) {
+  if (APICallError2.isInstance(error) && error.message === "Failed to process successful response" && error.statusCode !== void 0 && error.statusCode >= 200 && error.statusCode < 300 && APICallError2.isInstance(error.cause)) {
+    return error.cause;
+  }
+  if (operation === "doStream" && !APICallError2.isInstance(error)) {
+    const parsed = OPENAI_STREAM_ERROR_SCHEMA.safeParse(error);
+    if (parsed.success) {
+      return new APICallError2({
+        cause: error,
+        data: parsed.data.data,
+        isRetryable: parsed.data.isRetryable,
+        message: parsed.data.message,
+        requestBodyValues: createAISDKRequestBodySummary(options),
+        statusCode: parsed.data.statusCode,
+        url: "sap-ai:responses"
+      });
+    }
+  }
+  return convertToAISDKError(error, {
+    modelId: config.modelId,
+    modelType: "languageModel",
+    operation,
+    requestBody: createAISDKRequestBodySummary(options),
+    url: "sap-ai:responses"
+  });
+}
+function fromOpenAI(metadata, providerName) {
+  if (providerName === "openai" || !metadata?.openai) return metadata;
+  const { openai, ...rest } = metadata;
+  return { ...rest, [providerName]: { ...rest[providerName], ...openai } };
+}
+function fromOpenAICitations(citations, providerName) {
+  if (providerName === "openai" || !citations) return citations;
+  let mapped;
+  let index = 0;
+  for (const citation of citations) {
+    const providerMetadata = fromOpenAI(citation.source.providerMetadata, providerName);
+    if (providerMetadata !== citation.source.providerMetadata) {
+      mapped ??= citations.slice();
+      mapped[index] = {
+        ...citation,
+        source: { ...citation.source, providerMetadata }
+      };
+    }
+    index++;
+  }
+  return mapped ?? citations;
+}
+function fromOpenAIContent(part, providerName) {
+  const providerMetadata = fromOpenAI(part.providerMetadata, providerName);
+  const citations = fromOpenAICitations(part.citations, providerName);
+  if (providerMetadata === part.providerMetadata && citations === part.citations) return part;
+  if (providerMetadata === part.providerMetadata) return { ...part, citations };
+  return citations === part.citations ? { ...part, providerMetadata } : { ...part, citations, providerMetadata };
+}
+function modelResponseFormat(settings) {
+  const format = settings.responseFormat;
+  if (!format || format.type === "text") return format;
+  if (format.type === "json_object") return { type: "json" };
+  const schema = format.json_schema;
+  return {
+    description: schema.description,
+    name: schema.name,
+    schema: schema.schema === void 0 ? void 0 : z.record(z.string(), z.json()).parse(schema.schema),
+    type: "json"
+  };
+}
+async function prepareModel(config, settings, options) {
+  if (options.abortSignal?.aborted) {
+    throw createAbortError(options.abortSignal.reason);
+  }
+  const providerName = getProviderName(config.provider);
+  const sapOptions = config.parsedProviderOptions;
+  const parameters = { ...settings.modelParams, ...sapOptions?.modelParams };
+  const warnings = Object.keys(parameters).filter((key) => !MODEL_PARAMETERS.has(key)).map((key) => ({
+    details: "Use the responses option for Responses-specific parameters.",
+    feature: `modelParams.${key}`,
+    type: "unsupported"
+  }));
+  if (sapOptions?.includeReasoning ?? settings.includeReasoning) {
+    warnings.push({
+      details: "Responses preserves native reasoning history instead of converting it to text.",
+      feature: "includeReasoning",
+      type: "unsupported"
+    });
+  }
+  const responseOptions = {
+    ...parameters.parallel_tool_calls !== void 0 ? { parallelToolCalls: parameters.parallel_tool_calls } : {},
+    ...settings.responseFormat?.type === "json_schema" ? { strictJsonSchema: settings.responseFormat.json_schema.strict } : {},
+    store: false,
+    ...settings.responses,
+    ...sapOptions?.responses
+  };
+  const reasoning = "reasoning" in options ? options.reasoning : void 0;
+  if (typeof reasoning === "string" && reasoning !== "provider-default") {
+    responseOptions.reasoningEffort = reasoning;
+  }
+  const input = {
+    ...options,
+    frequencyPenalty: options.frequencyPenalty ?? parameters.frequencyPenalty,
+    maxOutputTokens: options.maxOutputTokens ?? parameters.maxTokens,
+    presencePenalty: options.presencePenalty ?? parameters.presencePenalty,
+    prompt: toOpenAIPrompt(options.prompt, providerName),
+    providerOptions: {
+      ...options.providerOptions,
+      openai: responseOptions
+    },
+    responseFormat: options.responseFormat ?? modelResponseFormat(settings),
+    temperature: options.temperature ?? parameters.temperature,
+    tools: options.tools?.map(
+      (tool) => tool.type === "function" ? {
+        ...tool,
+        providerOptions: toOpenAI(tool.providerOptions, providerName),
+        strict: tool.strict ?? false
+      } : tool
+    ),
+    topP: options.topP ?? parameters.topP
+  };
+  const convertedInput = convertResponsesCallToV4(input);
+  const transport = await createResponsesTransport(config, settings, options);
+  const model = createOpenAI({
+    // Authentication is supplied by SAP's transport, not an OpenAI API key.
+    apiKey: "sap-ai-core",
+    baseURL: transport.baseURL,
+    fetch: transport.fetch
+  }).responses(config.modelId);
+  return { dispose: transport.dispose, input: convertedInput, model, providerName, warnings };
+}
+function responseMetadata(metadata, providerName) {
+  const mapped = fromOpenAI(metadata, providerName);
+  return {
+    ...mapped,
+    [providerName]: { ...mapped?.[providerName], api: "responses", version: VERSION }
+  };
+}
+function toOpenAI(options, providerName) {
+  if (providerName === "openai" || !options?.[providerName]) return options;
+  return { ...options, openai: { ...options.openai, ...options[providerName] } };
+}
+function toOpenAIOutput(output, providerName) {
+  const mappedOutput = {
+    ...output,
+    providerOptions: toOpenAI(output.providerOptions, providerName)
+  };
+  if (mappedOutput.type !== "content") return mappedOutput;
+  return {
+    ...mappedOutput,
+    value: mappedOutput.value.map((part) => ({
+      ...part,
+      ...(part.type === "file-id" || part.type === "image-file-id") && typeof part.fileId !== "string" && part.fileId[providerName] ? { fileId: { ...part.fileId, openai: part.fileId[providerName] } } : {},
+      ..."providerOptions" in part ? { providerOptions: toOpenAI(part.providerOptions, providerName) } : {}
+    }))
+  };
+}
+function toOpenAIPart(part, providerName) {
+  return {
+    ...part,
+    ...part.type === "tool-result" ? { output: toOpenAIOutput(part.output, providerName) } : {},
+    providerOptions: toOpenAI(part.providerOptions, providerName)
+  };
+}
+function toOpenAIPrompt(prompt, providerName) {
+  return prompt.map((message) => {
+    const providerOptions = toOpenAI(message.providerOptions, providerName);
+    switch (message.role) {
+      case "assistant":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
+        };
+      case "system":
+        return { ...message, providerOptions };
+      case "tool":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
+        };
+      case "user":
+        return {
+          ...message,
+          content: message.content.map((part) => toOpenAIPart(part, providerName)),
+          providerOptions
+        };
+    }
+  });
+}
+export {
+  ResponsesLanguageModelStrategy
+};
+//# sourceMappingURL=responses-language-model-strategy-UYTV6TPM.js.map