@miraiclip/assistant 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -20,29 +20,41 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AI_PROVIDERS: () => AI_PROVIDERS,
   BACKGROUND_TEMPLATE: () => BACKGROUND_TEMPLATE,
   ChatModelError: () => ChatModelError,
   DEFAULT_INSTRUCTIONS: () => DEFAULT_INSTRUCTIONS,
+  USER_KEY_HEADERS: () => USER_KEY_HEADERS,
+  aiProvider: () => aiProvider,
+  anthropicChatModel: () => anthropicChatModel,
   applyChecked: () => applyChecked,
   applyCommandsSchema: () => applyCommandsSchema,
+  chatModelsFromEnv: () => chatModelsFromEnv,
   commitFork: () => commitFork,
   createAssistant: () => createAssistant,
   createChatHandler: () => createChatHandler,
+  createChatModel: () => createChatModel,
   defineChatModel: () => defineChatModel,
   defineTool: () => defineTool,
   describeCommands: () => describeCommands,
   describeForAssistant: () => describeForAssistant,
   editorTools: () => editorTools,
   forkProject: () => forkProject,
+  geminiChatModel: () => geminiChatModel,
   openAIChatModel: () => openAIChatModel,
   parseToolArguments: () => parseToolArguments,
   rateLimitedChatModel: () => rateLimitedChatModel,
   remoteChatModel: () => remoteChatModel,
   retryDelayMs: () => retryDelayMs,
+  routedChatModel: () => routedChatModel,
   scriptedChatModel: () => scriptedChatModel,
+  splitModelRef: () => splitModelRef,
+  toAnthropicMessages: () => toAnthropicMessages,
+  toGeminiContents: () => toGeminiContents,
   toOpenAIMessages: () => toOpenAIMessages,
   toolsFromDefinitions: () => toolsFromDefinitions,
   unknownFields: () => unknownFields,
+  userKeyHeaders: () => userKeyHeaders,
   withExplicitIds: () => withExplicitIds
 });
 module.exports = __toCommonJS(src_exports);
@@ -70,20 +82,7 @@ function defineChatModel(model) {
   return model;
 }
 
-// src/openai.ts
-function toOpenAIMessages(messages) {
-  return messages.map((m) => {
-    if (m.role === "assistant") {
-      const out = { role: "assistant", content: m.content || null };
-      if (m.toolCalls?.length) {
-        out.tool_calls = m.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: JSON.stringify(c.arguments) } }));
-      }
-      return out;
-    }
-    if (m.role === "tool") return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
-    return { role: m.role, content: m.content };
-  });
-}
+// src/wire.ts
 function parseToolArguments(raw) {
   if (!raw.trim()) return {};
   try {
@@ -93,7 +92,6 @@ function parseToolArguments(raw) {
     return { __invalidArguments: raw };
   }
 }
-var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
 function retryDelayMs(res, message, attempt) {
   const header = Number(res.headers.get("retry-after-ms") ?? NaN) || Number(res.headers.get("retry-after") ?? NaN) * 1e3;
   const m = /try again in ([\d.]+)\s*(ms|s)/i.exec(message);
@@ -108,6 +106,73 @@ function sleep(ms, signal) {
     signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason ?? new Error("aborted"))), { once: true });
   });
 }
