@yourgpt/llm-sdk 2.1.10-alpha.0 → 2.5.1-beta.0

package/dist/providers/openrouter/index.mjs

@@ -1,3 +1,232 @@
+// src/adapters/base.ts
+function stringifyForDebug(value) {
+  return JSON.stringify(
+    value,
+    (_key, currentValue) => {
+      if (typeof currentValue === "bigint") {
+        return currentValue.toString();
+      }
+      if (currentValue instanceof Error) {
+        return {
+          name: currentValue.name,
+          message: currentValue.message,
+          stack: currentValue.stack
+        };
+      }
+      return currentValue;
+    },
+    2
+  );
+}
+function logProviderPayload(provider, label, payload, enabled) {
+  if (!enabled) {
+    return;
+  }
+  if (label.toLowerCase().includes("stream ")) {
+    return;
+  }
+  try {
+    console.log(
+      `[llm-sdk:${provider}] ${label}
+${stringifyForDebug(payload)}`
+    );
+  } catch (error) {
+    console.log(
+      `[llm-sdk:${provider}] ${label} (failed to stringify payload)`,
+      error
+    );
+  }
+}
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
+  }
+  if (param.enum) {
+    schema.enum = param.enum;
+  }
+  if (param.type === "array" && param.items) {
+    schema.items = parameterToJsonSchema(
+      param.items
+    );
+  }
+  if (param.type === "object" && param.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(param.properties).map(([key, prop]) => [
+        key,
+        parameterToJsonSchema(
+          prop
+        )
+      ])
+    );
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function normalizeObjectJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  const normalized = { ...schema };
+  const type = normalized.type;
+  if (type === "object") {
+    const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : {};
+    normalized.properties = Object.fromEntries(
+      Object.entries(properties).map(([key, value]) => [
+        key,
+        normalizeObjectJsonSchema(value)
+      ])
+    );
+    const propertyKeys = Object.keys(properties);
+    const required = Array.isArray(normalized.required) ? normalized.required.filter(
+      (value) => typeof value === "string"
+    ) : [];
+    normalized.required = Array.from(/* @__PURE__ */ new Set([...required, ...propertyKeys]));
+    if (normalized.additionalProperties === void 0) {
+      normalized.additionalProperties = false;
+    }
+  } else if (type === "array" && normalized.items && typeof normalized.items === "object") {
+    normalized.items = normalizeObjectJsonSchema(
+      normalized.items
+    );
+  }
+  return normalized;
+}
+function isOpenAIReasoningModel(modelId) {
+  if (!modelId) return false;
+  return /^(o1|o3|o4|gpt-5)/i.test(modelId);
+}
+function buildOpenAITokenParams(modelId, maxTokens, temperature) {
+  if (isOpenAIReasoningModel(modelId)) {
+    return { max_completion_tokens: maxTokens };
+  }
+  return { max_tokens: maxTokens, temperature };
+}
+function toOpenAIResponseFormat(rf) {
+  if (!rf) return void 0;
+  if (rf.type === "json_object") return { type: "json_object" };
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: rf.json_schema.name,
+      schema: normalizeObjectJsonSchema(rf.json_schema.schema),
+      strict: rf.json_schema.strict ?? true
+    }
+  };
+}
+function toOpenAIResponsesTextFormat(rf) {
+  if (!rf || rf.type !== "json_schema") return void 0;
+  return {
+    type: "json_schema",
+    name: rf.json_schema.name,
+    schema: normalizeObjectJsonSchema(rf.json_schema.schema),
+    strict: rf.json_schema.strict ?? true
+  };
+}
+function formatTools(actions) {
+  return actions.map((action) => ({
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            parameterToJsonSchema(param)
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : [],
+        additionalProperties: false
+      }
+    }
+  }));
+}
+function hasImageAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some((a) => a.type === "image") ?? false;
+}
+function attachmentToOpenAIImage(attachment) {
+  if (attachment.type !== "image") return null;
+  let imageUrl;
+  if (attachment.url) {
+    imageUrl = attachment.url;
+  } else if (attachment.data) {
+    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+  } else {
+    return null;
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl,
+      detail: "auto"
+    }
+  };
+}
+function messageToOpenAIContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasImageAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToOpenAIImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
+    }
+  }
+  return blocks;
+}
+function formatMessagesForOpenAI(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      formatted.push({ role: "system", content: msg.content ?? "" });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToOpenAIContent(msg)
+      });
+    } else if (msg.role === "assistant") {
+      const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
+      const assistantMsg = {
+        role: "assistant",
+        // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
+        content: hasToolCalls ? msg.content || null : msg.content
+      };
+      if (hasToolCalls) {
+        assistantMsg.tool_calls = msg.tool_calls;
+      }
+      formatted.push(assistantMsg);
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      formatted.push({
+        role: "tool",
+        content: msg.content ?? "",
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  return formatted;
+}
+
 // src/providers/openrouter/provider.ts
 var DEFAULT_MODEL_CONFIG = {
   vision: true,
@@ -5,9 +234,6 @@ var DEFAULT_MODEL_CONFIG = {
   jsonMode: true,
   maxTokens: 128e3
 };
-function isOpenAIReasoningModel(modelId) {
-  return modelId.startsWith("openai/o1") || modelId.startsWith("openai/o3") || modelId.startsWith("openai/o4") || modelId.startsWith("openai/gpt-5");
-}
 function openrouter(modelId, options = {}) {
   const apiKey = options.apiKey ?? process.env.OPENROUTER_API_KEY;
   const baseURL = options.baseURL ?? "https://openrouter.ai/api/v1";
@@ -39,7 +265,7 @@ function openrouter(modelId, options = {}) {
       supportsTools: modelConfig.tools,
       supportsStreaming: true,
       supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: true,
+      supportsThinking: false,
       supportsPDF: false,
       maxTokens: modelConfig.maxTokens,
       supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
@@ -59,6 +285,10 @@ function openrouter(modelId, options = {}) {
       if (options.providerPreferences) {
         requestBody.provider = options.providerPreferences;
       }
+      const responseFormat = toOpenAIResponseFormat(params.responseFormat);
+      if (responseFormat) {
+        requestBody.response_format = responseFormat;
+      }
       const response = await client2.chat.completions.create(requestBody);
       const choice = response.choices[0];
       const message = choice.message;
@@ -82,11 +312,6 @@ function openrouter(modelId, options = {}) {
       };
     },
     async *doStream(params) {
-      if (!options.disableThinking && isOpenAIReasoningModel(modelId)) {
-        const client3 = await getClient();
-        yield* doStreamResponsesAPI(client3, modelId, params);
-        return;
-      }
       const client2 = await getClient();
       const messages = formatMessagesForOpenRouter(params.messages);
       const requestBody = {
@@ -94,8 +319,7 @@ function openrouter(modelId, options = {}) {
         messages,
         temperature: params.temperature,
         max_tokens: params.maxTokens,
-        stream: true,
-        ...!options.disableThinking ? { reasoning: { max_tokens: 8e3 }, include_reasoning: true } : {}
+        stream: true
       };
       if (params.tools) {
         requestBody.tools = params.tools;
@@ -103,11 +327,14 @@ function openrouter(modelId, options = {}) {
       if (options.providerPreferences) {
         requestBody.provider = options.providerPreferences;
       }
+      const responseFormat = toOpenAIResponseFormat(params.responseFormat);
+      if (responseFormat) {
+        requestBody.response_format = responseFormat;
+      }
       const stream = await client2.chat.completions.create(requestBody);
       let currentToolCall = null;
       let totalPromptTokens = 0;
       let totalCompletionTokens = 0;
-      let orReasoningStarted = false;
       for await (const chunk of stream) {
         if (params.signal?.aborted) {
           yield { type: "error", error: new Error("Aborted") };
@@ -118,20 +345,6 @@ function openrouter(modelId, options = {}) {
         if (delta?.content) {
           yield { type: "text-delta", text: delta.content };
         }
-        const rc = delta?.reasoning_content ?? delta?.reasoning ?? null;
-        if (rc) {
-          const rcText = typeof rc === "string" ? rc : Array.isArray(rc) && rc[0]?.text ? rc[0].text : "";
-          if (rcText) {
-            if (!orReasoningStarted) {
-              yield { type: "thinking:start" };
-              orReasoningStarted = true;
-            }
-            yield { type: "thinking:delta", content: rcText };
-          }
-        } else if (orReasoningStarted && (delta?.content || choice?.finish_reason)) {
-          yield { type: "thinking:end" };
-          orReasoningStarted = false;
-        }
         if (delta?.tool_calls) {
           for (const tc of delta.tool_calls) {
             if (tc.id) {
@@ -171,578 +384,118 @@ function openrouter(modelId, options = {}) {
             totalPromptTokens = chunk.usage.prompt_tokens;
             totalCompletionTokens = chunk.usage.completion_tokens;
           }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
-        }
-      }
-    }
-  };
-}
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForOpenRouter(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "system":
-        return { role: "system", content: msg.content };
-      case "user":
-        if (typeof msg.content === "string") {
-          return { role: "user", content: msg.content };
-        }
-        return {
-          role: "user",
-          content: msg.content.map((part) => {
-            if (part.type === "text") {
-              return { type: "text", text: part.text };
-            }
-            if (part.type === "image") {
-              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-              return { type: "image_url", image_url: { url, detail: "auto" } };
-            }
-            return { type: "text", text: "" };
-          })
-        };
-      case "assistant":
-        const assistantMsg = {
-          role: "assistant",
-          content: msg.content
-        };
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }));
-        }
-        return assistantMsg;
-      case "tool":
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        };
-      default:
-        return msg;
-    }
-  });
-}
-function formatMessagesForResponsesAPI(messages) {
-  const out = [];
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      out.push({
-        type: "message",
-        role: "system",
-        content: [
-          {
-            type: "input_text",
-            text: typeof msg.content === "string" ? msg.content : ""
-          }
-        ]
-      });
-      continue;
-    }
-    if (msg.role === "user") {
-      const parts = [];
-      if (typeof msg.content === "string") {
-        parts.push({ type: "input_text", text: msg.content });
-      } else {
-        for (const part of msg.content) {
-          if (part.type === "text") {
-            parts.push({ type: "input_text", text: part.text });
-          } else if (part.type === "image") {
-            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-            const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-            parts.push({ type: "input_image", image_url: url });
-          }
-        }
-      }
-      out.push({ type: "message", role: "user", content: parts });
-      continue;
-    }
-    if (msg.role === "assistant") {
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        for (const tc of msg.toolCalls) {
-          out.push({
-            type: "function_call",
-            call_id: tc.id,
-            name: tc.name,
-            arguments: JSON.stringify(tc.args ?? {})
-          });
-        }
-        if (typeof msg.content === "string" && msg.content.length > 0) {
-          out.push({
-            type: "message",
-            role: "assistant",
-            content: [{ type: "output_text", text: msg.content }]
-          });
-        }
-      } else {
-        const text = typeof msg.content === "string" ? msg.content : "";
-        out.push({
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text }]
-        });
-      }
-      continue;
-    }
-    if (msg.role === "tool") {
-      out.push({
-        type: "function_call_output",
-        call_id: msg.toolCallId,
-        output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-      });
-      continue;
-    }
-  }
-  return out;
-}
-function formatToolsForResponsesAPI(tools) {
-  if (!tools || tools.length === 0) return void 0;
-  return tools.map((t) => {
-    if (t?.name && t?.parameters && t?.type === "function") return t;
-    const fn = t?.function ?? t;
-    return {
-      type: "function",
-      name: fn.name,
-      description: fn.description,
-      parameters: fn.parameters ?? { type: "object", properties: {} }
-    };
-  });
-}
-async function* doStreamResponsesAPI(client, modelId, params) {
-  const systemTexts = [];
-  const nonSystem = [];
-  for (const m of params.messages) {
-    if (m.role === "system" && typeof m.content === "string") {
-      systemTexts.push(m.content);
-    } else {
-      nonSystem.push(m);
-    }
-  }
-  const instructions = systemTexts.join("\n\n") || void 0;
-  const input = formatMessagesForResponsesAPI(nonSystem);
-  const requestBody = {
-    model: modelId,
-    input,
-    stream: true,
-    reasoning: { effort: "medium", summary: "auto" }
-  };
-  if (instructions) requestBody.instructions = instructions;
-  if (typeof params.maxTokens === "number")
-    requestBody.max_output_tokens = params.maxTokens;
-  if (typeof params.temperature === "number")
-    requestBody.temperature = params.temperature;
-  const tools = formatToolsForResponsesAPI(params.tools);
-  if (tools) requestBody.tools = tools;
-  let stream;
-  try {
-    stream = await client.responses.create(requestBody);
-  } catch (err) {
-    yield {
-      type: "error",
-      error: err instanceof Error ? err : new Error(String(err))
-    };
-    return;
-  }
-  const toolCalls = /* @__PURE__ */ new Map();
-  let reasoningStarted = false;
-  let textStarted = false;
-  let totalPromptTokens = 0;
-  let totalCompletionTokens = 0;
-  let finishEmitted = false;
-  for await (const evt of stream) {
-    if (params.signal?.aborted) {
-      yield { type: "error", error: new Error("Aborted") };
-      return;
-    }
-    const t = evt?.type ?? "";
-    if (t === "response.reasoning_summary_text.delta") {
-      const delta = evt.delta ?? "";
-      if (!delta) continue;
-      if (!reasoningStarted) {
-        yield { type: "thinking:start" };
-        reasoningStarted = true;
-      }
-      yield { type: "thinking:delta", content: delta };
-      continue;
-    }
-    if (t === "response.reasoning_summary_text.done" || t === "response.reasoning.done") {
-      continue;
-    }
-    if (t === "response.output_text.delta") {
-      const text = evt.delta ?? "";
-      if (!text) continue;
-      if (reasoningStarted && !textStarted) {
-        yield { type: "thinking:end" };
-        textStarted = true;
-      }
-      yield { type: "text-delta", text };
-      continue;
-    }
-    if (t === "response.output_item.added") {
-      const item = evt.item;
-      if (item?.type === "function_call") {
-        const id = item.call_id ?? item.id ?? "";
-        if (id) {
-          toolCalls.set(id, {
-            id,
-            name: item.name ?? "",
-            arguments: item.arguments ?? ""
-          });
-        }
-      }
-      continue;
-    }
-    if (t === "response.function_call_arguments.delta") {
-      const id = evt.call_id ?? evt.item_id ?? "";
-      const delta = evt.delta ?? "";
-      if (!id || !delta) continue;
-      const existing = toolCalls.get(id);
-      if (existing) {
-        existing.arguments += delta;
-      } else {
-        toolCalls.set(id, { id, name: "", arguments: delta });
-      }
-      continue;
-    }
-    if (t === "response.output_item.done") {
-      const item = evt.item;
-      if (item?.type === "function_call") {
-        const id = item.call_id ?? item.id ?? "";
-        const tc = toolCalls.get(id);
-        const name = tc?.name || item.name || "";
-        const argsStr = tc?.arguments || item.arguments || "{}";
-        let args = {};
-        try {
-          args = JSON.parse(argsStr || "{}");
-        } catch {
-          args = {};
-        }
-        if (id && name) {
-          yield {
-            type: "tool-call",
-            toolCall: { id, name, args }
-          };
-        }
-        toolCalls.delete(id);
-      }
-      continue;
-    }
-    if (t === "response.completed") {
-      const usage = evt.response?.usage;
-      if (usage) {
-        totalPromptTokens = usage.input_tokens ?? 0;
-        totalCompletionTokens = usage.output_tokens ?? 0;
-      }
-      for (const tc of toolCalls.values()) {
-        let args = {};
-        try {
-          args = JSON.parse(tc.arguments || "{}");
-        } catch {
-          args = {};
-        }
-        if (tc.id && tc.name) {
-          yield {
-            type: "tool-call",
-            toolCall: { id: tc.id, name: tc.name, args }
-          };
-        }
-      }
-      toolCalls.clear();
-      if (reasoningStarted && !textStarted) {
-        yield { type: "thinking:end" };
-      }
-      const finishReason = toolCalls.size > 0 ? "tool-calls" : "stop";
-      yield {
-        type: "finish",
-        finishReason,
-        usage: {
-          promptTokens: totalPromptTokens,
-          completionTokens: totalCompletionTokens,
-          totalTokens: totalPromptTokens + totalCompletionTokens
-        }
-      };
-      finishEmitted = true;
-      continue;
-    }
-    if (t === "response.error" || t === "error") {
-      const msg = evt.error?.message || evt.message || "Responses API error";
-      yield { type: "error", error: new Error(msg) };
-      return;
-    }
-  }
-  if (!finishEmitted) {
-    if (reasoningStarted && !textStarted) {
-      yield { type: "thinking:end" };
-    }
-    yield {
-      type: "finish",
-      finishReason: "stop",
-      usage: {
-        promptTokens: totalPromptTokens,
-        completionTokens: totalCompletionTokens,
-        totalTokens: totalPromptTokens + totalCompletionTokens
-      }
-    };
-  }
-}
-async function fetchOpenRouterModels(apiKey) {
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  const response = await fetch("https://openrouter.ai/api/v1/models", {
-    headers
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch models: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.data || [];
-}
-async function searchOpenRouterModels(query, apiKey) {
-  const models = await fetchOpenRouterModels(apiKey);
-  const lowerQuery = query.toLowerCase();
-  return models.filter(
-    (model) => model.id.toLowerCase().includes(lowerQuery) || model.name.toLowerCase().includes(lowerQuery)
-  );
-}
-
-// src/core/utils.ts
-function generateId(prefix = "id") {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-function generateMessageId() {
-  return generateId("msg");
-}
-function generateToolCallId() {
-  return generateId("call");
-}
-
-// src/adapters/base.ts
-function stringifyForDebug(value) {
-  return JSON.stringify(
-    value,
-    (_key, currentValue) => {
-      if (typeof currentValue === "bigint") {
-        return currentValue.toString();
-      }
-      if (currentValue instanceof Error) {
-        return {
-          name: currentValue.name,
-          message: currentValue.message,
-          stack: currentValue.stack
-        };
-      }
-      return currentValue;
-    },
-    2
-  );
-}
-function logProviderPayload(provider, label, payload, enabled) {
-  if (!enabled) {
-    return;
-  }
-  if (label.toLowerCase().includes("stream ")) {
-    return;
-  }
-  try {
-    console.log(
-      `[llm-sdk:${provider}] ${label}
-${stringifyForDebug(payload)}`
-    );
-  } catch (error) {
-    console.log(
-      `[llm-sdk:${provider}] ${label} (failed to stringify payload)`,
-      error
-    );
-  }
-}
-function parameterToJsonSchema(param) {
-  const schema = {
-    type: param.type
-  };
-  if (param.description) {
-    schema.description = param.description;
-  }
-  if (param.enum) {
-    schema.enum = param.enum;
-  }
-  if (param.type === "array" && param.items) {
-    schema.items = parameterToJsonSchema(
-      param.items
-    );
-  }
-  if (param.type === "object" && param.properties) {
-    schema.properties = Object.fromEntries(
-      Object.entries(param.properties).map(([key, prop]) => [
-        key,
-        parameterToJsonSchema(
-          prop
-        )
-      ])
-    );
-    schema.additionalProperties = false;
-  }
-  return schema;
-}
-function normalizeObjectJsonSchema(schema) {
-  if (!schema || typeof schema !== "object") {
-    return {
-      type: "object",
-      properties: {},
-      required: [],
-      additionalProperties: false
-    };
-  }
-  const normalized = { ...schema };
-  const type = normalized.type;
-  if (type === "object") {
-    const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : {};
-    normalized.properties = Object.fromEntries(
-      Object.entries(properties).map(([key, value]) => [
-        key,
-        normalizeObjectJsonSchema(value)
-      ])
-    );
-    const propertyKeys = Object.keys(properties);
-    const required = Array.isArray(normalized.required) ? normalized.required.filter(
-      (value) => typeof value === "string"
-    ) : [];
-    normalized.required = Array.from(/* @__PURE__ */ new Set([...required, ...propertyKeys]));
-    if (normalized.additionalProperties === void 0) {
-      normalized.additionalProperties = false;
-    }
-  } else if (type === "array" && normalized.items && typeof normalized.items === "object") {
-    normalized.items = normalizeObjectJsonSchema(
-      normalized.items
-    );
-  }
-  return normalized;
-}
-function formatTools(actions) {
-  return actions.map((action) => ({
-    type: "function",
-    function: {
-      name: action.name,
-      description: action.description,
-      parameters: {
-        type: "object",
-        properties: action.parameters ? Object.fromEntries(
-          Object.entries(action.parameters).map(([key, param]) => [
-            key,
-            parameterToJsonSchema(param)
-          ])
-        ) : {},
-        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : [],
-        additionalProperties: false
+          yield {
+            type: "finish",
+            finishReason: mapFinishReason(choice.finish_reason),
+            usage: {
+              promptTokens: totalPromptTokens,
+              completionTokens: totalCompletionTokens,
+              totalTokens: totalPromptTokens + totalCompletionTokens
+            }
+          };
+        }
       }
     }
-  }));
-}
-function hasImageAttachments(message) {
-  const attachments = message.metadata?.attachments;
-  return attachments?.some((a) => a.type === "image") ?? false;
-}
-function attachmentToOpenAIImage(attachment) {
-  if (attachment.type !== "image") return null;
-  let imageUrl;
-  if (attachment.url) {
-    imageUrl = attachment.url;
-  } else if (attachment.data) {
-    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-  } else {
-    return null;
-  }
-  return {
-    type: "image_url",
-    image_url: {
-      url: imageUrl,
-      detail: "auto"
-    }
   };
 }
-function messageToOpenAIContent(message) {
-  const attachments = message.metadata?.attachments;
-  const content = message.content ?? "";
-  if (!hasImageAttachments(message)) {
-    return content;
-  }
-  const blocks = [];
-  if (content) {
-    blocks.push({ type: "text", text: content });
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
   }
-  if (attachments) {
-    for (const attachment of attachments) {
-      const imageBlock = attachmentToOpenAIImage(attachment);
-      if (imageBlock) {
-        blocks.push(imageBlock);
-      }
+}
+function formatMessagesForOpenRouter(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "system":
+        return { role: "system", content: msg.content };
+      case "user":
+        if (typeof msg.content === "string") {
+          return { role: "user", content: msg.content };
+        }
+        return {
+          role: "user",
+          content: msg.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "image") {
+              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              return { type: "image_url", image_url: { url, detail: "auto" } };
+            }
+            return { type: "text", text: "" };
+          })
+        };
+      case "assistant":
+        const assistantMsg = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: msg.content
+        };
+      default:
+        return msg;
     }
