@providerprotocol/ai 0.0.34 → 0.0.36

package/dist/responses/index.js

@@ -0,0 +1,930 @@
+import {
+  parseSSEStream
+} from "../chunk-PMK5LZ5Z.js";
+import {
+  parseJsonResponse
+} from "../chunk-A2IM7PGT.js";
+import {
+  resolveApiKey
+} from "../chunk-ARVM24K2.js";
+import {
+  createProvider
+} from "../chunk-JA3UZALR.js";
+import {
+  AssistantMessage,
+  generateId,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "../chunk-BRP5XJ6Q.js";
+import {
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError,
+  toError
+} from "../chunk-AY55T37A.js";
+import {
+  ErrorCode,
+  ModalityType,
+  UPPError
+} from "../chunk-COS4ON4G.js";
+import {
+  StreamEventType,
+  objectDelta
+} from "../chunk-RJGTRQ47.js";
+
+// src/providers/responses/transform.ts
+function normalizeSystem(system) {
+  if (system === void 0 || system === null) return void 0;
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) {
+    throw new UPPError(
+      "System prompt must be a string or an array of text blocks",
+      ErrorCode.InvalidRequest,
+      "responses",
+      ModalityType.LLM
+    );
+  }
+  const texts = [];
+  for (const block of system) {
+    if (!block || typeof block !== "object" || !("text" in block)) {
+      throw new UPPError(
+        "System prompt array must contain objects with a text field",
+        ErrorCode.InvalidRequest,
+        "responses",
+        ModalityType.LLM
+      );
+    }
+    const textValue = block.text;
+    if (typeof textValue !== "string") {
+      throw new UPPError(
+        "System prompt text must be a string",
+        ErrorCode.InvalidRequest,
+        "responses",
+        ModalityType.LLM
+      );
+    }
+    if (textValue.length > 0) {
+      texts.push(textValue);
+    }
+  }
+  return texts.length > 0 ? texts.join("\n\n") : void 0;
+}
+function filterValidContent(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformContentPart(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "input_text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      if (imageBlock.source.type === "base64") {
+        return {
+          type: "input_image",
+          image_url: `data:${imageBlock.mimeType};base64,${imageBlock.source.data}`
+        };
+      }
+      if (imageBlock.source.type === "url") {
+        return {
+          type: "input_image",
+          image_url: imageBlock.source.url
+        };
+      }
+      if (imageBlock.source.type === "bytes") {
+        const base64 = Buffer.from(imageBlock.source.data).toString("base64");
+        return {
+          type: "input_image",
+          image_url: `data:${imageBlock.mimeType};base64,${base64}`
+        };
+      }
+      throw new UPPError(
+        "Unknown image source type",
+        ErrorCode.InvalidRequest,
+        "responses",
+        ModalityType.LLM
+      );
+    }
+    case "document": {
+      const documentBlock = block;
+      if (documentBlock.source.type === "base64") {
+        return {
+          type: "input_file",
+          filename: documentBlock.title ?? "document",
+          file_data: `data:${documentBlock.mimeType};base64,${documentBlock.source.data}`
+        };
+      }
+      if (documentBlock.source.type === "url") {
+        return {
+          type: "input_file",
+          file_url: documentBlock.source.url
+        };
+      }
+      if (documentBlock.source.type === "text") {
+        const base64 = Buffer.from(documentBlock.source.data).toString("base64");
+        return {
+          type: "input_file",
+          filename: documentBlock.title ?? "document.txt",
+          file_data: `data:text/plain;base64,${base64}`
+        };
+      }
+      throw new UPPError(
+        "Unknown document source type",
+        ErrorCode.InvalidRequest,
+        "responses",
+        ModalityType.LLM
+      );
+    }
+    case "video": {
+      const videoBlock = block;
+      const base64 = Buffer.from(videoBlock.data).toString("base64");
+      return {
+        type: "input_video",
+        video: `data:${videoBlock.mimeType};base64,${base64}`
+      };
+    }
+    case "audio": {
+      const audioBlock = block;
+      const base64 = Buffer.from(audioBlock.data).toString("base64");
+      return {
+        type: "input_file",
+        filename: "audio",
+        file_data: `data:${audioBlock.mimeType};base64,${base64}`
+      };
+    }
+    default:
+      throw new UPPError(
+        `Unsupported content type: ${block.type}`,
+        ErrorCode.InvalidRequest,
+        "responses",
+        ModalityType.LLM
+      );
+  }
+}
+function transformMessage(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    if (validContent.length === 1 && validContent[0]?.type === "text") {
+      return [
+        {
+          type: "message",
+          role: "user",
+          content: validContent[0].text
+        }
+      ];
+    }
+    return [
+      {
+        type: "message",
+        role: "user",
+        content: validContent.map(transformContentPart)
+      }
+    ];
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const items = [];
+    const contentParts = validContent.filter((c) => c.type === "text").map((c) => ({
+      type: "output_text",
+      text: c.text
+    }));
+    if (contentParts.length > 0) {
+      items.push({
+        type: "message",
+        role: "assistant",
+        content: contentParts
+      });
+    }
+    const responsesMeta = message.metadata?.responses;
+    const functionCallItems = responsesMeta?.functionCallItems;
+    if (responsesMeta?.reasoningEncryptedContent) {
+      try {
+        const reasoningData = JSON.parse(responsesMeta.reasoningEncryptedContent);
+        items.push({
+          type: "reasoning",
+          id: reasoningData.id,
+          summary: reasoningData.summary,
+          encrypted_content: reasoningData.encrypted_content
+        });
+      } catch {
+      }
+    }
+    if (functionCallItems && functionCallItems.length > 0) {
+      for (const fc of functionCallItems) {
+        items.push({
+          type: "function_call",
+          id: fc.id,
+          call_id: fc.call_id,
+          name: fc.name,
+          arguments: fc.arguments
+        });
+      }
+    } else if (message.toolCalls && message.toolCalls.length > 0) {
+      for (const call of message.toolCalls) {
+        items.push({
+          type: "function_call",
+          id: `fc_${call.toolCallId}`,
+          call_id: call.toolCallId,
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments)
+        });
+      }
+    }
+    return items;
+  }
+  if (isToolResultMessage(message)) {
+    return message.results.map((result) => ({
+      type: "function_call_output",
+      call_id: result.toolCallId,
+      output: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+    }));
+  }
+  return [];
+}
+function transformInputItems(messages, system) {
+  const result = [];
+  const normalizedSystem = normalizeSystem(system);
+  if (normalizedSystem) {
+    result.push({
+      type: "message",
+      role: "system",
+      content: normalizedSystem
+    });
+  }
+  for (const message of messages) {
+    const items = transformMessage(message);
+    result.push(...items);
+  }
+  if (result.length === 1 && result[0]?.type === "message") {
+    const item = result[0];
+    if (item.role === "user" && typeof item.content === "string") {
+      return item.content;
+    }
+  }
+  return result;
+}
+function extractToolOptions(tool) {
+  const meta = tool.metadata?.responses;
+  return { strict: meta?.strict };
+}
+function transformTool(tool) {
+  const { strict } = extractToolOptions(tool);
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: {
+      type: "object",
+      properties: tool.parameters.properties,
+      required: tool.parameters.required,
+      ...tool.parameters.additionalProperties !== void 0 ? { additionalProperties: tool.parameters.additionalProperties } : {}
+    },
+    ...strict !== void 0 ? { strict } : {}
+  };
+}
+function transformRequest(request, modelId) {
+  const params = request.params ?? {};
+  const { tools: builtInTools, ...restParams } = params;
+  const responsesRequest = {
+    ...restParams,
+    model: modelId,
+    input: transformInputItems(request.messages, request.system)
+  };
+  const functionTools = request.tools?.map(transformTool) ?? [];
+  const allTools = [
+    ...functionTools,
+    ...builtInTools ?? []
+  ];
+  if (allTools.length > 0) {
+    responsesRequest.tools = allTools;
+  }
+  if (request.structure) {
+    const schema = {
+      type: "object",
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...request.structure.additionalProperties !== void 0 ? { additionalProperties: request.structure.additionalProperties } : { additionalProperties: false }
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+    responsesRequest.text = {
+      format: {
+        type: "json_schema",
+        name: "json_response",
+        description: request.structure.description,
+        schema,
+        strict: true
+      }
+    };
+  }
+  return responsesRequest;
+}
+function transformResponse(data) {
+  const content = [];
+  const toolCalls = [];
+  const functionCallItems = [];
+  let hadRefusal = false;
+  let structuredData;
+  let reasoningEncryptedContent;
+  for (const item of data.output) {
+    if (item.type === "message") {
+      const messageItem = item;
+      for (const part of messageItem.content) {
+        if (part.type === "output_text") {
+          content.push({ type: "text", text: part.text });
+          if (structuredData === void 0) {
+            try {
+              structuredData = JSON.parse(part.text);
+            } catch {
+            }
+          }
+        } else if (part.type === "refusal") {
+          content.push({ type: "text", text: part.refusal });
+          hadRefusal = true;
+        }
+      }
+    } else if (item.type === "function_call") {
+      const functionCall = item;
+      let args = {};
+      try {
+        args = JSON.parse(functionCall.arguments);
+      } catch {
+      }
+      toolCalls.push({
+        toolCallId: functionCall.call_id,
+        toolName: functionCall.name,
+        arguments: args
+      });
+      functionCallItems.push({
+        id: functionCall.id,
+        call_id: functionCall.call_id,
+        name: functionCall.name,
+        arguments: functionCall.arguments
+      });
+    } else if (item.type === "reasoning") {
+      const reasoningItem = item;
+      const reasoningText = reasoningItem.summary.filter((s) => s.type === "summary_text").map((s) => s.text).join("");
+      if (reasoningText) {
+        content.push({ type: "reasoning", text: reasoningText });
+      }
+      reasoningEncryptedContent = JSON.stringify({
+        id: reasoningItem.id,
+        summary: reasoningItem.summary,
+        encrypted_content: reasoningItem.encrypted_content
+      });
+    }
+  }
+  const responseId = data.id || generateId();
+  const message = new AssistantMessage(
+    content,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: responseId,
+      metadata: {
+        responses: {
+          model: data.model,
+          status: data.status,
+          response_id: responseId,
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0,
+          reasoningEncryptedContent
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.total_tokens,
+    cacheReadTokens: data.usage.input_tokens_details?.cached_tokens ?? 0,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  if (data.status === "completed") {
+    stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
+  } else if (data.status === "incomplete") {
+    stopReason = data.incomplete_details?.reason === "max_output_tokens" ? "max_tokens" : "end_turn";
+  } else if (data.status === "failed") {
+    stopReason = "error";
+  }
+  if (hadRefusal && stopReason !== "error") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+function createStreamState() {
+  return {
+    id: "",
+    model: "",
+    textByIndex: /* @__PURE__ */ new Map(),
+    reasoningByIndex: /* @__PURE__ */ new Map(),
+    toolCalls: /* @__PURE__ */ new Map(),
+    status: "in_progress",
+    incompleteReason: void 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    hadRefusal: false
+  };
+}
+function transformStreamEvent(event, state) {
+  const events = [];
+  const updateFromResponse = (response) => {
+    state.id = response.id || state.id;
+    state.model = response.model || state.model;
+    state.status = response.status;
+    if (response.incomplete_details?.reason) {
+      state.incompleteReason = response.incomplete_details.reason;
+    } else if (response.status !== "incomplete") {
+      state.incompleteReason = void 0;
+    }
+    if (response.usage) {
+      state.inputTokens = response.usage.input_tokens;
+      state.outputTokens = response.usage.output_tokens;
+      state.cacheReadTokens = response.usage.input_tokens_details?.cached_tokens ?? 0;
+    }
+  };
+  switch (event.type) {
+    case "response.created":
+      updateFromResponse(event.response);
+      events.push({ type: StreamEventType.MessageStart, index: 0, delta: {} });
+      break;
+    case "response.queued":
+    case "response.in_progress":
+      updateFromResponse(event.response);
+      break;
+    case "response.completed":
+      updateFromResponse(event.response);
+      events.push({ type: StreamEventType.MessageStop, index: 0, delta: {} });
+      break;
+    case "response.failed":
+    case "response.incomplete":
+      updateFromResponse(event.response);
+      events.push({ type: StreamEventType.MessageStop, index: 0, delta: {} });
+      break;
+    case "response.output_item.added":
+      if (event.item.type === "function_call") {
+        const functionCall = event.item;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: ""
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      }
+      events.push({
+        type: StreamEventType.ContentBlockStart,
+        index: event.output_index,
+        delta: {}
+      });
+      break;
+    case "response.output_item.done":
+      if (event.item.type === "function_call") {
+        const functionCall = event.item;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: ""
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      } else if (event.item.type === "reasoning") {
+        const reasoningItem = event.item;
+        state.reasoningEncryptedContent = JSON.stringify({
+          id: reasoningItem.id,
+          summary: reasoningItem.summary,
+          encrypted_content: reasoningItem.encrypted_content
+        });
+      }
+      events.push({
+        type: StreamEventType.ContentBlockStop,
+        index: event.output_index,
+        delta: {}
+      });
+      break;
+    case "response.output_text.delta": {
+      const currentText = state.textByIndex.get(event.output_index) ?? "";
+      state.textByIndex.set(event.output_index, currentText + event.delta);
+      events.push({
+        type: StreamEventType.TextDelta,
+        index: event.output_index,
+        delta: { text: event.delta }
+      });
+      break;
+    }
+    case "response.output_text.done":
+      state.textByIndex.set(event.output_index, event.text);
+      break;
+    case "response.refusal.delta": {
+      state.hadRefusal = true;
+      const currentRefusal = state.textByIndex.get(event.output_index) ?? "";
+      state.textByIndex.set(event.output_index, currentRefusal + event.delta);
+      events.push({
+        type: StreamEventType.TextDelta,
+        index: event.output_index,
+        delta: { text: event.delta }
+      });
+      break;
+    }
+    case "response.refusal.done":
+      state.hadRefusal = true;
+      state.textByIndex.set(event.output_index, event.refusal);
+      break;
+    case "response.function_call_arguments.delta": {
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: "" };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id && !toolCall.itemId) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id && !toolCall.callId) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.arguments += event.delta;
+      events.push({
+        type: StreamEventType.ToolCallDelta,
+        index: event.output_index,
+        delta: {
+          toolCallId: toolCall.callId ?? toolCall.itemId ?? "",
+          toolName: toolCall.name,
+          argumentsJson: event.delta
+        }
+      });
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: "" };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.name = event.name;
+      toolCall.arguments = event.arguments;
+      break;
+    }
+    case "response.reasoning_summary_text.delta": {
+      const currentReasoning = state.reasoningByIndex.get(event.output_index) ?? "";
+      state.reasoningByIndex.set(event.output_index, currentReasoning + event.delta);
+      events.push({
+        type: StreamEventType.ReasoningDelta,
+        index: event.output_index,
+        delta: { text: event.delta }
+      });
+      break;
+    }
+    case "response.reasoning_summary_text.done":
+      state.reasoningByIndex.set(event.output_index, event.text);
+      break;
+    case "error":
+      break;
+    default:
+      break;
+  }
+  return events;
+}
+function buildResponseFromState(state) {
+  const content = [];
+  let structuredData;
+  const orderedReasoningEntries = [...state.reasoningByIndex.entries()].sort(
+    ([leftIndex], [rightIndex]) => leftIndex - rightIndex
+  );
+  for (const [, reasoning] of orderedReasoningEntries) {
+    if (reasoning) {
+      content.push({ type: "reasoning", text: reasoning });
+    }
+  }
+  const orderedTextEntries = [...state.textByIndex.entries()].sort(
+    ([leftIndex], [rightIndex]) => leftIndex - rightIndex
+  );
+  for (const [, text] of orderedTextEntries) {
+    if (text) {
+      content.push({ type: "text", text });
+      if (structuredData === void 0) {
+        try {
+          structuredData = JSON.parse(text);
+        } catch {
+        }
+      }
+    }
+  }
+  const toolCalls = [];
+  const functionCallItems = [];
+  const orderedToolEntries = [...state.toolCalls.entries()].sort(
+    ([leftIndex], [rightIndex]) => leftIndex - rightIndex
+  );
+  for (const [, toolCall] of orderedToolEntries) {
+    let args = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+      }
+    }
+    const itemId = toolCall.itemId ?? "";
+    const callId = toolCall.callId ?? toolCall.itemId ?? "";
+    const name = toolCall.name ?? "";
+    if (!name || !callId) {
+      continue;
+    }
+    toolCalls.push({
+      toolCallId: callId,
+      toolName: name,
+      arguments: args
+    });
+    if (itemId && callId && name) {
+      functionCallItems.push({
+        id: itemId,
+        call_id: callId,
+        name,
+        arguments: toolCall.arguments
+      });
+    }
+  }
+  const responseId = state.id || generateId();
+  const message = new AssistantMessage(
+    content,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: responseId,
+      metadata: {
+        responses: {
+          model: state.model,
+          status: state.status,
+          response_id: responseId,
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0,
+          reasoningEncryptedContent: state.reasoningEncryptedContent
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens,
+    cacheReadTokens: state.cacheReadTokens,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  if (state.status === "completed") {
+    stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
+  } else if (state.status === "incomplete") {
+    stopReason = state.incompleteReason === "max_output_tokens" ? "max_tokens" : "end_turn";
+  } else if (state.status === "failed") {
+    stopReason = "error";
+  }
+  if (state.hadRefusal && stopReason !== "error") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+
+// src/providers/responses/llm.ts
+var RESPONSES_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  documentInput: true,
+  videoInput: true,
+  audioInput: true
+};
+function extractContext(request) {
+  const config = request.config;
+  const responsesConfig = config._responsesContext;
+  if (!responsesConfig) {
+    throw new UPPError(
+      'OpenResponses provider requires host configuration. Use responses(modelId, { host: "..." })',
+      ErrorCode.InvalidRequest,
+      "responses",
+      ModalityType.LLM
+    );
+  }
+  return responsesConfig;
+}
+function createLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          ErrorCode.InvalidRequest,
+          "responses",
+          ModalityType.LLM
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: RESPONSES_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const context = extractContext(request);
+          const apiKey = await resolveApiKey(
+            request.config,
+            context.apiKeyEnv,
+            "responses",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? `${context.host}/responses`;
+          const body = transformRequest(request, modelId);
+          const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          };
+          if (request.config.headers) {
+            for (const [key, value] of Object.entries(request.config.headers)) {
+              if (value !== void 0) {
+                headers[key] = value;
+              }
+            }
+          }
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers,
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "responses",
+            "llm"
+          );
+          const data = await parseJsonResponse(response, "responses", "llm");
+          if (data.status === "failed") {
+            const message = data.error?.message ?? "Provider returned a failed response.";
+            throw new UPPError(
+              message,
+              ErrorCode.ProviderError,
+              "responses",
+              ModalityType.LLM
+            );
+          }
+          return transformResponse(data);
+        },
+        stream(request) {
+          const state = createStreamState();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const context = extractContext(request);
+              const apiKey = await resolveApiKey(
+                request.config,
+                context.apiKeyEnv,
+                "responses",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? `${context.host}/responses`;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+              const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "text/event-stream"
+              };
+              if (request.config.headers) {
+                for (const [key, value] of Object.entries(request.config.headers)) {
+                  if (value !== void 0) {
+                    headers[key] = value;
+                  }
+                }
+              }
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "responses",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "responses", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  ErrorCode.ProviderError,
+                  "responses",
+                  ModalityType.LLM
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (data === "[DONE]") {
+                  continue;
+                }
+                if (typeof data === "object" && data !== null) {
+                  const event = data;
+                  if (event.type === "error") {
+                    const errorEvent = event;
+                    const error = new UPPError(
+                      errorEvent.error.message,
+                      ErrorCode.ProviderError,
+                      "responses",
+                      ModalityType.LLM
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvents = transformStreamEvent(event, state);
+                  for (const uppEvent of uppEvents) {
+                    yield uppEvent;
+                    if (request.structure && uppEvent.type === StreamEventType.TextDelta) {
+                      yield objectDelta(uppEvent.delta.text ?? "", uppEvent.index);
+                    }
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              const err = toError(error);
+              responseReject(err);
+              throw err;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/responses/index.ts
+var responses = createProvider({
+  name: "responses",
+  version: "1.0.0",
+  handlers: {
+    llm: createLLMHandler()
+  },
+  createModelReference: (modelId, options, provider) => {
+    if (!options?.host) {
+      throw new Error(
+        'OpenResponses provider requires a host option. Usage: responses("model-id", { host: "https://api.example.com/v1" })'
+      );
+    }
+    const providerConfig = {
+      _responsesContext: {
+        host: options.host,
+        apiKeyEnv: options.apiKeyEnv ?? "OPENRESPONSES_API_KEY"
+      }
+    };
+    return {
+      modelId,
+      provider,
+      options,
+      providerConfig
+    };
+  }
+});
+export {
+  responses
+};
+//# sourceMappingURL=index.js.map