+var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504, 529]);
+function errorMessage(body, status) {
+  const b = body;
+  const msg = typeof b?.error === "string" ? b.error : b?.error?.message ?? b?.message;
+  return msg || `HTTP ${status}`;
+}
+async function sendWithRetry(provider, doFetch, url, init, options = {}) {
+  const maxRetries = options.maxRetries ?? 4;
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await doFetch(url, { ...init, ...options.signal ? { signal: options.signal } : {} });
+    } catch (err) {
+      if (err?.name === "AbortError" || options.signal?.aborted) throw err;
+      throw new ChatModelError(provider, `request failed: ${err?.message ?? err}`);
+    }
+    if (res.ok) return res;
+    const message = errorMessage(await res.json().catch(() => null), res.status);
+    const permanent = /quota|credit|billing/i.test(message);
+    if (attempt >= maxRetries || !RETRYABLE.has(res.status) || permanent) throw new ChatModelError(provider, message, res.status);
+    await sleep(retryDelayMs(res, message, attempt), options.signal);
+  }
+}
+async function getJson(provider, doFetch, url, headers, signal) {
+  const res = await sendWithRetry(provider, doFetch, url, { method: "GET", headers }, { maxRetries: 1, ...signal ? { signal } : {} });
+  return res.json();
+}
+async function readSse(body, onData) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const line = (raw) => {
+    const l = raw.replace(/\r$/, "");
+    if (l.startsWith("data:")) onData(l.slice(5).trim());
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (value) buffer += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      line(buffer.slice(0, nl));
+      buffer = buffer.slice(nl + 1);
+    }
+    if (done) break;
+  }
+  if (buffer) line(buffer);
+}
+var isEventStream = (res) => !!res.body && (res.headers.get("content-type") ?? "").includes("event-stream");
+var trimSlash = (url) => url.replace(/\/+$/, "");
+function modelList(model, others = []) {
+  return [others.find((m) => m.id === model) ?? { id: model }, ...others.filter((m) => m.id !== model)];
+}
+
+// src/openai.ts
+function toOpenAIMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "assistant") {
+      const out = { role: "assistant", content: m.content || null };
+      if (m.toolCalls?.length) {
+        out.tool_calls = m.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: JSON.stringify(c.arguments) } }));
+      }
+      return out;
+    }
+    if (m.role === "tool") return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+    return { role: m.role, content: m.content };
+  });
+}
 var FINISH = {
   stop: "stop",
   tool_calls: "tool_calls",
@@ -116,48 +181,45 @@ var FINISH = {
   content_filter: "content_filter"
 };
 function openAIChatModel(options) {
-  const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+  const base = trimSlash(options.baseUrl ?? "https://api.openai.com/v1");
   const id = options.id ?? "openai";
   const doFetch = options.fetch ?? defaultFetch();
   const stream = options.stream ?? true;
-  const models = [{ id: options.model }, ...(options.models ?? []).filter((m) => m.id !== options.model)];
+  const models = modelList(options.model, options.models);
+  const maxTokensField = options.maxTokensField ?? "max_completion_tokens";
+  const headers = () => {
+    const h = { "Content-Type": "application/json", ...options.headers };
+    if (options.apiKey) h["Authorization"] = `Bearer ${options.apiKey}`;
+    if (options.organization) h["OpenAI-Organization"] = options.organization;
+    if (options.project) h["OpenAI-Project"] = options.project;
+    return h;
+  };
   return defineChatModel({
     id,
     label: options.label ?? "OpenAI",
     models,
+    async listModels(opts = {}) {
+      const json2 = await getJson(id, doFetch, `${base}/models`, headers(), opts.signal);
+      return (json2.data ?? []).map((m) => ({ id: m.id })).sort((a, b) => a.id.localeCompare(b.id));
+    },
     async complete(request, opts = {}) {
       const body = {
         model: request.model ?? options.model,
         messages: toOpenAIMessages(request.messages),
         ...request.tools?.length ? { tools: request.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.inputSchema } })) } : {},
-        ...request.maxOutputTokens ? { max_completion_tokens: request.maxOutputTokens } : {},
-        ...stream ? { stream: true, stream_options: { include_usage: true } } : {},
+        ...request.maxOutputTokens ? { [maxTokensField]: request.maxOutputTokens } : {},
+        ...stream ? { stream: true, ...options.streamUsage === false ? {} : { stream_options: { include_usage: true } } } : {},
         ...options.params,
         ...request.params
       };
-      const headers = { "Content-Type": "application/json", ...options.headers };
-      if (options.apiKey) headers["Authorization"] = `Bearer ${options.apiKey}`;
-      if (options.organization) headers["OpenAI-Organization"] = options.organization;
-      if (options.project) headers["OpenAI-Project"] = options.project;
-      const maxRetries = options.maxRetries ?? 4;
-      let res;
-      for (let attempt = 0; ; attempt++) {
-        res = await doFetch(`${base}/chat/completions`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(body),
-          ...opts.signal ? { signal: opts.signal } : {}
-        });
-        if (res.ok) break;
-        const err = await res.json().catch(() => null);
-        const message = err?.error?.message ?? `HTTP ${res.status}`;
-        const permanent = /quota|credits|billing/i.test(message);
-        if (attempt >= maxRetries || !RETRYABLE.has(res.status) || permanent) throw new ChatModelError(id, message, res.status);
-        await sleep(retryDelayMs(res, message, attempt), opts.signal);
-      }
-      if (!stream || !res.body || !(res.headers.get("content-type") ?? "").includes("event-stream")) {
-        return fromCompletion(await res.json(), opts.onText);
-      }
+      const res = await sendWithRetry(
+        id,
+        doFetch,
+        `${base}/chat/completions`,
+        { method: "POST", headers: headers(), body: JSON.stringify(body) },
+        { ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}, ...opts.signal ? { signal: opts.signal } : {} }
+      );
+      if (!stream || !isEventStream(res)) return fromCompletion(await res.json(), opts.onText);
       return readStream(res.body, opts.onText);
     }
   });
@@ -180,9 +242,6 @@ var usage = (u) => ({
   ...u.completion_tokens !== void 0 ? { outputTokens: u.completion_tokens } : {}
 });
 async function readStream(body, onText) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
   let content = "";
   let finish = "other";
   let model;
@@ -214,18 +273,7 @@ async function readStream(body, onText) {
       if (choice.finish_reason) finish = FINISH[choice.finish_reason] ?? "other";
     }
   };
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (value) buffer += decoder.decode(value, { stream: true });
-    let nl;
-    while ((nl = buffer.indexOf("\n")) >= 0) {
-      const line = buffer.slice(0, nl).replace(/\r$/, "");
-      buffer = buffer.slice(nl + 1);
-      if (line.startsWith("data:")) handle(line.slice(5).trim());
-    }
-    if (done) break;
-  }
-  if (buffer.startsWith("data:")) handle(buffer.slice(5).trim());
+  await readSse(body, handle);
   const toolCalls = [...calls.entries()].sort(([a], [b]) => a - b).map(([index, c]) => ({ id: c.id || `call_${index}`, name: c.name, arguments: parseToolArguments(c.args) }));
   const out = { content, toolCalls, finish };
   if (model) out.model = model;
@@ -233,10 +281,585 @@ async function readStream(body, onText) {
   return out;
 }
 
