@amux.ai/adapter-openai 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1546 @@
+'use strict';
+
+var llmBridge = require('@amux.ai/llm-bridge');
+
+// src/inbound/error-parser.ts
+function parseError(error) {
+  return llmBridge.parseOpenAICompatibleError(error);
+}
+
+// src/inbound/request-parser.ts
+function parseRequest(request) {
+  const req = request;
+  let system;
+  const messages = [];
+  for (const msg of req.messages) {
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        system = system ? `${system}
+${msg.content}` : msg.content;
+      }
+    } else {
+      messages.push(parseMessage(msg));
+    }
+  }
+  const tools = req.tools?.map((tool) => parseTool(tool));
+  const toolChoice = req.tool_choice ? parseToolChoice(req.tool_choice) : void 0;
+  return {
+    messages,
+    model: req.model,
+    tools,
+    toolChoice,
+    stream: req.stream,
+    system,
+    generation: {
+      temperature: req.temperature,
+      topP: req.top_p,
+      maxTokens: req.max_tokens ?? req.max_completion_tokens,
+      stopSequences: req.stop ? Array.isArray(req.stop) ? req.stop : [req.stop] : void 0,
+      presencePenalty: req.presence_penalty,
+      frequencyPenalty: req.frequency_penalty,
+      n: req.n,
+      seed: req.seed,
+      responseFormat: req.response_format ? {
+        type: req.response_format.type,
+        jsonSchema: req.response_format.json_schema
+      } : void 0,
+      logprobs: req.logprobs,
+      topLogprobs: req.top_logprobs
+    },
+    metadata: {
+      userId: req.user
+    },
+    raw: request
+  };
+}
+function parseMessage(msg) {
+  return {
+    role: msg.role,
+    content: parseContent(msg.content),
+    name: msg.name,
+    toolCalls: msg.tool_calls,
+    toolCallId: msg.tool_call_id
+  };
+}
+function parseContent(content) {
+  if (content === null || content === void 0) {
+    return "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        text: part.text
+      };
+    }
+    if (part.type === "image_url") {
+      const url = part.image_url.url;
+      if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: "image",
+            source: {
+              type: "base64",
+              mediaType: match[1],
+              data: match[2]
+            }
+          };
+        }
+      }
+      return {
+        type: "image",
+        source: {
+          type: "url",
+          url
+        }
+      };
+    }
+    return {
+      type: "text",
+      text: JSON.stringify(part)
+    };
+  });
+}
+function parseTool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters,
+      strict: tool.function.strict
+    }
+  };
+}
+function parseToolChoice(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.function.name
+    }
+  };
+}
+function parseResponse(response) {
+  const res = response;
+  const choices = res.choices.map((choice) => ({
+    index: choice.index,
+    message: {
+      role: choice.message.role,
+      content: choice.message.content ?? "",
+      toolCalls: choice.message.tool_calls
+    },
+    finishReason: llmBridge.mapFinishReason(choice.finish_reason),
+    logprobs: choice.logprobs
+  }));
+  return {
+    id: res.id,
+    model: res.model,
+    choices,
+    created: res.created,
+    systemFingerprint: res.system_fingerprint,
+    usage: llmBridge.parseOpenAIUsage(res.usage),
+    raw: response
+  };
+}
+
+// src/inbound/stream-parser.ts
+function mapFinishReason2(reason) {
+  const reasonMap = {
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_calls",
+    content_filter: "content_filter",
+    function_call: "tool_calls"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+function parseStream(chunk) {
+  const data = chunk;
+  if (!data.choices || data.choices.length === 0) {
+    if (data.usage) {
+      return {
+        type: "end",
+        id: data.id,
+        model: data.model,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens,
+          details: data.usage.completion_tokens_details ? {
+            reasoningTokens: data.usage.completion_tokens_details.reasoning_tokens
+          } : void 0
+        },
+        raw: chunk
+      };
+    }
+    return null;
+  }
+  const choice = data.choices[0];
+  if (!choice) {
+    return null;
+  }
+  const delta = choice.delta;
+  if (delta.role && !delta.content && !delta.tool_calls) {
+    return {
+      type: "start",
+      id: data.id,
+      model: data.model,
+      raw: chunk
+    };
+  }
+  if (delta.content) {
+    return {
+      type: "content",
+      id: data.id,
+      model: data.model,
+      content: {
+        type: "content",
+        delta: delta.content,
+        index: choice.index
+      },
+      raw: chunk
+    };
+  }
+  if (delta.tool_calls && delta.tool_calls.length > 0) {
+    const toolCall = delta.tool_calls[0];
+    if (toolCall) {
+      return {
+        type: "tool_call",
+        id: data.id,
+        model: data.model,
+        toolCall: {
+          type: "tool_call",
+          id: toolCall.id,
+          name: toolCall.function?.name,
+          arguments: toolCall.function?.arguments,
+          index: toolCall.index
+        },
+        raw: chunk
+      };
+    }
+  }
+  if (choice.finish_reason) {
+    return {
+      type: "end",
+      id: data.id,
+      model: data.model,
+      finishReason: mapFinishReason2(choice.finish_reason),
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens,
+        details: data.usage.completion_tokens_details ? {
+          reasoningTokens: data.usage.completion_tokens_details.reasoning_tokens
+        } : void 0
+      } : void 0,
+      raw: chunk
+    };
+  }
+  return null;
+}
+
+// src/outbound/request-builder.ts
+function buildRequest(ir) {
+  const messages = [];
+  if (ir.system) {
+    messages.push({
+      role: "system",
+      content: ir.system
+    });
+  }
+  for (const msg of ir.messages) {
+    messages.push({
+      role: msg.role,
+      content: buildContent(msg.content),
+      name: msg.name,
+      tool_calls: msg.toolCalls,
+      tool_call_id: msg.toolCallId
+    });
+  }
+  const request = {
+    model: ir.model ?? "gpt-4",
+    messages,
+    stream: ir.stream
+  };
+  if (ir.tools && ir.tools.length > 0) {
+    request.tools = ir.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+        strict: tool.function.strict
+      }
+    }));
+  }
+  if (ir.toolChoice) {
+    request.tool_choice = ir.toolChoice;
+  }
+  if (ir.generation) {
+    if (ir.generation.temperature !== void 0) {
+      request.temperature = ir.generation.temperature;
+    }
+    if (ir.generation.topP !== void 0) {
+      request.top_p = ir.generation.topP;
+    }
+    if (ir.generation.maxTokens !== void 0) {
+      request.max_tokens = ir.generation.maxTokens;
+    }
+    if (ir.generation.stopSequences && ir.generation.stopSequences.length > 0) {
+      request.stop = ir.generation.stopSequences;
+    }
+    if (ir.generation.presencePenalty !== void 0) {
+      request.presence_penalty = ir.generation.presencePenalty;
+    }
+    if (ir.generation.frequencyPenalty !== void 0) {
+      request.frequency_penalty = ir.generation.frequencyPenalty;
+    }
+    if (ir.generation.n !== void 0) {
+      request.n = ir.generation.n;
+    }
+    if (ir.generation.seed !== void 0) {
+      request.seed = ir.generation.seed;
+    }
+    if (ir.generation.responseFormat) {
+      request.response_format = {
+        type: ir.generation.responseFormat.type,
+        json_schema: ir.generation.responseFormat.jsonSchema
+      };
+    }
+    if (ir.generation.logprobs !== void 0) {
+      request.logprobs = ir.generation.logprobs;
+    }
+    if (ir.generation.topLogprobs !== void 0) {
+      request.top_logprobs = ir.generation.topLogprobs;
+    }
+  }
+  if (ir.metadata?.userId) {
+    request.user = ir.metadata.userId;
+  }
+  if (ir.stream) {
+    request.stream_options = { include_usage: true };
+  }
+  return request;
+}
+function buildContent(content) {
+  if (typeof content === "string") {
+    return content || null;
+  }
+  if (!content || content.length === 0) {
+    return null;
+  }
+  const allText = content.every((part) => part.type === "text");
+  if (allText) {
+    return content.map((part) => part.type === "text" ? part.text : "").join("");
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return { type: "text", text: part.text };
+    }
+    if (part.type === "image") {
+      const imgPart = part;
+      if (imgPart.source.type === "url") {
+        return {
+          type: "image_url",
+          image_url: { url: imgPart.source.url }
+        };
+      }
+      return {
+        type: "image_url",
+        image_url: {
+          url: `data:${imgPart.source.mediaType};base64,${imgPart.source.data}`
+        }
+      };
+    }
+    return { type: "text", text: JSON.stringify(part) };
+  });
+}
+function buildResponse(ir) {
+  return {
+    id: ir.id,
+    object: "chat.completion",
+    created: ir.created ?? Math.floor(Date.now() / 1e3),
+    model: ir.model,
+    system_fingerprint: ir.systemFingerprint,
+    choices: ir.choices.map((choice) => ({
+      index: choice.index,
+      message: {
+        role: choice.message.role,
+        content: llmBridge.contentToString(choice.message.content),
+        tool_calls: choice.message.toolCalls
+      },
+      finish_reason: choice.finishReason ?? "stop",
+      logprobs: choice.logprobs
+    })),
+    usage: ir.usage ? {
+      prompt_tokens: ir.usage.promptTokens,
+      completion_tokens: ir.usage.completionTokens,
+      total_tokens: ir.usage.totalTokens,
+      completion_tokens_details: ir.usage.details?.reasoningTokens ? {
+        reasoning_tokens: ir.usage.details.reasoningTokens
+      } : void 0
+    } : void 0
+  };
+}
+
+// src/outbound/stream-builder.ts
+function createStreamBuilder() {
+  let chunkId = `chatcmpl-${Date.now()}`;
+  let model = "";
+  const created = Math.floor(Date.now() / 1e3);
+  const toolCallsState = /* @__PURE__ */ new Map();
+  return {
+    process(event) {
+      const events = [];
+      if (event.id) chunkId = event.id;
+      if (event.model) model = event.model;
+      if (event.type === "start") {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { role: "assistant", content: "" },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "content" && event.content?.delta) {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { content: event.content.delta },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "reasoning" && event.reasoning?.delta) {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { content: event.reasoning.delta },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "tool_call" && event.toolCall) {
+        const toolIndex = event.toolCall.index ?? 0;
+        const toolCallDelta = { index: toolIndex };
+        if (event.toolCall.name) {
+          toolCallDelta.id = event.toolCall.id || `call_${Date.now()}_${toolIndex}`;
+          toolCallDelta.type = "function";
+          toolCallDelta.function = { name: event.toolCall.name };
+          toolCallsState.set(toolIndex, {
+            id: toolCallDelta.id,
+            name: event.toolCall.name
+          });
+        }
+        if (event.toolCall.arguments) {
+          toolCallDelta.function = {
+            ...toolCallDelta.function,
+            arguments: event.toolCall.arguments
+          };
+        }
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { tool_calls: [toolCallDelta] },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "end") {
+        const finishReason = mapFinishReason3(event.finishReason);
+        const finalChunk = {
+          id: chunkId,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{
+            index: 0,
+            delta: {},
+            finish_reason: finishReason
+          }]
+        };
+        if (event.usage) {
+          finalChunk.usage = {
+            prompt_tokens: event.usage.promptTokens ?? 0,
+            completion_tokens: event.usage.completionTokens ?? 0,
+            total_tokens: event.usage.totalTokens ?? 0
+          };
+        }
+        events.push({ event: "data", data: finalChunk });
+      }
+      if (event.type === "error" && event.error) {
+        events.push({
+          event: "data",
+          data: {
+            error: {
+              message: event.error.message,
+              type: "server_error",
+              code: event.error.code
+            }
+          }
+        });
+      }
+      return events;
+    },
+    finalize() {
+      return [{ event: "data", data: "[DONE]" }];
+    }
+  };
+}
+function mapFinishReason3(reason) {
+  if (!reason) return "stop";
+  const reasonMap = {
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_calls",
+    content_filter: "content_filter",
+    end_turn: "stop",
+    max_tokens: "length"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+
+// src/adapter.ts
+var openaiAdapter = {
+  name: "openai",
+  version: "1.0.0",
+  capabilities: {
+    streaming: true,
+    tools: true,
+    vision: true,
+    multimodal: true,
+    systemPrompt: true,
+    toolChoice: true,
+    reasoning: false,
+    webSearch: false,
+    jsonMode: true,
+    logprobs: true,
+    seed: true
+  },
+  inbound: {
+    parseRequest: (request) => {
+      return parseRequest(request);
+    },
+    parseResponse: (response) => {
+      return parseResponse(response);
+    },
+    parseStream: (chunk) => {
+      return parseStream(chunk);
+    },
+    parseError: (error) => {
+      return parseError(error);
+    }
+  },
+  outbound: {
+    buildRequest: (ir) => {
+      return buildRequest(ir);
+    },
+    buildResponse: (ir) => {
+      return buildResponse(ir);
+    },
+    createStreamBuilder
+  },
+  getInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      capabilities: this.capabilities,
+      endpoint: {
+        baseUrl: "https://api.openai.com",
+        chatPath: "/v1/chat/completions",
+        modelsPath: "/v1/models"
+      }
+    };
+  }
+};
+
+// src/responses/request-parser.ts
+function parseResponsesRequest(request) {
+  const req = request;
+  let system = req.instructions;
+  const { messages, developerSystem } = parseInput(req.input);
+  if (developerSystem) {
+    system = system ? `${system}
+${developerSystem}` : developerSystem;
+  }
+  const tools = req.tools?.filter((tool) => tool.type === "function").map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+      strict: tool.strict
+    }
+  }));
+  const toolChoice = req.tool_choice ? parseToolChoice2(req.tool_choice) : void 0;
+  let responseFormat;
+  if (req.text?.format) {
+    if (req.text.format.type === "json_object") {
+      responseFormat = { type: "json_object" };
+    } else if (req.text.format.type === "json_schema" && req.text.format.json_schema) {
+      responseFormat = {
+        type: "json_schema",
+        jsonSchema: {
+          name: req.text.format.json_schema.name,
+          description: req.text.format.json_schema.description,
+          schema: req.text.format.json_schema.schema,
+          strict: req.text.format.json_schema.strict
+        }
+      };
+    }
+  }
+  const generation = {
+    temperature: req.temperature,
+    topP: req.top_p,
+    maxTokens: req.max_output_tokens,
+    responseFormat
+  };
+  return {
+    messages,
+    model: req.model,
+    tools: tools && tools.length > 0 ? tools : void 0,
+    toolChoice,
+    stream: req.stream,
+    system,
+    generation,
+    metadata: {
+      userId: req.user,
+      ...req.metadata || {}
+    },
+    extensions: {
+      responses: {
+        truncation: req.truncation,
+        store: req.store,
+        reasoning: req.reasoning,
+        previousResponseId: req.previous_response_id,
+        parallelToolCalls: req.parallel_tool_calls,
+        text: req.text,
+        // Track built-in tools for outbound
+        builtInTools: req.tools?.filter((t) => t.type !== "function")
+      }
+    },
+    raw: request
+  };
+}
+function parseInput(input) {
+  if (typeof input === "string") {
+    return {
+      messages: [
+        {
+          role: "user",
+          content: input
+        }
+      ]
+    };
+  }
+  const messages = [];
+  let developerSystem;
+  for (const item of input) {
+    if (item.type === "item_reference") {
+      continue;
+    }
+    const role = item.role;
+    const content = item.content;
+    if (role === "system" || role === "developer") {
+      if (typeof content === "string") {
+        developerSystem = developerSystem ? `${developerSystem}
+${content}` : content;
+      } else {
+        const text = content.filter((p) => p.type === "input_text").map((p) => p.text).join("");
+        developerSystem = developerSystem ? `${developerSystem}
+${text}` : text;
+      }
+      continue;
+    }
+    messages.push({
+      role,
+      content: parseContent2(content)
+    });
+  }
+  return { messages, developerSystem };
+}
+function parseContent2(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if (part.type === "input_text") {
+      return {
+        type: "text",
+        text: part.text
+      };
+    }
+    if (part.type === "input_image") {
+      if (part.image_url.startsWith("data:")) {
+        const match = part.image_url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: "image",
+            source: {
+              type: "base64",
+              mediaType: match[1],
+              data: match[2]
+            }
+          };
+        }
+      }
+      return {
+        type: "image",
+        source: {
+          type: "url",
+          url: part.image_url
+        }
+      };
+    }
+    if (part.type === "input_file") {
+      return {
+        type: "text",
+        text: `[File: ${part.file_id}]`
+      };
+    }
+    return {
+      type: "text",
+      text: JSON.stringify(part)
+    };
+  });
+}
+function parseToolChoice2(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.name
+    }
+  };
+}
+
+// src/responses/response-parser.ts
+function mapFinishReason4(status) {
+  const statusMap = {
+    completed: "stop",
+    failed: "stop",
+    incomplete: "length",
+    in_progress: "stop"
+  };
+  return statusMap[status] ?? "stop";
+}
+function parseResponsesResponse(response) {
+  const res = response;
+  const { content, toolCalls, reasoning } = extractOutputContent(res.output, res.output_text);
+  const choices = [
+    {
+      index: 0,
+      message: {
+        role: "assistant",
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+        reasoningContent: reasoning || void 0
+      },
+      finishReason: mapFinishReason4(res.status)
+    }
+  ];
+  return {
+    id: res.id,
+    model: res.model,
+    choices,
+    created: res.created_at,
+    usage: res.usage ? {
+      promptTokens: res.usage.input_tokens,
+      completionTokens: res.usage.output_tokens,
+      totalTokens: res.usage.total_tokens,
+      details: {
+        ...res.usage.output_tokens_details?.reasoning_tokens ? { reasoningTokens: res.usage.output_tokens_details.reasoning_tokens } : {},
+        ...res.usage.input_tokens_details?.cached_tokens ? { cachedTokens: res.usage.input_tokens_details.cached_tokens } : {}
+      }
+    } : void 0,
+    raw: response
+  };
+}
+function extractOutputContent(output, outputText) {
+  let content = "";
+  const toolCalls = [];
+  let reasoning = null;
+  if (outputText && (!output || output.length === 0)) {
+    return { content: outputText, toolCalls: [], reasoning: null };
+  }
+  for (const item of output) {
+    if (item.type === "message") {
+      for (const part of item.content) {
+        if (part.type === "output_text") {
+          content += part.text;
+        } else if (part.type === "refusal") {
+          content += `[Refusal: ${part.refusal}]`;
+        }
+      }
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        id: item.call_id,
+        type: "function",
+        function: {
+          name: item.name,
+          arguments: item.arguments
+        }
+      });
+    } else if (item.type === "reasoning") {
+      const reasoningItem = item;
+      if (reasoningItem.summary && reasoningItem.summary.length > 0) {
+        reasoning = reasoningItem.summary.filter((s) => s.type === "summary_text").map((s) => s.text).join("");
+      } else if (reasoningItem.content && reasoningItem.content.length > 0) {
+        reasoning = reasoningItem.content.filter((c) => c.type === "reasoning_text").map((c) => c.text).join("");
+      }
+    }
+  }
+  if (!content && outputText) {
+    content = outputText;
+  }
+  return { content, toolCalls, reasoning };
+}
+
+// src/responses/stream-parser.ts
+function mapFinishReason5(status) {
+  const statusMap = {
+    completed: "stop",
+    failed: "stop",
+    incomplete: "length"
+  };
+  return statusMap[status] ?? "stop";
+}
+function parseResponsesStream(chunk) {
+  const event = chunk;
+  switch (event.type) {
+    case "response.created":
+    case "response.in_progress":
+      return {
+        type: "start",
+        id: event.response?.id ?? "",
+        model: event.response?.model ?? "",
+        raw: chunk
+      };
+    case "response.output_text.delta":
+      return {
+        type: "content",
+        id: "",
+        model: "",
+        content: {
+          type: "content",
+          delta: event.delta ?? "",
+          index: event.output_index ?? 0
+        },
+        raw: chunk
+      };
+    case "response.reasoning_summary_text.delta":
+      return {
+        type: "reasoning",
+        id: "",
+        model: "",
+        reasoning: {
+          type: "reasoning",
+          delta: event.delta ?? ""
+        },
+        raw: chunk
+      };
+    case "response.function_call_arguments.delta":
+      return {
+        type: "tool_call",
+        id: "",
+        model: "",
+        toolCall: {
+          type: "tool_call",
+          arguments: event.delta,
+          index: event.output_index ?? 0
+        },
+        raw: chunk
+      };
+    case "response.output_item.added":
+      if (event.item?.type === "function_call") {
+        return {
+          type: "tool_call",
+          id: "",
+          model: "",
+          toolCall: {
+            type: "tool_call",
+            id: event.item.call_id,
+            name: event.item.name,
+            index: event.output_index ?? 0
+          },
+          raw: chunk
+        };
+      }
+      return null;
+    case "response.completed":
+    case "response.failed":
+    case "response.incomplete":
+      return {
+        type: "end",
+        id: event.response?.id ?? "",
+        model: event.response?.model ?? "",
+        finishReason: mapFinishReason5(event.response?.status ?? "completed"),
+        usage: event.response?.usage ? {
+          promptTokens: event.response.usage.input_tokens,
+          completionTokens: event.response.usage.output_tokens,
+          totalTokens: event.response.usage.total_tokens,
+          details: event.response.usage.output_tokens_details?.reasoning_tokens ? {
+            reasoningTokens: event.response.usage.output_tokens_details.reasoning_tokens
+          } : void 0
+        } : void 0,
+        raw: chunk
+      };
+    case "error":
+      return {
+        type: "error",
+        id: "",
+        model: "",
+        error: {
+          type: "api",
+          message: event.error?.message ?? "Unknown error",
+          code: event.error?.code
+        },
+        raw: chunk
+      };
+    default:
+      return null;
+  }
+}
+
+// src/responses/request-builder.ts
+function buildResponsesRequest(ir) {
+  const input = [];
+  for (const msg of ir.messages) {
+    if (msg.role === "system") {
+      continue;
+    }
+    input.push({
+      type: "message",
+      role: msg.role,
+      content: buildContent2(msg.content)
+    });
+  }
+  const request = {
+    model: ir.model ?? "gpt-5",
+    input: input.length === 1 && input[0]?.type === "message" && typeof input[0].content === "string" && input[0].role === "user" ? input[0].content : input,
+    stream: ir.stream
+  };
+  if (ir.system) {
+    request.instructions = ir.system;
+  }
+  const tools = [];
+  if (ir.tools && ir.tools.length > 0) {
+    for (const tool of ir.tools) {
+      tools.push({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+        strict: tool.function.strict
+      });
+    }
+  }
+  const responsesExt = ir.extensions?.responses;
+  const builtInTools = responsesExt?.builtInTools;
+  if (builtInTools) {
+    tools.push(...builtInTools);
+  }
+  if (tools.length > 0) {
+    request.tools = tools;
+  }
+  if (ir.toolChoice) {
+    if (typeof ir.toolChoice === "string") {
+      request.tool_choice = ir.toolChoice;
+    } else if (ir.toolChoice.type === "function" && ir.toolChoice.function) {
+      request.tool_choice = {
+        type: "function",
+        name: ir.toolChoice.function.name
+      };
+    }
+  }
+  if (ir.generation) {
+    if (ir.generation.temperature !== void 0) {
+      request.temperature = ir.generation.temperature;
+    }
+    if (ir.generation.topP !== void 0) {
+      request.top_p = ir.generation.topP;
+    }
+    if (ir.generation.maxTokens !== void 0) {
+      request.max_output_tokens = ir.generation.maxTokens;
+    }
+  }
+  if (ir.metadata?.userId) {
+    request.user = ir.metadata.userId;
+  }
+  if (responsesExt) {
+    if (responsesExt.truncation !== void 0) {
+      request.truncation = responsesExt.truncation;
+    }
+    if (responsesExt.store !== void 0) {
+      request.store = responsesExt.store;
+    }
+    if (responsesExt.reasoning !== void 0) {
+      request.reasoning = responsesExt.reasoning;
+    }
+    if (responsesExt.previousResponseId !== void 0) {
+      request.previous_response_id = responsesExt.previousResponseId;
+    }
+    if (responsesExt.parallelToolCalls !== void 0) {
+      request.parallel_tool_calls = responsesExt.parallelToolCalls;
+    }
+    if (responsesExt.text !== void 0) {
+      request.text = responsesExt.text;
+    }
+  }
+  if (ir.generation?.responseFormat) {
+    if (ir.generation.responseFormat.type === "json_object") {
+      request.text = {
+        format: { type: "json_object" }
+      };
+    } else if (ir.generation.responseFormat.type === "json_schema" && ir.generation.responseFormat.jsonSchema) {
+      request.text = {
+        format: {
+          type: "json_schema",
+          json_schema: {
+            name: ir.generation.responseFormat.jsonSchema.name,
+            description: ir.generation.responseFormat.jsonSchema.description,
+            schema: ir.generation.responseFormat.jsonSchema.schema,
+            strict: ir.generation.responseFormat.jsonSchema.strict
+          }
+        }
+      };
+    }
+  }
+  return request;
+}
+function buildContent2(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!content || content.length === 0) {
+    return "";
+  }
+  const allText = content.every((part) => part.type === "text");
+  if (allText) {
+    return content.map((part) => part.type === "text" ? part.text : "").join("");
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return { type: "input_text", text: part.text };
+    }
+    if (part.type === "image") {
+      const imgPart = part;
+      if (imgPart.source.type === "url") {
+        return {
+          type: "input_image",
+          image_url: imgPart.source.url
+        };
+      }
+      return {
+        type: "input_image",
+        image_url: `data:${imgPart.source.mediaType};base64,${imgPart.source.data}`
+      };
+    }
+    return { type: "input_text", text: JSON.stringify(part) };
+  });
+}
+
+// src/responses/response-builder.ts
+function contentToOutput(content) {
+  if (typeof content === "string") {
+    return content ? [{ type: "output_text", text: content }] : [];
+  }
+  if (!content || content.length === 0) {
+    return [];
+  }
+  const text = content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "").join("");
+  return text ? [{ type: "output_text", text }] : [];
+}
+function buildResponsesResponse(ir) {
+  const output = [];
+  const choice = ir.choices[0];
+  if (choice) {
+    const messageContent = contentToOutput(choice.message.content);
+    if (messageContent.length > 0) {
+      output.push({
+        type: "message",
+        id: `msg_${ir.id}`,
+        role: "assistant",
+        content: messageContent,
+        status: "completed"
+      });
+    }
+    if (choice.message.toolCalls) {
+      for (const toolCall of choice.message.toolCalls) {
+        output.push({
+          type: "function_call",
+          id: `fc_${toolCall.id}`,
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: toolCall.function.arguments,
+          status: "completed"
+        });
+      }
+    }
+    if (choice.message.reasoningContent) {
+      output.unshift({
+        type: "reasoning",
+        id: `rs_${ir.id}`,
+        content: [{ type: "reasoning_text", text: choice.message.reasoningContent }]
+      });
+    }
+  }
+  return {
+    id: ir.id,
+    object: "response",
+    created_at: ir.created ?? Math.floor(Date.now() / 1e3),
+    model: ir.model,
+    status: "completed",
+    output,
+    usage: ir.usage ? {
+      input_tokens: ir.usage.promptTokens,
+      output_tokens: ir.usage.completionTokens,
+      total_tokens: ir.usage.totalTokens,
+      output_tokens_details: ir.usage.details?.reasoningTokens ? {
+        reasoning_tokens: ir.usage.details.reasoningTokens
+      } : void 0
+    } : void 0
+  };
+}
+
+// src/responses/stream-builder.ts
+function createResponsesStreamBuilder() {
+  let responseId = "";
+  let model = "";
+  let currentOutputIndex = -1;
+  let reasoningItemAdded = false;
+  let reasoningPartAdded = false;
+  let messageItemAdded = false;
+  let contentPartAdded = false;
+  let accumulatedText = "";
+  let accumulatedReasoning = "";
+  let sequenceNumber = 0;
+  let reasoningItemId = "";
+  let messageItemId = "";
+  function nextSeq() {
+    return sequenceNumber++;
+  }
+  function ensureReasoningItemAdded(events) {
+    if (!reasoningItemAdded) {
+      reasoningItemAdded = true;
+      currentOutputIndex++;
+      reasoningItemId = `rs_${responseId || Date.now()}`;
+      events.push({
+        event: "response.output_item.added",
+        data: {
+          type: "response.output_item.added",
+          output_index: currentOutputIndex,
+          item_id: reasoningItemId,
+          sequence_number: nextSeq(),
+          item: {
+            type: "reasoning",
+            id: reasoningItemId,
+            summary: [],
+            status: "in_progress"
+          }
+        }
+      });
+    }
+  }
+  function ensureReasoningPartAdded(events) {
+    if (!reasoningPartAdded) {
+      reasoningPartAdded = true;
+      events.push({
+        event: "response.reasoning_summary_part.added",
+        data: {
+          type: "response.reasoning_summary_part.added",
+          item_id: reasoningItemId,
+          output_index: currentOutputIndex,
+          summary_index: 0,
+          sequence_number: nextSeq(),
+          part: {
+            type: "summary_text",
+            text: ""
+          }
+        }
+      });
+    }
+  }
+  function ensureMessageItemAdded(events) {
+    if (!messageItemAdded) {
+      messageItemAdded = true;
+      currentOutputIndex++;
+      messageItemId = `msg_${responseId || Date.now()}`;
+      events.push({
+        event: "response.output_item.added",
+        data: {
+          type: "response.output_item.added",
+          output_index: currentOutputIndex,
+          item_id: messageItemId,
+          sequence_number: nextSeq(),
+          item: {
+            type: "message",
+            id: messageItemId,
+            role: "assistant",
+            content: [],
+            status: "in_progress"
+          }
+        }
+      });
+    }
+  }
+  function ensureContentPartAdded(events) {
+    if (!contentPartAdded) {
+      contentPartAdded = true;
+      events.push({
+        event: "response.content_part.added",
+        data: {
+          type: "response.content_part.added",
+          output_index: currentOutputIndex,
+          item_id: messageItemId,
+          content_index: 0,
+          sequence_number: nextSeq(),
+          part: {
+            type: "output_text",
+            text: ""
+          }
+        }
+      });
+    }
+  }
+  return {
+    process(event) {
+      const events = [];
+      if (event.id) responseId = event.id || `resp_${Date.now()}`;
+      if (event.model) model = event.model || "";
+      if (event.type === "start") {
+        events.push({
+          event: "response.created",
+          data: {
+            type: "response.created",
+            sequence_number: nextSeq(),
+            response: {
+              id: responseId,
+              object: "response",
+              created_at: Math.floor(Date.now() / 1e3),
+              model,
+              status: "in_progress",
+              output: []
+            }
+          }
+        });
+      }
+      if (event.type === "reasoning" && event.reasoning?.delta) {
+        ensureReasoningItemAdded(events);
+        ensureReasoningPartAdded(events);
+        accumulatedReasoning += event.reasoning.delta;
+        events.push({
+          event: "response.reasoning_summary_text.delta",
+          data: {
+            type: "response.reasoning_summary_text.delta",
+            item_id: reasoningItemId,
+            output_index: 0,
+            // Reasoning is always at output_index 0
+            summary_index: 0,
+            sequence_number: nextSeq(),
+            delta: event.reasoning.delta
+          }
+        });
+      }
+      if (event.type === "content" && event.content?.delta) {
+        ensureMessageItemAdded(events);
+        ensureContentPartAdded(events);
+        accumulatedText += event.content.delta;
+        events.push({
+          event: "response.output_text.delta",
+          data: {
+            type: "response.output_text.delta",
+            output_index: currentOutputIndex,
+            item_id: messageItemId,
+            content_index: 0,
+            sequence_number: nextSeq(),
+            delta: event.content.delta
+          }
+        });
+      }
+      if (event.type === "tool_call" && event.toolCall) {
+        if (event.toolCall.name) {
+          currentOutputIndex++;
+          const toolItemId = `fc_${event.toolCall.id || currentOutputIndex}`;
+          events.push({
+            event: "response.output_item.added",
+            data: {
+              type: "response.output_item.added",
+              output_index: currentOutputIndex,
+              item_id: toolItemId,
+              sequence_number: nextSeq(),
+              item: {
+                type: "function_call",
+                id: toolItemId,
+                call_id: event.toolCall.id || `call_${currentOutputIndex}`,
+                name: event.toolCall.name,
+                arguments: "",
+                status: "in_progress"
+              }
+            }
+          });
+        }
+        if (event.toolCall.arguments) {
+          events.push({
+            event: "response.function_call_arguments.delta",
+            data: {
+              type: "response.function_call_arguments.delta",
+              output_index: currentOutputIndex,
+              item_id: messageItemId,
+              sequence_number: nextSeq(),
+              delta: event.toolCall.arguments
+            }
+          });
+        }
+      }
+      if (event.type === "end") {
+        const output = [];
+        if (reasoningItemAdded) {
+          output.push({
+            type: "reasoning",
+            id: reasoningItemId,
+            summary: accumulatedReasoning ? [{ type: "summary_text", text: accumulatedReasoning }] : [],
+            status: "completed"
+          });
+          events.push({
+            event: "response.reasoning_summary_text.done",
+            data: {
+              type: "response.reasoning_summary_text.done",
+              item_id: reasoningItemId,
+              output_index: 0,
+              summary_index: 0,
+              sequence_number: nextSeq(),
+              text: accumulatedReasoning
+            }
+          });
+          events.push({
+            event: "response.reasoning_summary_part.done",
+            data: {
+              type: "response.reasoning_summary_part.done",
+              item_id: reasoningItemId,
+              output_index: 0,
+              summary_index: 0,
+              sequence_number: nextSeq(),
+              part: {
+                type: "summary_text",
+                text: accumulatedReasoning
+              }
+            }
+          });
+          events.push({
+            event: "response.output_item.done",
+            data: {
+              type: "response.output_item.done",
+              output_index: 0,
+              item_id: reasoningItemId,
+              sequence_number: nextSeq(),
+              item: {
+                type: "reasoning",
+                id: reasoningItemId,
+                summary: [{ type: "summary_text", text: accumulatedReasoning }],
+                status: "completed"
+              }
+            }
+          });
+        }
+        if (messageItemAdded) {
+          const messageOutputIndex = reasoningItemAdded ? 1 : 0;
+          output.push({
+            type: "message",
+            id: messageItemId,
+            role: "assistant",
+            content: accumulatedText ? [{ type: "output_text", text: accumulatedText }] : [],
+            status: "completed"
+          });
+          if (contentPartAdded) {
+            events.push({
+              event: "response.output_text.done",
+              data: {
+                type: "response.output_text.done",
+                output_index: messageOutputIndex,
+                item_id: messageItemId,
+                content_index: 0,
+                sequence_number: nextSeq(),
+                text: accumulatedText
+              }
+            });
+            events.push({
+              event: "response.content_part.done",
+              data: {
+                type: "response.content_part.done",
+                output_index: messageOutputIndex,
+                item_id: messageItemId,
+                content_index: 0,
+                sequence_number: nextSeq(),
+                part: {
+                  type: "output_text",
+                  text: accumulatedText
+                }
+              }
+            });
+          }
+          events.push({
+            event: "response.output_item.done",
+            data: {
+              type: "response.output_item.done",
+              output_index: messageOutputIndex,
+              item_id: messageItemId,
+              sequence_number: nextSeq(),
+              item: {
+                type: "message",
+                id: messageItemId,
+                role: "assistant",
+                content: accumulatedText ? [{ type: "output_text", text: accumulatedText }] : [],
+                status: "completed"
+              }
+            }
+          });
+        }
+        events.push({
+          event: "response.completed",
+          data: {
+            type: "response.completed",
+            sequence_number: nextSeq(),
+            response: {
+              id: responseId,
+              object: "response",
+              created_at: Math.floor(Date.now() / 1e3),
+              model,
+              status: "completed",
+              output,
+              output_text: accumulatedText || void 0,
+              usage: event.usage ? {
+                input_tokens: event.usage.promptTokens,
+                output_tokens: event.usage.completionTokens,
+                total_tokens: event.usage.totalTokens,
+                output_tokens_details: event.usage.details?.reasoningTokens ? {
+                  reasoning_tokens: event.usage.details.reasoningTokens
+                } : void 0
+              } : void 0
+            }
+          }
+        });
+      }
+      if (event.type === "error" && event.error) {
+        events.push({
+          event: "error",
+          data: {
+            type: "error",
+            sequence_number: nextSeq(),
+            error: {
+              type: "api_error",
+              code: event.error.code || "unknown",
+              message: event.error.message
+            }
+          }
+        });
+      }
+      return events;
+    },
+    finalize() {
+      return [];
+    }
+  };
+}
+
+// src/responses-adapter.ts
+var openaiResponsesAdapter = {
+  name: "openai-responses",
+  version: "1.0.0",
+  capabilities: {
+    streaming: true,
+    tools: true,
+    vision: true,
+    multimodal: true,
+    systemPrompt: true,
+    toolChoice: true,
+    reasoning: true,
+    // Responses API supports reasoning models (o3, o4-mini)
+    webSearch: true,
+    // Built-in web search tool
+    jsonMode: true,
+    // Supported via text.format
+    logprobs: false,
+    // Not supported in Responses API
+    seed: false
+    // Not supported in Responses API
+  },
+  inbound: {
+    parseRequest: (request) => {
+      return parseResponsesRequest(request);
+    },
+    parseResponse: (response) => {
+      return parseResponsesResponse(response);
+    },
+    parseStream: (chunk) => {
+      return parseResponsesStream(chunk);
+    },
+    parseError: (error) => {
+      return parseError(error);
+    }
+  },
+  outbound: {
+    buildRequest: (ir) => {
+      return buildResponsesRequest(ir);
+    },
+    buildResponse: (ir) => {
+      return buildResponsesResponse(ir);
+    },
+    createStreamBuilder: createResponsesStreamBuilder
+  },
+  getInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      capabilities: this.capabilities,
+      endpoint: {
+        baseUrl: "https://api.openai.com",
+        chatPath: "/v1/responses",
+        modelsPath: "/v1/models"
+      }
+    };
+  }
+};
+
+exports.openaiAdapter = openaiAdapter;
+exports.openaiResponsesAdapter = openaiResponsesAdapter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map