-  }
-  return blocks;
+  });
 }
-function formatMessagesForOpenAI(messages, systemPrompt) {
-  const formatted = [];
-  if (systemPrompt) {
-    formatted.push({ role: "system", content: systemPrompt });
+async function fetchOpenRouterModels(apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
   }
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      formatted.push({ role: "system", content: msg.content ?? "" });
-    } else if (msg.role === "user") {
-      formatted.push({
-        role: "user",
-        content: messageToOpenAIContent(msg)
-      });
-    } else if (msg.role === "assistant") {
-      const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
-      const assistantMsg = {
-        role: "assistant",
-        // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
-        content: hasToolCalls ? msg.content || null : msg.content
-      };
-      if (hasToolCalls) {
-        assistantMsg.tool_calls = msg.tool_calls;
-      }
-      formatted.push(assistantMsg);
-    } else if (msg.role === "tool" && msg.tool_call_id) {
-      formatted.push({
-        role: "tool",
-        content: msg.content ?? "",
-        tool_call_id: msg.tool_call_id
-      });
-    }
+  const response = await fetch("https://openrouter.ai/api/v1/models", {
+    headers
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch models: ${response.statusText}`);
   }
-  return formatted;
+  const data = await response.json();
+  return data.data || [];
+}
+async function searchOpenRouterModels(query, apiKey) {
+  const models = await fetchOpenRouterModels(apiKey);
+  const lowerQuery = query.toLowerCase();
+  return models.filter(
+    (model) => model.id.toLowerCase().includes(lowerQuery) || model.name.toLowerCase().includes(lowerQuery)
+  );
+}
+
+// src/core/utils.ts
+function generateId(prefix = "id") {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateToolCallId() {
+  return generateId("call");
 }
 
 // src/adapters/openai.ts
@@ -757,7 +510,6 @@ var OpenAIAdapter = class _OpenAIAdapter {
     if (baseUrl.includes("generativelanguage.googleapis.com")) return "google";
     if (baseUrl.includes("x.ai")) return "xai";
     if (baseUrl.includes("azure")) return "azure";
-    if (baseUrl.includes("openrouter.ai")) return "openrouter";
     return "openai";
   }
   async getClient() {
@@ -857,259 +609,12 @@ var OpenAIAdapter = class _OpenAIAdapter {
       rawResponse: response
     };
   }
-  /**
-   * OpenAI reasoning models on OpenRouter (o1/o3/o4/gpt-5 family) hide their
-   * reasoning content on the chat-completions endpoint. To surface reasoning
-   * SUMMARIES (not raw CoT, which OpenAI never exposes) we have to use the
-   * Responses API, which streams `response.reasoning_summary_text.delta` events.
-   *
-   * Match by prefix on the OpenRouter model id. Excludes openai/gpt-4o,
-   * openai/gpt-4.1, openai/chatgpt-* — those continue on chat-completions.
-   */
-  isOpenAIReasoningModelOnOpenRouter(activeModel) {
-    if (this.provider !== "openrouter") return false;
-    return activeModel.startsWith("openai/o1") || activeModel.startsWith("openai/o3") || activeModel.startsWith("openai/o4") || activeModel.startsWith("openai/gpt-5");
-  }
-  /**
-   * Convert ActionDefinition[] (the chat-completions tool shape used by the
-   * adapter) to the Responses API tool shape.
-   */
-  buildResponsesToolsFromActions(actions) {
-    if (!actions || actions.length === 0) return void 0;
-    const formatted = formatTools(actions);
-    return formatted.map((t) => ({
-      type: "function",
-      name: t.function.name,
-      description: t.function.description,
-      parameters: t.function.parameters
-    }));
-  }
-  /**
-   * Streaming Responses API path for OpenAI reasoning models on OpenRouter.
-   *
-   * Maps Responses API SSE events back to the same StreamEvent shapes the
-   * chat-completions path emits, so downstream consumers (processChunk.ts,
-   * frontend tool handlers, plan approval, specialist delegations) see
-   * identical events regardless of which path produced them.
-   *
-   *   response.reasoning_summary_text.delta  → thinking:start (once) + thinking:delta
-   *   response.output_text.delta             → message:delta
-   *   response.output_item.added (function_call) → action:start (queued buffer)
-   *   response.function_call_arguments.delta → action:args (progressive)
-   *   response.output_item.done (function_call) → final action:args + action:end
-   *   response.completed                     → message:end + done(usage)
-   *   response.error                         → error
-   */
-  async *streamWithResponsesAPI(request, activeModel, messageId) {
-    const client = await this.getClient();
-    const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
-    const payload = {
-      model: activeModel,
-      input: this.buildResponsesInput(request),
-      stream: true,
-      reasoning: {
-        effort: request.config?.reasoningEffort ?? "medium",
-        summary: "auto"
-      }
-    };
-    if (request.systemPrompt) payload.instructions = request.systemPrompt;
-    if (typeof maxTokensValue === "number")
-      payload.max_output_tokens = maxTokensValue;
-    const tools = this.buildResponsesToolsFromActions(request.actions);
-    if (tools && tools.length > 0) payload.tools = tools;
-    logProviderPayload(
-      "openai",
-      "responses-api request payload",
-      payload,
-      request.debug
-    );
-    let stream;
-    try {
-      stream = await client.responses.create(payload);
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "OPENAI_RESPONSES_ERROR"
-      };
-      return;
-    }
-    const toolBuffers = /* @__PURE__ */ new Map();
-    const itemIdToCallId = /* @__PURE__ */ new Map();
-    let usage;
-    let reasoningStarted = false;
-    let textStarted = false;
-    let finishEmitted = false;
-    const resolveCallId = (evt) => {
-      if (evt?.call_id) return evt.call_id;
-      if (evt?.item_id) return itemIdToCallId.get(evt.item_id) ?? evt.item_id;
-      if (evt?.item?.call_id) return evt.item.call_id;
-      if (evt?.item?.id) return evt.item.id;
-      return "";
-    };
-    try {
-      for await (const evt of stream) {
-        logProviderPayload(
-          "openai",
-          "responses-api stream chunk",
-          evt,
-          request.debug
-        );
-        if (request.signal?.aborted) break;
-        const t = evt?.type ?? "";
-        if (t === "response.reasoning_summary_text.delta") {
-          const delta = evt.delta ?? "";
-          if (!delta) continue;
-          if (!reasoningStarted) {
-            yield { type: "thinking:start" };
-            reasoningStarted = true;
-          }
-          yield { type: "thinking:delta", content: delta };
-          continue;
-        }
-        if (t === "response.reasoning_summary_text.done" || t === "response.reasoning.done") {
-          continue;
-        }
-        if (t === "response.output_text.delta") {
-          const text = evt.delta ?? "";
-          if (!text) continue;
-          if (reasoningStarted && !textStarted) {
-            yield { type: "thinking:end" };
-            textStarted = true;
-          }
-          yield { type: "message:delta", content: text };
-          continue;
-        }
-        if (t === "response.output_item.added") {
-          const item = evt.item;
-          if (item?.type === "function_call") {
-            const callId = item.call_id ?? item.id ?? "";
-            const itemId = item.id ?? callId;
-            if (callId) {
-              if (itemId && itemId !== callId) {
-                itemIdToCallId.set(itemId, callId);
-              }
-              if (!toolBuffers.has(callId)) {
-                toolBuffers.set(callId, {
-                  id: callId,
-                  name: item.name ?? "",
-                  arguments: item.arguments ?? "",
-                  emittedStart: false
-                });
-              }
-              const buf = toolBuffers.get(callId);
-              if (buf.name && !buf.emittedStart) {
-                yield { type: "action:start", id: buf.id, name: buf.name };
-                buf.emittedStart = true;
-              }
-            }
-          }
-          continue;
-        }
-        if (t === "response.function_call_arguments.delta") {
-          const callId = resolveCallId(evt);
-          const delta = evt.delta ?? "";
-          if (!callId || !delta) continue;
-          let buf = toolBuffers.get(callId);
-          if (!buf) {
-            buf = { id: callId, name: "", arguments: "", emittedStart: false };
-            toolBuffers.set(callId, buf);
-          }
-          buf.arguments += delta;
-          if (buf.emittedStart) {
-            yield {
-              type: "action:args",
-              id: buf.id,
-              args: buf.arguments
-            };
-          }
-          continue;
-        }
-        if (t === "response.output_item.done") {
-          const item = evt.item;
-          if (item?.type === "function_call") {
-            const callId = item.call_id ?? item.id ?? "";
-            const buf = toolBuffers.get(callId);
-            const name = buf?.name || item.name || "";
-            const argsStr = buf?.arguments || item.arguments || "{}";
-            if (callId && name) {
-              if (!buf?.emittedStart) {
-                yield { type: "action:start", id: callId, name };
-              }
-              yield {
-                type: "action:args",
-                id: callId,
-                args: argsStr
-              };
-              yield {
-                type: "action:end",
-                id: callId,
-                name
-              };
-            }
-            toolBuffers.delete(callId);
-          }
-          continue;
-        }
-        if (t === "response.completed") {
-          const u = evt.response?.usage;
-          if (u) {
-            usage = {
-              prompt_tokens: u.input_tokens ?? 0,
-              completion_tokens: u.output_tokens ?? 0,
-              total_tokens: u.total_tokens ?? (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
-            };
-          }
-          for (const buf of toolBuffers.values()) {
-            if (!buf.id || !buf.name) continue;
-            if (!buf.emittedStart) {
-              yield { type: "action:start", id: buf.id, name: buf.name };
-            }
-            yield {
-              type: "action:args",
-              id: buf.id,
-              args: buf.arguments || "{}"
-            };
-            yield { type: "action:end", id: buf.id, name: buf.name };
-          }
-          toolBuffers.clear();
-          if (reasoningStarted && !textStarted) {
-            yield { type: "thinking:end" };
-          }
-          yield { type: "message:end" };
-          yield { type: "done", usage };
-          finishEmitted = true;
-          continue;
-        }
-        if (t === "response.error" || t === "error") {
-          const msg = evt.error?.message || evt.message || "Responses API error";
-          yield {
-            type: "error",
-            message: msg,
-            code: "OPENAI_RESPONSES_ERROR"
-          };
-          return;
-        }
-      }
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "OPENAI_RESPONSES_ERROR"
-      };
-      return;
-    }
-    if (!finishEmitted) {
-      if (reasoningStarted && !textStarted) {
-        yield { type: "thinking:end" };
-      }
-      yield { type: "message:end" };
-      yield { type: "done", usage };
-    }
-  }
   async completeWithResponses(request) {
     const client = await this.getClient();
     const openaiToolOptions = request.providerToolOptions?.openai;
+    const responsesTextFormat = toOpenAIResponsesTextFormat(
+      request.config?.responseFormat
+    );
     const payload = {
       model: request.config?.model || this.model,
       instructions: request.systemPrompt,
@@ -1119,6 +624,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
       parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
       temperature: request.config?.temperature ?? this.config.temperature,
       max_output_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+      ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream: false
     };
     logProviderPayload("openai", "request payload", payload, request.debug);
@@ -1240,37 +746,21 @@ var OpenAIAdapter = class _OpenAIAdapter {
           name: openaiToolOptions.toolChoice.name
         }
       } : openaiToolOptions?.toolChoice;
-      const isOpenRouter = this.provider === "openrouter";
-      const activeModel = request.config?.model || this.model;
-      const modelSlug = activeModel.replace("openai/", "");
-      const isOSeries = /^o[1-9]/.test(modelSlug);
-      const isOpenAIOnOpenRouter = isOpenRouter && activeModel.startsWith("openai/");
-      if (!this.config.disableThinking && this.isOpenAIReasoningModelOnOpenRouter(activeModel)) {
-        yield* this.streamWithResponsesAPI(request, activeModel, messageId);
-        return;
-      }
-      const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
+      const modelIdForPayload = request.config?.model || this.model;
       const payload = {
-        model: activeModel,
+        model: modelIdForPayload,
         messages,
         tools: tools.length > 0 ? tools : void 0,
         tool_choice: tools.length > 0 ? toolChoice : void 0,
         parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
+        ...buildOpenAITokenParams(
+          modelIdForPayload,
+          request.config?.maxTokens ?? this.config.maxTokens,
+          request.config?.temperature ?? this.config.temperature
+        ),
+        response_format: toOpenAIResponseFormat(request.config?.responseFormat),
         stream: true,
-        stream_options: { include_usage: true },
-        // o-series: use max_completion_tokens + reasoning_effort, no temperature
-        // regular models: use max_tokens + temperature
-        ...isOSeries ? {
-          max_completion_tokens: maxTokensValue,
-          reasoning_effort: request.config?.reasoningEffort ?? "medium"
-        } : {
-          temperature: request.config?.temperature ?? this.config.temperature,
-          max_tokens: maxTokensValue
-        },
-        // Non-OpenAI OpenRouter models support OR's reasoning/include_reasoning params.
-        // When disableThinking=true we must explicitly send include_reasoning:false because
-        // models like Qwen3 and DeepSeek-R1 reason by default even without the reasoning param.
-        ...isOpenRouter && !isOpenAIOnOpenRouter ? this.config.disableThinking ? { include_reasoning: false } : { reasoning: { max_tokens: 8e3 }, include_reasoning: true } : {}
+        stream_options: { include_usage: true }
       };
       logProviderPayload("openai", "request payload", payload, request.debug);
       const stream = await client.chat.completions.create(payload);
@@ -1278,7 +768,6 @@ var OpenAIAdapter = class _OpenAIAdapter {
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
-      let adapterReasoningStarted = false;
       for await (const chunk of stream) {
         logProviderPayload("openai", "stream chunk", chunk, request.debug);
         if (request.signal?.aborted) {
@@ -1289,22 +778,6 @@ var OpenAIAdapter = class _OpenAIAdapter {
         if (delta?.content) {
           yield { type: "message:delta", content: delta.content };
         }
-        if (isOpenRouter) {
-          const rc = delta?.reasoning_content ?? delta?.reasoning ?? null;
-          if (rc) {
-            const rcText = typeof rc === "string" ? rc : Array.isArray(rc) && rc[0]?.text ? rc[0].text : "";
-            if (rcText) {
-              if (!adapterReasoningStarted) {
-                yield { type: "thinking:start" };
-                adapterReasoningStarted = true;
-              }
-              yield { type: "thinking:delta", content: rcText };
-            }
-          } else if (adapterReasoningStarted && (delta?.content || choice?.finish_reason)) {
-            yield { type: "thinking:end" };
-            adapterReasoningStarted = false;
-          }
-        }
         const annotations = delta?.annotations;
         if (annotations && annotations.length > 0) {
           for (const annotation of annotations) {
@@ -1352,11 +825,6 @@ var OpenAIAdapter = class _OpenAIAdapter {
               };
             } else if (currentToolCall && toolCall.function?.arguments) {
               currentToolCall.arguments += toolCall.function.arguments;
-              yield {
-                type: "action:args",
-                id: currentToolCall.id,
-                args: currentToolCall.arguments
-              };
             }
           }
         }
@@ -1432,24 +900,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
         name: openaiToolOptions.toolChoice.name
       }
     } : openaiToolOptions?.toolChoice;
-    const activeModel2 = request.config?.model || this.model;
-    const modelSlug2 = activeModel2.replace("openai/", "");
-    const isOSeries2 = /^o[1-9]/.test(modelSlug2);
-    const maxTokensValue2 = request.config?.maxTokens ?? this.config.maxTokens;
+    const modelIdForCompletePayload = request.config?.model || this.model;
     const payload = {
-      model: activeModel2,
+      model: modelIdForCompletePayload,
       messages,
       tools: tools.length > 0 ? tools : void 0,
       tool_choice: tools.length > 0 ? toolChoice : void 0,
       parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-      stream: false,
-      ...isOSeries2 ? {
-        max_completion_tokens: maxTokensValue2,
-        reasoning_effort: request.config?.reasoningEffort ?? "medium"
-      } : {
-        temperature: request.config?.temperature ?? this.config.temperature,
-        max_tokens: maxTokensValue2
-      }
+      ...buildOpenAITokenParams(
+        modelIdForCompletePayload,
+        request.config?.maxTokens ?? this.config.maxTokens,
+        request.config?.temperature ?? this.config.temperature
+      ),
+      response_format: toOpenAIResponseFormat(request.config?.responseFormat),
+      stream: false
     };
     logProviderPayload("openai", "request payload", payload, request.debug);
     const response = await client.chat.completions.create(payload);
@@ -1532,8 +996,7 @@ function createOpenRouter(config = {}) {
     return createOpenAIAdapter({
       apiKey,
       model: modelId,
-      baseUrl,
-      disableThinking: config.disableThinking
+      baseUrl
     });
   };
   const getCapabilities = (modelId) => {