+// src/anthropic.ts
+function toAnthropicMessages(messages) {
+  const system = [];
+  const out = [];
+  const push = (role, blocks) => {
+    if (!blocks.length) return;
+    const last = out[out.length - 1];
+    if (last && last.role === role) last.content.push(...blocks);
+    else out.push({ role, content: blocks });
+  };
+  for (const m of messages) {
+    if (m.role === "system") system.push(m.content);
+    else if (m.role === "user") push("user", m.content.trim() ? [{ type: "text", text: m.content }] : []);
+    else if (m.role === "tool") push("user", [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content }]);
+    else {
+      const thinking = m.toolCalls?.[0]?.meta?.anthropicThinking ?? [];
+      push("assistant", [
+        ...thinking,
+        ...m.content.trim() ? [{ type: "text", text: m.content }] : [],
+        ...(m.toolCalls ?? []).map((c) => ({ type: "tool_use", id: c.id, name: c.name, input: c.arguments }))
+      ]);
+    }
+  }
+  return { system: system.join("\n\n"), messages: out };
+}
+var FINISH2 = {
+  end_turn: "stop",
+  stop_sequence: "stop",
+  tool_use: "tool_calls",
+  max_tokens: "length",
+  model_context_window_exceeded: "length",
+  refusal: "content_filter"
+};
+var usageOf = (u) => {
+  const input = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+  return {
+    ...u.input_tokens !== void 0 ? { inputTokens: input } : {},
+    ...u.output_tokens !== void 0 ? { outputTokens: u.output_tokens } : {}
+  };
+};
+function fromBlocks(blocks, stopReason, model, usage2) {
+  const thinking = blocks.filter((b) => b.type === "thinking" || b.type === "redacted_thinking");
+  const toolCalls = blocks.filter((b) => b.type === "tool_use").map((b, i) => ({ id: b.id, name: b.name, arguments: b.input ?? {}, ...i === 0 && thinking.length ? { meta: { anthropicThinking: thinking } } : {} }));
+  const out = {
+    content: blocks.map((b) => b.type === "text" ? b.text : "").join(""),
+    toolCalls,
+    finish: FINISH2[stopReason ?? ""] ?? "other"
+  };
+  if (model) out.model = model;
+  if (usage2) out.usage = usageOf(usage2);
+  return out;
+}
+function anthropicChatModel(options) {
+  const base = trimSlash(options.baseUrl ?? "https://api.anthropic.com");
+  const id = options.id ?? "anthropic";
+  const doFetch = options.fetch ?? defaultFetch();
+  const stream = options.stream ?? true;
+  const models = modelList(options.model, options.models);
+  const headers = () => {
+    const h = { "Content-Type": "application/json", "anthropic-version": options.version ?? "2023-06-01", ...options.headers };
+    if (options.apiKey) h["x-api-key"] = options.apiKey;
+    if (options.betas?.length) h["anthropic-beta"] = options.betas.join(",");
+    if (options.browser) h["anthropic-dangerous-direct-browser-access"] = "true";
+    return h;
+  };
+  return defineChatModel({
+    id,
+    label: options.label ?? "Anthropic",
+    models,
+    async listModels(opts = {}) {
+      const json2 = await getJson(id, doFetch, `${base}/v1/models?limit=1000`, headers(), opts.signal);
+      return (json2.data ?? []).map((m) => ({ id: m.id, ...m.display_name ? { label: m.display_name } : {} }));
+    },
+    async complete(request, opts = {}) {
+      const { system, messages } = toAnthropicMessages(request.messages);
+      const body = {
+        model: request.model ?? options.model,
+        max_tokens: request.maxOutputTokens ?? options.maxOutputTokens ?? 8192,
+        messages,
+        ...system ? { system } : {},
+        ...request.tools?.length ? { tools: request.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema })) } : {},
+        ...stream ? { stream: true } : {},
+        ...options.params,
+        ...request.params
+      };
+      const res = await sendWithRetry(
+        id,
+        doFetch,
+        `${base}/v1/messages`,
+        { method: "POST", headers: headers(), body: JSON.stringify(body) },
+        { ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}, ...opts.signal ? { signal: opts.signal } : {} }
+      );
+      if (!stream || !isEventStream(res)) {
+        const json2 = await res.json();
+        const out = fromBlocks(json2.content ?? [], json2.stop_reason, json2.model, json2.usage);
+        if (out.content) opts.onText?.(out.content);
+        return out;
+      }
+      return readStream2(id, res.body, opts.onText);
+    }
+  });
+}
+async function readStream2(id, body, onText) {
+  const blocks = /* @__PURE__ */ new Map();
+  let model;
+  let stopReason;
+  const usage2 = {};
+  let failure;
+  await readSse(body, (data) => {
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return;
+    }
+    switch (event.type) {
+      case "message_start":
+        if (event.message?.model) model = event.message.model;
+        Object.assign(usage2, event.message?.usage ?? {});
+        break;
+      case "content_block_start": {
+        const b = event.content_block;
+        blocks.set(event.index ?? blocks.size, {
+          type: b.type,
+          ...b.id ? { id: b.id } : {},
+          ...b.name ? { name: b.name } : {},
+          text: b.text ?? b.thinking ?? "",
+          json: "",
+          signature: b.signature ?? "",
+          ...b.data ? { data: b.data } : {}
+        });
+        if (b.type === "text" && b.text) onText?.(b.text);
+        break;
+      }
+      case "content_block_delta": {
+        const block = blocks.get(event.index ?? 0);
+        const d = event.delta ?? {};
+        if (!block) break;
+        if (d.type === "text_delta" && d.text) {
+          block.text += d.text;
+          onText?.(d.text);
+        } else if (d.type === "input_json_delta" && d.partial_json) block.json += d.partial_json;
+        else if (d.type === "thinking_delta" && d.thinking) block.text += d.thinking;
+        else if (d.type === "signature_delta" && d.signature) block.signature += d.signature;
+        break;
+      }
+      case "message_delta":
+        if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
+        Object.assign(usage2, Object.fromEntries(Object.entries(event.usage ?? {}).filter(([, v]) => v !== null && v !== void 0)));
+        break;
+      case "error":
+        failure = event.error?.message ?? event.error?.type ?? "stream error";
+        break;
+    }
+  });
+  if (failure) throw new ChatModelError(id, failure);
+  const ordered = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, b]) => b);
+  const out = ordered.flatMap((b) => {
+    if (b.type === "text") return [{ type: "text", text: b.text }];
+    if (b.type === "tool_use") return [{ type: "tool_use", id: b.id ?? "", name: b.name ?? "", input: parseToolArguments(b.json) }];
+    if (b.type === "thinking") return [{ type: "thinking", thinking: b.text, signature: b.signature }];
+    if (b.type === "redacted_thinking") return [{ type: "redacted_thinking", data: b.data ?? "" }];
+    return [];
+  });
+  return fromBlocks(out, stopReason, model, Object.keys(usage2).length ? usage2 : void 0);
+}
+
+// src/gemini.ts
+var UNSIGNED = "skip_thought_signature_validator";
+var metaOf = (call) => call.meta?.gemini ?? {};
+function responseObject(content) {
+  try {
+    const value = JSON.parse(content);
+    if (value && typeof value === "object" && !Array.isArray(value)) return value;
+    return { result: value };
+  } catch {
+    return { result: content };
+  }
+}
+function toGeminiContents(messages) {
+  const system = [];
+  const contents = [];
+  const callIds = /* @__PURE__ */ new Map();
+  const push = (role, parts) => {
+    if (!parts.length) return;
+    const last = contents[contents.length - 1];
+    if (last && last.role === role) last.parts.push(...parts);
+    else contents.push({ role, parts });
+  };
+  for (const m of messages) {
+    if (m.role === "system") system.push(m.content);
+    else if (m.role === "user") push("user", m.content ? [{ text: m.content }] : []);
+    else if (m.role === "tool") {
+      const id = callIds.get(m.toolCallId);
+      push("user", [{ functionResponse: { ...id ? { id } : {}, name: m.name, response: responseObject(m.content) } }]);
+    } else {
+      const calls = m.toolCalls ?? [];
+      const signed = calls.some((c) => metaOf(c).signature);
+      push("model", [
+        ...m.content ? [{ text: m.content }] : [],
+        ...calls.map((c, i) => {
+          const meta = metaOf(c);
+          callIds.set(c.id, meta.id);
+          const signature = meta.signature ?? (i === 0 && !signed ? UNSIGNED : void 0);
+          return { functionCall: { ...meta.id ? { id: meta.id } : {}, name: c.name, args: c.arguments }, ...signature ? { thoughtSignature: signature } : {} };
+        })
+      ]);
+    }
+  }
+  return { system: system.join("\n\n"), contents };
+}
+var FINISH3 = {
+  STOP: "stop",
+  MAX_TOKENS: "length",
+  SAFETY: "content_filter",
+  RECITATION: "content_filter",
+  BLOCKLIST: "content_filter",
+  PROHIBITED_CONTENT: "content_filter",
+  SPII: "content_filter",
+  IMAGE_SAFETY: "content_filter"
+};
+function collector(onText) {
+  let content = "";
+  let finishReason;
+  let blocked = false;
+  let model;
+  let usage2;
+  const toolCalls = [];
+  const batch = Math.random().toString(36).slice(2, 10);
+  return {
+    add(json2) {
+      if (json2.modelVersion) model = json2.modelVersion;
+      if (json2.promptFeedback?.blockReason) blocked = true;
+      const u = json2.usageMetadata;
+      if (u) {
+        usage2 = {
+          ...u.promptTokenCount !== void 0 ? { inputTokens: u.promptTokenCount } : {},
+          ...u.candidatesTokenCount !== void 0 || u.thoughtsTokenCount !== void 0 ? { outputTokens: (u.candidatesTokenCount ?? 0) + (u.thoughtsTokenCount ?? 0) } : {}
+        };
+      }
+      const candidate = json2.candidates?.[0];
+      if (candidate?.finishReason) finishReason = candidate.finishReason;
+      for (const part of candidate?.content?.parts ?? []) {
+        if (part.functionCall) {
+          const gemini = { ...part.functionCall.id ? { id: part.functionCall.id } : {}, ...part.thoughtSignature ? { signature: part.thoughtSignature } : {} };
+          toolCalls.push({
+            // Gemini often gives no id; ours must still be unique across the conversation.
+            id: part.functionCall.id ?? `call_${batch}_${toolCalls.length}`,
+            name: part.functionCall.name,
+            arguments: part.functionCall.args ?? {},
+            ...Object.keys(gemini).length ? { meta: { gemini } } : {}
+          });
+        } else if (part.text && !part.thought) {
+          content += part.text;
+          onText?.(part.text);
+        }
+      }
+    },
+    result() {
+      const finish = blocked ? "content_filter" : toolCalls.length && (finishReason === "STOP" || finishReason === void 0) ? "tool_calls" : FINISH3[finishReason ?? ""] ?? "other";
+      return { content, toolCalls, finish, ...model ? { model } : {}, ...usage2 ? { usage: usage2 } : {} };
+    }
+  };
+}
+var bareModel = (model) => model.replace(/^models\//, "");
+function geminiChatModel(options) {
+  const base = trimSlash(options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta");
+  const id = options.id ?? "gemini";
+  const doFetch = options.fetch ?? defaultFetch();
+  const stream = options.stream ?? true;
+  const models = modelList(bareModel(options.model), options.models?.map((m) => ({ ...m, id: bareModel(m.id) })));
+  const headers = () => ({
+    "Content-Type": "application/json",
+    ...options.apiKey ? { "x-goog-api-key": options.apiKey } : {},
+    ...options.headers
+  });
+  return defineChatModel({
+    id,
+    label: options.label ?? "Google Gemini",
+    models,
+    async listModels(opts = {}) {
+      const json2 = await getJson(id, doFetch, `${base}/models?pageSize=1000`, headers(), opts.signal);
+      return (json2.models ?? []).filter((m) => !m.supportedGenerationMethods || m.supportedGenerationMethods.includes("generateContent")).map((m) => ({ id: bareModel(m.name), ...m.displayName ? { label: m.displayName } : {} }));
+    },
+    async complete(request, opts = {}) {
+      const { system, contents } = toGeminiContents(request.messages);
+      const params = { ...options.params, ...request.params };
+      const generationConfig = {
+        ...request.maxOutputTokens ? { maxOutputTokens: request.maxOutputTokens } : {},
+        ...options.params?.generationConfig,
+        ...request.params?.generationConfig
+      };
+      const body = {
+        ...params,
+        contents,
+        ...system ? { systemInstruction: { parts: [{ text: system }] } } : {},
+        ...request.tools?.length ? { tools: [{ functionDeclarations: request.tools.map((t) => ({ name: t.name, description: t.description, parametersJsonSchema: t.inputSchema })) }] } : {},
+        ...Object.keys(generationConfig).length ? { generationConfig } : {}
+      };
+      const model = bareModel(request.model ?? options.model);
+      const url = `${base}/models/${encodeURIComponent(model)}:${stream ? "streamGenerateContent?alt=sse" : "generateContent"}`;
+      const res = await sendWithRetry(
+        id,
+        doFetch,
+        url,
+        { method: "POST", headers: headers(), body: JSON.stringify(body) },
+        { ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}, ...opts.signal ? { signal: opts.signal } : {} }
+      );
+      const collect = collector(opts.onText);
+      if (!stream || !isEventStream(res)) collect.add(await res.json());
+      else {
+        await readSse(res.body, (data) => {
+          try {
+            collect.add(JSON.parse(data));
+          } catch {
+          }
+        });
+      }
+      const out = collect.result();
+      out.model ??= model;
+      return out;
+    }
+  });
+}
+
+// src/providers.ts
+var AI_PROVIDERS = [
+  {
+    id: "openai",
+    label: "OpenAI",
+    api: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    needsKey: true,
+    keyUrl: "https://platform.openai.com/api-keys",
+    env: "OPENAI",
+    defaultModel: "gpt-5.4-mini",
+    models: [{ id: "gpt-5.4-mini" }, { id: "gpt-6-luna" }, { id: "gpt-6.1-sol" }],
+    browser: true
+  },
+  {
+    id: "anthropic",
+    label: "Anthropic",
+    api: "anthropic",
+    baseUrl: "https://api.anthropic.com",
+    needsKey: true,
+    keyUrl: "https://console.anthropic.com/settings/keys",
+    env: "ANTHROPIC",
+    defaultModel: "claude-sonnet-5-5",
+    models: [
+      { id: "claude-sonnet-5-5", label: "Claude Sonnet 5.5" },
+      { id: "claude-haiku-5-5", label: "Claude Haiku 5.5" },
+      { id: "claude-opus-5-5", label: "Claude Opus 5.5" }
+    ],
+    browser: true
+  },
+  {
+    id: "gemini",
+    label: "Google Gemini",
+    api: "gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    needsKey: true,
+    keyUrl: "https://aistudio.google.com/apikey",
+    env: "GEMINI",
+    defaultModel: "gemini-3.8-flash",
+    models: [
+      { id: "gemini-3.8-flash", label: "Gemini 3.8 Flash" },
+      { id: "gemini-3.5-flash-lite", label: "Gemini 3.5 Flash-Lite" },
+      { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (preview)" }
+    ],
+    browser: true
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    api: "openai",
+    baseUrl: "https://openrouter.ai/api/v1",
+    needsKey: true,
+    keyUrl: "https://openrouter.ai/keys",
+    env: "OPENROUTER",
+    defaultModel: "openrouter/auto",
+    models: [{ id: "openrouter/auto", label: "Auto (OpenRouter picks)" }],
+    browser: true,
+    maxTokensField: "max_tokens"
+  },
+  { id: "groq", label: "Groq", api: "openai", baseUrl: "https://api.groq.com/openai/v1", needsKey: true, keyUrl: "https://console.groq.com/keys", env: "GROQ", maxTokensField: "max_tokens" },
+  {
+    id: "mistral",
+    label: "Mistral",
+    api: "openai",
+    baseUrl: "https://api.mistral.ai/v1",
+    needsKey: true,
+    keyUrl: "https://console.mistral.ai/api-keys",
+    env: "MISTRAL",
+    defaultModel: "mistral-medium-latest",
+    maxTokensField: "max_tokens",
+    streamUsage: false
+  },
+  {
+    id: "deepseek",
+    label: "DeepSeek",
+    api: "openai",
+    baseUrl: "https://api.deepseek.com/v1",
+    needsKey: true,
+    keyUrl: "https://platform.deepseek.com/api_keys",
+    env: "DEEPSEEK",
+    defaultModel: "deepseek-chat",
+    maxTokensField: "max_tokens"
+  },
+  { id: "xai", label: "xAI", api: "openai", baseUrl: "https://api.x.ai/v1", needsKey: true, keyUrl: "https://console.x.ai", env: "XAI", maxTokensField: "max_tokens" },
+  {
+    id: "together",
+    label: "Together AI",
+    api: "openai",
+    baseUrl: "https://api.together.xyz/v1",
+    needsKey: true,
+    keyUrl: "https://api.together.ai/settings/api-keys",
+    env: "TOGETHER",
+    maxTokensField: "max_tokens"
+  },
+  { id: "ollama", label: "Ollama (local)", api: "openai", baseUrl: "http://localhost:11434/v1", needsKey: false, local: true, env: "OLLAMA", maxTokensField: "max_tokens" },
+  { id: "lmstudio", label: "LM Studio (local)", api: "openai", baseUrl: "http://localhost:1234/v1", needsKey: false, local: true, env: "LMSTUDIO", maxTokensField: "max_tokens" },
+  { id: "openai-compatible", label: "OpenAI-compatible", api: "openai", needsKey: false, env: "OPENAI_COMPATIBLE", maxTokensField: "max_tokens" }
+];
+function aiProvider(id) {
+  return AI_PROVIDERS.find((p) => p.id === id);
+}
+function createChatModel(options) {
+  const info = aiProvider(options.provider);
+  if (!info) throw new Error(`Unknown AI provider "${options.provider}". Known: ${AI_PROVIDERS.map((p) => p.id).join(", ")}`);
+  const model = options.model || info.defaultModel;
+  if (!model) throw new ChatModelError(info.id, `pick a model (${info.label} has no default; set ${info.env}_MODEL or choose one)`, 400);
+  if (info.needsKey && !options.apiKey) throw new ChatModelError(info.id, `needs an API key${info.keyUrl ? ` (create one at ${info.keyUrl})` : ""}`, 401);
+  const baseUrl = options.baseUrl || info.baseUrl;
+  if (!baseUrl) throw new ChatModelError(info.id, "needs a base URL (the server's /v1 address)", 400);
+  const common = {
+    model,
+    models: options.models ?? info.models ?? [],
+    baseUrl,
+    id: options.id ?? info.id,
+    label: options.label ?? info.label,
+    ...options.apiKey ? { apiKey: options.apiKey } : {},
+    ...options.headers ? { headers: options.headers } : {},
+    ...options.params ? { params: options.params } : {},
+    ...options.stream !== void 0 ? { stream: options.stream } : {},
+    ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  };
+  switch (info.api) {
+    case "anthropic":
+      return anthropicChatModel({ ...common, ...options.browser ? { browser: true } : {} });
+    case "gemini":
+      return geminiChatModel(common);
+    case "openai":
+      return openAIChatModel({
+        ...common,
+        ...info.maxTokensField ? { maxTokensField: info.maxTokensField } : {},
+        ...info.streamUsage !== void 0 ? { streamUsage: info.streamUsage } : {}
+      });
+  }
+}
+function chatModelsFromEnv(env, options = {}) {
+  const out = [];
+  const wanted = options.providers ? new Set(options.providers) : null;
+  for (const info of AI_PROVIDERS) {
+    if (wanted && !wanted.has(info.id)) continue;
+    const p = info.env;
+    let apiKey = env[`${p}_API_KEY`] || (info.id === "gemini" ? env.GOOGLE_API_KEY : void 0);
+    let baseUrl = env[`${p}_BASE_URL`];
+    let label;
+    if (info.id === "openai" && env.OPENAI_BASE_URL) continue;
+    if (info.id === "openai-compatible" && !baseUrl && env.OPENAI_BASE_URL) {
+      baseUrl = env.OPENAI_BASE_URL;
+      apiKey ||= env.OPENAI_API_KEY;
+      label = env.OPENAI_LABEL || void 0;
+    }
+    const model = env[`${p}_MODEL`] || (info.id === "openai-compatible" ? env.OPENAI_MODEL : void 0);
+    const enabled = info.needsKey ? !!apiKey : info.local ? !!(model || baseUrl) : !!baseUrl;
+    if (!enabled) continue;
+    const models = (env[`${p}_MODELS`] || (info.id === "openai-compatible" && env.OPENAI_BASE_URL ? env.OPENAI_MODELS : "") || "").split(",").map((m) => m.trim()).filter(Boolean).map((m) => ({ id: m }));
+    try {
+      out.push(
+        createChatModel({
+          provider: info.id,
+          ...apiKey ? { apiKey } : {},
+          ...model ? { model } : {},
+          ...models.length ? { models } : {},
+          ...baseUrl ? { baseUrl } : {},
+          ...label ? { label } : {},
+          ...options.fetch ? { fetch: options.fetch } : {}
+        })
+      );
+    } catch (err) {
+      options.onSkip?.(info.id, err.message);
+    }
+  }
+  return out;
+}
+function splitModelRef(ref, providerIds) {
+  const slash = ref.indexOf("/");
+  if (slash > 0) {
+    const provider = ref.slice(0, slash);
+    for (const id of providerIds) if (id === provider) return { provider, model: ref.slice(slash + 1) };
+  }
+  return { model: ref };
+}
+function routedChatModel(models, options = {}) {
+  if (!models.length) throw new Error("routedChatModel needs at least one model");
+  const byId = new Map(models.map((m) => [m.id, m]));
+  if (byId.size !== models.length) throw new Error("routedChatModel: adapter ids must be unique");
+  const fallback = options.default && byId.get(options.default) || models[0];
+  const ordered = [fallback, ...models.filter((m) => m !== fallback)];
+  const prefixed = (m, list) => list.map((e) => ({ id: `${m.id}/${e.id}`, label: `${m.label} \xB7 ${e.label ?? e.id}` }));
+  const resolve = (ref) => {
+    if (!ref) return { adapter: fallback };
+    const { provider, model } = splitModelRef(ref, byId.keys());
+    if (provider) return { adapter: byId.get(provider), model };
+    const lister = ordered.find((m) => m.models?.some((e) => e.id === ref));
+    return { adapter: lister ?? fallback, model: ref };
+  };
+  return defineChatModel({
+    id: options.id ?? "router",
+    label: options.label ?? (models.length === 1 ? fallback.label : "AI models"),
+    models: ordered.flatMap((m) => prefixed(m, m.models ?? [])),
+    providers: ordered.map((m) => ({ id: m.id, label: m.label })),
+    async complete(request, opts) {
+      const { adapter, model } = resolve(request.model);
+      const { model: _drop, ...rest } = request;
+      return adapter.complete(model ? { ...rest, model } : rest, opts);
+    },
+    async listModels(opts) {
+      const lists = await Promise.allSettled(ordered.map(async (m) => prefixed(m, m.listModels ? await m.listModels(opts) : m.models ?? [])));
+      return lists.flatMap((r, i) => r.status === "fulfilled" ? r.value : prefixed(ordered[i], ordered[i].models ?? []));
+    }
+  });
+}
+
 // src/http.ts
+var USER_KEY_HEADERS = { provider: "x-ai-provider", key: "x-ai-key", baseUrl: "x-ai-base-url" };
+var hostedProviders = () => AI_PROVIDERS.filter((p) => !p.local && p.baseUrl).map((p) => p.id);
 function createChatHandler(model, options = {}) {
   const base = (options.basePath ?? "").replace(/\/+$/, "");
   const maxBody = options.maxBodyBytes ?? 2e6;
+  const byok = options.userKeys ? options.userKeys === true ? {} : options.userKeys : null;
+  if (!model && !byok) throw new Error("createChatHandler needs a model, or userKeys so users can bring their own");
+  const allowed = new Set(byok?.providers ?? hostedProviders());
+  if (byok?.allowBaseUrl) allowed.add("openai-compatible");
+  const userKeyInfo = byok ? {
+    providers: [...allowed].flatMap((id) => {
+      const p = aiProvider(id);
+      return p ? [{ id: p.id, label: p.label, needsKey: p.needsKey, ...p.keyUrl ? { keyUrl: p.keyUrl } : {}, ...p.defaultModel ? { defaultModel: p.defaultModel } : {}, ...p.models ? { models: p.models } : {} }] : [];
+    }),
+    allowBaseUrl: !!byok.allowBaseUrl,
+    required: !!byok.required
+  } : void 0;
+  const userModel = (request, modelRef) => {
+    if (!byok) return null;
+    const provider = request.headers.get(USER_KEY_HEADERS.provider)?.trim();
+    if (!provider) return null;
+    if (!allowed.has(provider)) return json(403, { error: `bringing your own key isn't enabled for "${provider}" here` });
+    const apiKey = request.headers.get(USER_KEY_HEADERS.key)?.trim() || void 0;
+    const baseUrl = request.headers.get(USER_KEY_HEADERS.baseUrl)?.trim() || void 0;
+    if (baseUrl && !byok.allowBaseUrl) return json(403, { error: "custom API addresses aren't allowed here" });
+    const ref = modelRef ? splitModelRef(modelRef, [provider]) : void 0;
+    const config = {
+      provider,
+      ...apiKey ? { apiKey } : {},
+      // Listing models needs no model; the catalog default (or a placeholder) is fine.
+      model: ref?.model || aiProvider(provider)?.defaultModel || "default",
+      ...baseUrl ? { baseUrl } : {},
+      ...byok.fetch ? { fetch: byok.fetch } : {}
+    };
+    try {
+      return byok.create ? byok.create(config, request) : createChatModel(config);
+    } catch (err) {
+      const status = err instanceof ChatModelError && err.status ? err.status : 400;
+      return json(status, { error: err.message });
+    }
+  };
+  const noModel = () => json(401, { error: "Add your own API key to use AI here.", needsKey: true });
   return async function handle(request) {
     const path = new URL(request.url).pathname;
     if (base && path !== base && !path.startsWith(`${base}/`)) return null;
@@ -244,7 +867,27 @@ function createChatHandler(model, options = {}) {
     const refused = await options.authorize?.(request);
     if (refused) return refused;
     if (rest === "" && request.method === "GET") {
-      return json(200, { id: model.id, label: model.label, models: model.models ?? [] });
+      return json(200, {
+        id: model?.id ?? "byok",
+        label: model?.label ?? "Your API key",
+        models: model?.models ?? [],
+        ...model?.providers ? { providers: model.providers } : {},
+        ...userKeyInfo ? { userKeys: userKeyInfo } : {},
+        ...!model || byok?.required ? { needsKey: true } : {}
+      });
+    }
+    if (rest === "/models" && request.method === "GET") {
+      const mine2 = userModel(request, void 0);
+      if (mine2 instanceof Response) return mine2;
+      const target2 = mine2 ?? (byok?.required ? null : model);
+      if (!target2) return noModel();
+      try {
+        const models = target2.listModels ? await target2.listModels({ signal: request.signal }) : target2.models ?? [];
+        return json(200, { models });
+      } catch (err) {
+        const status = err?.status;
+        return json(status && status >= 400 && status < 600 ? status : 502, { error: err?.message ?? String(err) });
+      }
     }
     if (rest !== "/chat" || request.method !== "POST") return json(404, { error: "not found" });
     const text = await request.text();
@@ -257,13 +900,18 @@ function createChatHandler(model, options = {}) {
     }
     if (!chat || !Array.isArray(chat.messages)) return json(400, { error: "request.messages is required" });
     if (options.prepare) chat = options.prepare(chat);
+    const mine = userModel(request, chat.model);
+    if (mine instanceof Response) return mine;
+    const target = mine ?? (byok?.required ? null : model);
+    if (!target) return noModel();
+    if (mine && chat.model) chat = { ...chat, model: splitModelRef(chat.model, [request.headers.get(USER_KEY_HEADERS.provider).trim(), mine.id]).model };
     const encoder = new TextEncoder();
     const body = new ReadableStream({
       async start(controller) {
         const send = (value) => controller.enqueue(encoder.encode(`${JSON.stringify(value)}
 `));
         try {
-          const response = await model.complete(chat, { signal: request.signal, onText: (delta) => send({ type: "text", delta }) });
+          const response = await target.complete(chat, { signal: request.signal, onText: (delta) => send({ type: "text", delta }) });
           send({ type: "done", response });
         } catch (err) {
           const status = err?.status;
@@ -277,6 +925,14 @@ function createChatHandler(model, options = {}) {
   };
 }
 var json = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+function userKeyHeaders(credentials) {
+  if (!credentials?.provider) return {};
+  return {
+    [USER_KEY_HEADERS.provider]: credentials.provider,
+    ...credentials.apiKey ? { [USER_KEY_HEADERS.key]: credentials.apiKey } : {},
+    ...credentials.baseUrl ? { [USER_KEY_HEADERS.baseUrl]: credentials.baseUrl } : {}
+  };
+}
 async function remoteChatModel(endpoint, options = {}) {
   const doFetch = options.fetch ?? defaultFetch();
   const root = endpoint.replace(/\/+$/, "");
@@ -286,15 +942,24 @@ async function remoteChatModel(endpoint, options = {}) {
     if (!res.ok) throw new ChatModelError("remote", `HTTP ${res.status}`, res.status);
     info = await res.json();
   }
-  const { id, label, models } = info;
+  const { id, label, models, providers } = info;
+  const headers = (extra) => ({ ...extra, ...options.headers, ...userKeyHeaders(options.credentials?.()) });
   return {
     id,
     label,
+    info,
     ...models ? { models } : {},
+    ...providers ? { providers } : {},
+    async listModels(opts = {}) {
+      const res = await doFetch(`${root}/models`, { headers: headers({ Accept: "application/json" }), ...opts.signal ? { signal: opts.signal } : {} });
+      const body = await res.json().catch(() => null);
+      if (!res.ok) throw new ChatModelError(id, body?.error ?? `HTTP ${res.status}`, res.status);
+      return body?.models ?? [];
+    },
     async complete(request, opts = {}) {
       const res = await doFetch(`${root}/chat`, {
         method: "POST",
-        headers: { "Content-Type": "application/json", Accept: "application/x-ndjson", ...options.headers },
+        headers: headers({ "Content-Type": "application/json", Accept: "application/x-ndjson" }),
         body: JSON.stringify({ request }),
         ...opts.signal ? { signal: opts.signal } : {}
       });
@@ -498,7 +1163,7 @@ function toolsFromDefinitions(definitions, run, options = {}) {
     return defineTool({
       name,
       description: def.function?.description ?? def.description ?? "",
-      inputSchema: def.function?.parameters ?? def.input_schema ?? { type: "object", properties: {} },
+      inputSchema: def.function?.parameters ?? def.input_schema ?? def.parametersJsonSchema ?? { type: "object", properties: {} },
       async run(input, ctx) {
         const out = await run(name, input, ctx);
         if (!out.ok) return { ok: false, error: out.error ?? "failed" };