@jambonz/llm 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  assertValidRequest: () => assertValidRequest,
+  createLlm: () => createLlm,
+  getAdapterFactory: () => getAdapterFactory,
+  getManifest: () => getManifest,
+  listVendors: () => listVendors,
+  normalizeAuth: () => normalizeAuth,
+  registerAdapter: () => registerAdapter,
+  replaceAdapter: () => replaceAdapter,
+  unregisterAdapter: () => unregisterAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerAdapter(factory) {
+  if (registry.has(factory.vendor)) {
+    throw new Error(
+      `Adapter already registered for vendor '${factory.vendor}'. Use replaceAdapter() if you intended to override.`
+    );
+  }
+  if (factory.vendor !== factory.manifest.vendor) {
+    throw new Error(
+      `Adapter factory vendor '${factory.vendor}' does not match manifest.vendor '${factory.manifest.vendor}'.`
+    );
+  }
+  registry.set(factory.vendor, factory);
+}
+function replaceAdapter(factory) {
+  registry.set(factory.vendor, factory);
+}
+function unregisterAdapter(vendor) {
+  registry.delete(vendor);
+}
+function getAdapterFactory(vendor) {
+  const factory = registry.get(vendor);
+  if (!factory) {
+    const known = Array.from(registry.keys()).sort().join(", ") || "(none)";
+    throw new Error(
+      `Unknown vendor '${vendor}'. Registered vendors: ${known}`
+    );
+  }
+  return factory;
+}
+function listVendors() {
+  return Array.from(registry.keys()).sort();
+}
+function getManifest() {
+  const vendors = Array.from(registry.values()).map((f) => f.manifest).sort((a, b) => a.vendor.localeCompare(b.vendor));
+  return { vendors };
+}
+
+// src/adapters/openai/adapter.ts
+var import_openai = __toESM(require("openai"), 1);
+
+// src/validate.ts
+function assertValidRequest(req) {
+  if (!req || typeof req !== "object") {
+    throw new Error("PromptRequest must be an object");
+  }
+  if (typeof req.model !== "string" || req.model.length === 0) {
+    throw new Error("PromptRequest.model must be a non-empty string");
+  }
+  if (!Array.isArray(req.messages) || req.messages.length === 0) {
+    throw new Error("PromptRequest.messages must be a non-empty array");
+  }
+  if (req.messages.some((m) => m.role === "system")) {
+    throw new Error(
+      "PromptRequest.messages must not contain role: 'system'. Pass the system prompt via PromptRequest.system instead."
+    );
+  }
+}
+
+// src/adapters/openai/_streaming.ts
+async function* streamFromOpenAI(client, req, options) {
+  assertValidRequest(req);
+  if (req.signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  const capabilities = capabilitiesFor(req.model, options.knownModels);
+  const useTools = req.tools && req.tools.length > 0 && capabilities.tools;
+  const messages = buildWireMessages(req);
+  const tools = useTools ? formatTools(req.tools) : void 0;
+  const body = {
+    model: req.model,
+    messages,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (tools) {
+    body.tools = tools;
+    body.tool_choice = "auto";
+  }
+  if (req.temperature !== void 0) body.temperature = req.temperature;
+  if (req.maxTokens !== void 0) body.max_tokens = req.maxTokens;
+  let stream;
+  try {
+    stream = await client.chat.completions.create(body, { signal: req.signal });
+  } catch (err) {
+    if (isAbortError(err)) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    throw err;
+  }
+  const pending = {};
+  const startedIds = /* @__PURE__ */ new Set();
+  const toolCallsEmitted = /* @__PURE__ */ new Set();
+  let usage;
+  let finalFinishReason = null;
+  let finalRawReason;
+  try {
+    for await (const chunk of stream) {
+      if (req.signal?.aborted) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      if (chunk.usage) {
+        usage = {
+          ...chunk.usage.prompt_tokens !== void 0 ? { inputTokens: chunk.usage.prompt_tokens } : {},
+          ...chunk.usage.completion_tokens !== void 0 ? { outputTokens: chunk.usage.completion_tokens } : {},
+          ...chunk.usage.total_tokens !== void 0 ? { totalTokens: chunk.usage.total_tokens } : {}
+        };
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      const finishReason = choice.finish_reason;
+      if (delta?.content) {
+        yield { type: "token", text: delta.content };
+      }
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!pending[idx]) {
+            pending[idx] = { id: "", name: "", arguments: "" };
+          }
+          if (tc.id) pending[idx].id += tc.id;
+          if (tc.function?.name) pending[idx].name += tc.function.name;
+          if (tc.function?.arguments) pending[idx].arguments += tc.function.arguments;
+          if (pending[idx].id && pending[idx].name && !startedIds.has(pending[idx].id)) {
+            startedIds.add(pending[idx].id);
+            yield {
+              type: "toolCallStart",
+              id: pending[idx].id,
+              name: pending[idx].name
+            };
+          }
+        }
+      }
+      if (finishReason === "tool_calls") {
+        if (req.signal?.aborted) {
+          yield { type: "end", finishReason: "aborted" };
+          return;
+        }
+        for (const tc of Object.values(pending)) {
+          if (!tc.id || !tc.name) continue;
+          if (toolCallsEmitted.has(tc.id)) continue;
+          toolCallsEmitted.add(tc.id);
+          let args = {};
+          try {
+            args = tc.arguments ? JSON.parse(tc.arguments) : {};
+          } catch {
+            args = {};
+          }
+          yield {
+            type: "toolCall",
+            id: tc.id,
+            name: tc.name,
+            arguments: args
+          };
+        }
+        finalFinishReason = "tool";
+        finalRawReason = finishReason;
+      } else if (finishReason) {
+        finalFinishReason = mapFinishReason(finishReason);
+        finalRawReason = finishReason;
+      }
+    }
+  } catch (err) {
+    if (isAbortError(err)) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    throw err;
+  }
+  const endEvent = {
+    type: "end",
+    finishReason: finalFinishReason ?? "stop",
+    ...usage ? { usage } : {},
+    ...finalRawReason ? { rawReason: finalRawReason } : {}
+  };
+  yield endEvent;
+}
+function appendOpenAIToolResult(history, toolCallId, result) {
+  const content = typeof result === "string" ? result : JSON.stringify(result);
+  const wireMessage = {
+    role: "tool",
+    tool_call_id: toolCallId,
+    content
+  };
+  return [
+    ...history,
+    {
+      role: "tool",
+      content,
+      vendorRaw: wireMessage
+    }
+  ];
+}
+async function listOpenAICompatibleModels(client, knownModels) {
+  const result = await client.models.list();
+  const out = [];
+  for (const m of result.data) {
+    const known = knownModels.find((k) => k.id === m.id);
+    if (known) {
+      out.push(known);
+    } else {
+      out.push({
+        id: m.id,
+        capabilities: defaultCapabilitiesForUnknown(m.id)
+      });
+    }
+  }
+  return out;
+}
+function buildWireMessages(req) {
+  const out = [];
+  if (req.system) {
+    out.push({ role: "system", content: req.system });
+  }
+  for (const msg of req.messages) {
+    if (msg.vendorRaw && typeof msg.vendorRaw === "object") {
+      out.push(msg.vendorRaw);
+    } else {
+      out.push({ role: msg.role, content: msg.content });
+    }
+  }
+  return out;
+}
+function formatTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description ?? "",
+      parameters: t.parameters ?? { type: "object", properties: {} }
+    }
+  }));
+}
+function capabilitiesFor(modelId, knownModels) {
+  const known = knownModels.find((k) => k.id === modelId);
+  if (known) return known.capabilities;
+  return defaultCapabilitiesForUnknown(modelId);
+}
+function defaultCapabilitiesForUnknown(modelId) {
+  const isReasoning = /^o[13]([-/]|$)/i.test(modelId);
+  if (isReasoning) {
+    return {
+      streaming: false,
+      tools: false,
+      vision: false,
+      systemPrompt: false
+    };
+  }
+  return {
+    streaming: true,
+    tools: true,
+    vision: false,
+    systemPrompt: true
+  };
+}
+function mapFinishReason(r) {
+  switch (r) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool";
+    case "function_call":
+      return "tool";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "filtered";
+    default:
+      return "stop";
+  }
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "APIUserAbortError" || e.name === "AbortError" || e.code === "ABORT_ERR" || typeof e.message === "string" && /aborted/i.test(e.message);
+}
+
+// src/adapters/openai/manifest.ts
+var OPENAI_KNOWN_MODELS = [
+  {
+    id: "gpt-4o",
+    displayName: "GPT-4o",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "gpt-4o-mini",
+    displayName: "GPT-4o mini",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "gpt-4-turbo",
+    displayName: "GPT-4 Turbo",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "gpt-3.5-turbo",
+    displayName: "GPT-3.5 Turbo",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 16385
+    }
+  },
+  {
+    id: "o1-preview",
+    displayName: "o1 preview (reasoning)",
+    capabilities: {
+      streaming: false,
+      tools: false,
+      vision: false,
+      systemPrompt: false,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "o1-mini",
+    displayName: "o1 mini (reasoning)",
+    capabilities: {
+      streaming: false,
+      tools: false,
+      vision: false,
+      systemPrompt: false,
+      maxContextTokens: 128e3
+    }
+  }
+];
+var openAIManifest = {
+  vendor: "openai",
+  displayName: "OpenAI",
+  authKinds: [
+    {
+      kind: "apiKey",
+      displayName: "API Key",
+      fields: [
+        {
+          name: "apiKey",
+          label: "API Key",
+          type: "password",
+          required: true,
+          help: "Get an API key from https://platform.openai.com/api-keys"
+        },
+        {
+          name: "baseURL",
+          label: "Base URL",
+          type: "url",
+          required: false,
+          default: "https://api.openai.com/v1",
+          help: "Override for OpenAI-compatible endpoints (LM Studio, Ollama, vLLM, proxies)."
+        }
+      ]
+    }
+  ],
+  knownModels: OPENAI_KNOWN_MODELS,
+  supportsModelListing: true,
+  docsUrl: "https://platform.openai.com/docs/api-reference"
+};
+
+// src/adapters/openai/adapter.ts
+var OpenAIAdapter = class {
+  vendor = openAIManifest.vendor;
+  acceptedAuth = ["apiKey"];
+  client;
+  init(auth, client) {
+    if (!auth.apiKey) {
+      throw new Error("OpenAIAdapter: apiKey is required");
+    }
+    this.client = new import_openai.default({
+      apiKey: auth.apiKey,
+      ...auth.baseURL ? { baseURL: auth.baseURL } : {},
+      ...client?.timeout !== void 0 ? { timeout: client.timeout } : {},
+      ...client?.maxRetries !== void 0 ? { maxRetries: client.maxRetries } : {}
+    });
+  }
+  stream(req) {
+    return streamFromOpenAI(this.ensureClient(), req, {
+      knownModels: openAIManifest.knownModels
+    });
+  }
+  appendToolResult(history, toolCallId, result) {
+    return appendOpenAIToolResult(history, toolCallId, result);
+  }
+  async listAvailableModels() {
+    return listOpenAICompatibleModels(this.ensureClient(), openAIManifest.knownModels);
+  }
+  async warmup() {
+    const client = this.ensureClient();
+    await client.models.list().catch(() => void 0);
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error("OpenAIAdapter: init() must be called before stream()/listAvailableModels()");
+    }
+    return this.client;
+  }
+};
+
+// src/adapters/openai/factory.ts
+var openAIFactory = {
+  vendor: openAIManifest.vendor,
+  manifest: openAIManifest,
+  create: () => new OpenAIAdapter()
+};
+var deepseekManifest = {
+  vendor: "deepseek",
+  displayName: "DeepSeek",
+  authKinds: [
+    {
+      kind: "apiKey",
+      displayName: "API Key",
+      fields: [
+        {
+          name: "apiKey",
+          label: "API Key",
+          type: "password",
+          required: true,
+          help: "Get an API key from https://platform.deepseek.com/api_keys"
+        },
+        {
+          name: "baseURL",
+          label: "Base URL",
+          type: "url",
+          required: false,
+          default: "https://api.deepseek.com/v1",
+          help: "Override for self-hosted DeepSeek or proxy endpoints."
+        }
+      ]
+    }
+  ],
+  knownModels: [
+    {
+      id: "deepseek-chat",
+      displayName: "DeepSeek Chat",
+      capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        systemPrompt: true,
+        maxContextTokens: 64e3
+      }
+    },
+    {
+      id: "deepseek-reasoner",
+      displayName: "DeepSeek Reasoner",
+      capabilities: {
+        streaming: true,
+        tools: false,
+        vision: false,
+        systemPrompt: true,
+        maxContextTokens: 64e3
+      }
+    }
+  ],
+  supportsModelListing: true,
+  docsUrl: "https://api-docs.deepseek.com/"
+};
+var DeepSeekAdapter = class extends OpenAIAdapter {
+  vendor = deepseekManifest.vendor;
+  init(auth, client) {
+    super.init(
+      {
+        ...auth,
+        baseURL: auth.baseURL ?? "https://api.deepseek.com/v1"
+      },
+      client
+    );
+  }
+};
+var deepseekFactory = {
+  vendor: deepseekManifest.vendor,
+  manifest: deepseekManifest,
+  create: () => new DeepSeekAdapter()
+};
+
+// src/adapters/anthropic/adapter.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+
+// src/adapters/anthropic/manifest.ts
+var ANTHROPIC_KNOWN_MODELS = [
+  {
+    id: "claude-opus-4-7",
+    displayName: "Claude Opus 4.7",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "claude-sonnet-4-6",
+    displayName: "Claude Sonnet 4.6",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "claude-haiku-4-5-20251001",
+    displayName: "Claude Haiku 4.5",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "claude-3-7-sonnet-20250219",
+    displayName: "Claude 3.7 Sonnet",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "claude-3-5-sonnet-20241022",
+    displayName: "Claude 3.5 Sonnet",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "claude-3-5-haiku-20241022",
+    displayName: "Claude 3.5 Haiku",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  }
+];
+var anthropicManifest = {
+  vendor: "anthropic",
+  displayName: "Anthropic Claude",
+  authKinds: [
+    {
+      kind: "apiKey",
+      displayName: "API Key",
+      fields: [
+        {
+          name: "apiKey",
+          label: "API Key",
+          type: "password",
+          required: true,
+          help: "Get an API key from https://console.anthropic.com/settings/keys"
+        },
+        {
+          name: "baseURL",
+          label: "Base URL",
+          type: "url",
+          required: false,
+          default: "https://api.anthropic.com",
+          help: "Override for proxies or enterprise deployments."
+        }
+      ]
+    }
+  ],
+  knownModels: ANTHROPIC_KNOWN_MODELS,
+  supportsModelListing: true,
+  docsUrl: "https://docs.anthropic.com/en/api/overview"
+};
+
+// src/adapters/anthropic/adapter.ts
+var AnthropicAdapter = class {
+  vendor = anthropicManifest.vendor;
+  acceptedAuth = ["apiKey"];
+  client;
+  init(auth, client) {
+    if (!auth.apiKey) {
+      throw new Error("AnthropicAdapter: apiKey is required");
+    }
+    this.client = new import_sdk.default({
+      apiKey: auth.apiKey,
+      ...auth.baseURL ? { baseURL: auth.baseURL } : {},
+      ...client?.timeout !== void 0 ? { timeout: client.timeout } : {},
+      ...client?.maxRetries !== void 0 ? { maxRetries: client.maxRetries } : {}
+    });
+  }
+  async *stream(req) {
+    assertValidRequest(req);
+    const client = this.ensureClient();
+    if (req.signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    const messages = buildWireMessages2(req);
+    const tools = req.tools && req.tools.length > 0 ? formatTools2(req.tools) : void 0;
+    const body = {
+      model: req.model,
+      messages,
+      max_tokens: req.maxTokens ?? 4096,
+      stream: true
+    };
+    if (req.system) body.system = req.system;
+    if (tools) body.tools = tools;
+    if (req.temperature !== void 0) body.temperature = req.temperature;
+    let stream;
+    try {
+      stream = await client.messages.create(
+        body,
+        { signal: req.signal }
+      );
+    } catch (err) {
+      if (isAbortError2(err)) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      throw err;
+    }
+    let currentToolUse = null;
+    const completedToolCalls = [];
+    let stopReason;
+    let inputTokens;
+    let outputTokens;
+    try {
+      for await (const event of stream) {
+        if (req.signal?.aborted) {
+          yield { type: "end", finishReason: "aborted" };
+          return;
+        }
+        switch (event.type) {
+          case "message_start":
+            inputTokens = event.message?.usage?.input_tokens;
+            break;
+          case "content_block_start": {
+            const block = event.content_block;
+            if (block?.type === "tool_use") {
+              currentToolUse = {
+                id: block.id ?? "",
+                name: block.name ?? "",
+                argumentsText: ""
+              };
+              if (currentToolUse.id && currentToolUse.name) {
+                yield {
+                  type: "toolCallStart",
+                  id: currentToolUse.id,
+                  name: currentToolUse.name
+                };
+              }
+            }
+            break;
+          }
+          case "content_block_delta": {
+            const delta = event.delta;
+            if (delta?.type === "text_delta" && delta.text) {
+              yield { type: "token", text: delta.text };
+            } else if (delta?.type === "input_json_delta" && currentToolUse && delta.partial_json) {
+              currentToolUse.argumentsText += delta.partial_json;
+            }
+            break;
+          }
+          case "content_block_stop":
+            if (currentToolUse && currentToolUse.id && currentToolUse.name) {
+              let parsed = {};
+              try {
+                parsed = currentToolUse.argumentsText ? JSON.parse(currentToolUse.argumentsText) : {};
+              } catch {
+                parsed = {};
+              }
+              completedToolCalls.push({
+                id: currentToolUse.id,
+                name: currentToolUse.name,
+                arguments: parsed
+              });
+            }
+            currentToolUse = null;
+            break;
+          case "message_delta":
+            if (event.delta?.stop_reason) {
+              stopReason = event.delta.stop_reason;
+            }
+            if (event.usage?.output_tokens !== void 0) {
+              outputTokens = event.usage.output_tokens;
+            }
+            break;
+          case "message_stop":
+            break;
+          default:
+            break;
+        }
+      }
+    } catch (err) {
+      if (isAbortError2(err)) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      throw err;
+    }
+    if (req.signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    for (const tc of completedToolCalls) {
+      yield {
+        type: "toolCall",
+        id: tc.id,
+        name: tc.name,
+        arguments: tc.arguments
+      };
+    }
+    const finishReason = mapStopReason(stopReason, completedToolCalls.length > 0);
+    const usage = inputTokens !== void 0 || outputTokens !== void 0 ? {
+      ...inputTokens !== void 0 ? { inputTokens } : {},
+      ...outputTokens !== void 0 ? { outputTokens } : {},
+      ...inputTokens !== void 0 && outputTokens !== void 0 ? { totalTokens: inputTokens + outputTokens } : {}
+    } : void 0;
+    const endEvent = {
+      type: "end",
+      finishReason,
+      ...usage ? { usage } : {},
+      ...stopReason ? { rawReason: stopReason } : {}
+    };
+    yield endEvent;
+  }
+  appendToolResult(history, toolCallId, result) {
+    const content = typeof result === "string" ? result : JSON.stringify(result);
+    const wireMessage = {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: toolCallId,
+          content
+        }
+      ]
+    };
+    return [
+      ...history,
+      {
+        role: "tool",
+        content,
+        vendorRaw: wireMessage
+      }
+    ];
+  }
+  async listAvailableModels() {
+    const client = this.ensureClient();
+    const result = await client.models.list();
+    const models = [];
+    for (const m of result.data) {
+      const known = anthropicManifest.knownModels.find((k) => k.id === m.id);
+      if (known) {
+        models.push(known);
+      } else {
+        models.push({
+          id: m.id,
+          displayName: m.display_name ?? void 0,
+          capabilities: defaultClaudeCapabilities()
+        });
+      }
+    }
+    return models;
+  }
+  async warmup() {
+    const client = this.ensureClient();
+    await client.models.list().catch(() => void 0);
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error("AnthropicAdapter: init() must be called before stream()/listAvailableModels()");
+    }
+    return this.client;
+  }
+};
+function buildWireMessages2(req) {
+  const out = [];
+  for (const msg of req.messages) {
+    if (msg.vendorRaw && typeof msg.vendorRaw === "object") {
+      out.push(msg.vendorRaw);
+    } else {
+      out.push({ role: msg.role, content: msg.content });
+    }
+  }
+  return out;
+}
+function formatTools2(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    input_schema: t.parameters ?? { type: "object", properties: {} }
+  }));
+}
+function mapStopReason(r, hadToolCalls) {
+  if (hadToolCalls) return "tool";
+  switch (r) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool";
+    case "max_tokens":
+      return "length";
+    default:
+      return "stop";
+  }
+}
+function defaultClaudeCapabilities() {
+  return {
+    streaming: true,
+    tools: true,
+    vision: true,
+    systemPrompt: true
+  };
+}
+function isAbortError2(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "APIUserAbortError" || e.name === "AbortError" || e.code === "ABORT_ERR" || typeof e.message === "string" && /aborted/i.test(e.message);
+}
+
+// src/adapters/anthropic/factory.ts
+var anthropicFactory = {
+  vendor: anthropicManifest.vendor,
+  manifest: anthropicManifest,
+  create: () => new AnthropicAdapter()
+};
+
+// src/adapters/google/adapter.ts
+var import_genai = require("@google/genai");
+
+// src/adapters/google/_streaming.ts
+async function* streamFromGemini(client, req) {
+  assertValidRequest(req);
+  if (req.signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  const contents = buildWireContents(req);
+  const tools = req.tools && req.tools.length > 0 ? formatTools3(req.tools) : void 0;
+  const config = {};
+  if (req.system) {
+    config.systemInstruction = { parts: [{ text: req.system }] };
+  }
+  if (tools) config.tools = tools;
+  if (req.temperature !== void 0) config.temperature = req.temperature;
+  if (req.maxTokens !== void 0) config.maxOutputTokens = req.maxTokens;
+  if (req.signal) config.abortSignal = req.signal;
+  let stream;
+  try {
+    stream = await client.models.generateContentStream({
+      model: req.model,
+      contents,
+      config
+    });
+  } catch (err) {
+    if (isAbortError3(err)) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    throw err;
+  }
+  const toolCallCounter = /* @__PURE__ */ new Map();
+  const completedToolCalls = [];
+  let stopReason;
+  let inputTokens;
+  let outputTokens;
+  let totalTokens;
+  try {
+    for await (const chunk of stream) {
+      if (req.signal?.aborted) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      const usage2 = chunk.usageMetadata;
+      if (usage2) {
+        if (usage2.promptTokenCount !== void 0) inputTokens = usage2.promptTokenCount;
+        if (usage2.candidatesTokenCount !== void 0) outputTokens = usage2.candidatesTokenCount;
+        if (usage2.totalTokenCount !== void 0) totalTokens = usage2.totalTokenCount;
+      }
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts) {
+        if (candidate?.finishReason) stopReason = candidate.finishReason;
+        continue;
+      }
+      for (const part of candidate.content.parts) {
+        if (typeof part.text === "string" && part.text.length > 0) {
+          yield { type: "token", text: part.text };
+        }
+        if (part.functionCall) {
+          const name = part.functionCall.name ?? "";
+          if (!name) continue;
+          const count = toolCallCounter.get(name) ?? 0;
+          toolCallCounter.set(name, count + 1);
+          const id = count === 0 ? name : `${name}#${count}`;
+          yield { type: "toolCallStart", id, name };
+          completedToolCalls.push({
+            id,
+            name,
+            arguments: part.functionCall.args ?? {}
+          });
+        }
+      }
+      if (candidate.finishReason) {
+        stopReason = candidate.finishReason;
+      }
+    }
+  } catch (err) {
+    if (isAbortError3(err)) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    throw err;
+  }
+  if (req.signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  for (const tc of completedToolCalls) {
+    yield {
+      type: "toolCall",
+      id: tc.id,
+      name: tc.name,
+      arguments: tc.arguments
+    };
+  }
+  const finishReason = mapFinishReason2(stopReason, completedToolCalls.length > 0);
+  const usage = inputTokens !== void 0 || outputTokens !== void 0 || totalTokens !== void 0 ? {
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  } : void 0;
+  const endEvent = {
+    type: "end",
+    finishReason,
+    ...usage ? { usage } : {},
+    ...stopReason ? { rawReason: stopReason } : {}
+  };
+  yield endEvent;
+}
+function appendGeminiToolResult(history, toolCallId, result) {
+  const name = parseToolName(toolCallId);
+  const content = typeof result === "string" ? result : JSON.stringify(result);
+  const wireMessage = {
+    role: "user",
+    parts: [
+      {
+        functionResponse: {
+          name,
+          response: { result: content }
+        }
+      }
+    ]
+  };
+  return [
+    ...history,
+    {
+      role: "tool",
+      content,
+      vendorRaw: wireMessage
+    }
+  ];
+}
+async function listGeminiModels(client, knownModels) {
+  const out = [];
+  const pager = await client.models.list();
+  for await (const m of pager) {
+    const id = stripModelPrefix(m.name ?? "");
+    if (!id) continue;
+    const known = knownModels.find((k) => k.id === id);
+    if (known) {
+      out.push(known);
+    } else {
+      out.push({
+        id,
+        displayName: m.displayName ?? void 0,
+        capabilities: defaultGeminiCapabilities()
+      });
+    }
+  }
+  return out;
+}
+function buildWireContents(req) {
+  const out = [];
+  for (const msg of req.messages) {
+    if (msg.vendorRaw && typeof msg.vendorRaw === "object") {
+      out.push(msg.vendorRaw);
+      continue;
+    }
+    const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    out.push({
+      role: toGeminiRole(msg.role),
+      parts: [{ text }]
+    });
+  }
+  return out;
+}
+function toGeminiRole(role) {
+  return role === "assistant" || role === "model" ? "model" : "user";
+}
+function formatTools3(tools) {
+  return [
+    {
+      functionDeclarations: tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }))
+    }
+  ];
+}
+function mapFinishReason2(r, hadToolCalls) {
+  if (hadToolCalls && (r === "STOP" || r === "TOOL_CALLS" || !r)) return "tool";
+  switch (r) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+      return "filtered";
+    case "TOOL_CALLS":
+      return "tool";
+    default:
+      return "stop";
+  }
+}
+function parseToolName(id) {
+  const hashIdx = id.lastIndexOf("#");
+  if (hashIdx === -1) return id;
+  const suffix = id.slice(hashIdx + 1);
+  if (/^\d+$/.test(suffix)) return id.slice(0, hashIdx);
+  return id;
+}
+function stripModelPrefix(name) {
+  return name.startsWith("models/") ? name.slice("models/".length) : name;
+}
+function defaultGeminiCapabilities() {
+  return {
+    streaming: true,
+    tools: true,
+    vision: true,
+    systemPrompt: true
+  };
+}
+function isAbortError3(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "APIUserAbortError" || e.name === "AbortError" || e.code === "ABORT_ERR" || typeof e.message === "string" && /aborted/i.test(e.message);
+}
+
+// src/adapters/google/manifest.ts
+var GOOGLE_KNOWN_MODELS = [
+  {
+    id: "gemini-2.5-pro",
+    displayName: "Gemini 2.5 Pro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-2.5-flash",
+    displayName: "Gemini 2.5 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-2.0-flash",
+    displayName: "Gemini 2.0 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-2.0-flash-lite",
+    displayName: "Gemini 2.0 Flash Lite",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-1.5-pro",
+    displayName: "Gemini 1.5 Pro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e6
+    }
+  },
+  {
+    id: "gemini-1.5-flash",
+    displayName: "Gemini 1.5 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  }
+];
+var googleManifest = {
+  vendor: "google",
+  displayName: "Google Gemini",
+  authKinds: [
+    {
+      kind: "googleApiKey",
+      displayName: "API Key",
+      fields: [
+        {
+          name: "apiKey",
+          label: "API Key",
+          type: "password",
+          required: true,
+          help: "Get an API key from https://aistudio.google.com/apikey"
+        }
+      ]
+    }
+  ],
+  knownModels: GOOGLE_KNOWN_MODELS,
+  supportsModelListing: true,
+  docsUrl: "https://ai.google.dev/gemini-api/docs"
+};
+
+// src/adapters/google/adapter.ts
+var GoogleAdapter = class {
+  vendor = googleManifest.vendor;
+  acceptedAuth = ["googleApiKey"];
+  client;
+  init(auth, _client) {
+    if (auth.kind !== "googleApiKey") {
+      throw new Error(
+        `GoogleAdapter: unsupported auth kind '${auth.kind}'`
+      );
+    }
+    if (!auth.apiKey) {
+      throw new Error("GoogleAdapter: apiKey is required");
+    }
+    this.client = new import_genai.GoogleGenAI({ apiKey: auth.apiKey });
+  }
+  stream(req) {
+    return streamFromGemini(this.ensureClient(), req);
+  }
+  appendToolResult(history, toolCallId, result) {
+    return appendGeminiToolResult(history, toolCallId, result);
+  }
+  async listAvailableModels() {
+    return listGeminiModels(this.ensureClient(), googleManifest.knownModels);
+  }
+  async warmup() {
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error("GoogleAdapter: init() must be called before stream()/listAvailableModels()");
+    }
+    return this.client;
+  }
+};
+
+// src/adapters/google/factory.ts
+var googleFactory = {
+  vendor: googleManifest.vendor,
+  manifest: googleManifest,
+  create: () => new GoogleAdapter()
+};
+
+// src/adapters/vertex-gemini/adapter.ts
+var import_genai2 = require("@google/genai");
+
+// src/adapters/vertex-gemini/manifest.ts
+var VERTEX_GEMINI_KNOWN_MODELS = [
+  {
+    id: "gemini-2.5-pro",
+    displayName: "Gemini 2.5 Pro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-2.5-flash",
+    displayName: "Gemini 2.5 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-2.0-flash",
+    displayName: "Gemini 2.0 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
+  {
+    id: "gemini-1.5-pro",
+    displayName: "Gemini 1.5 Pro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e6
+    }
+  },
+  {
+    id: "gemini-1.5-flash",
+    displayName: "Gemini 1.5 Flash",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  }
+];
+var vertexGeminiManifest = {
+  vendor: "vertex-gemini",
+  displayName: "Vertex AI \u2014 Gemini",
+  authKinds: [
+    {
+      kind: "vertexServiceAccount",
+      displayName: "Service Account JSON",
+      fields: [
+        {
+          name: "credentials",
+          label: "Service Account Key (JSON)",
+          type: "json-file",
+          required: true,
+          help: "Upload the service account key JSON from Google Cloud Console."
+        },
+        {
+          name: "projectId",
+          label: "Project ID",
+          type: "text",
+          required: true,
+          help: "GCP project that hosts the Vertex AI deployment."
+        },
+        {
+          name: "location",
+          label: "Region",
+          type: "select",
+          required: true,
+          default: "us-central1",
+          options: [
+            { value: "us-central1", label: "us-central1" },
+            { value: "us-east1", label: "us-east1" },
+            { value: "us-east4", label: "us-east4" },
+            { value: "us-west1", label: "us-west1" },
+            { value: "us-west4", label: "us-west4" },
+            { value: "europe-west1", label: "europe-west1" },
+            { value: "europe-west2", label: "europe-west2" },
+            { value: "europe-west3", label: "europe-west3" },
+            { value: "europe-west4", label: "europe-west4" },
+            { value: "asia-east1", label: "asia-east1" },
+            { value: "asia-northeast1", label: "asia-northeast1" },
+            { value: "asia-southeast1", label: "asia-southeast1" }
+          ]
+        }
+      ]
+    }
+  ],
+  knownModels: VERTEX_GEMINI_KNOWN_MODELS,
+  supportsModelListing: true,
+  docsUrl: "https://cloud.google.com/vertex-ai/generative-ai/docs"
+};
+
+// src/adapters/vertex-gemini/adapter.ts
+var VertexGeminiAdapter = class {
+  vendor = vertexGeminiManifest.vendor;
+  acceptedAuth = ["vertexServiceAccount"];
+  client;
+  init(auth, _client) {
+    if (auth.kind !== "vertexServiceAccount") {
+      throw new Error(
+        `VertexGeminiAdapter: unsupported auth kind '${auth.kind}'`
+      );
+    }
+    if (!auth.credentials) {
+      throw new Error("VertexGeminiAdapter: service-account credentials are required");
+    }
+    if (!auth.projectId) {
+      throw new Error("VertexGeminiAdapter: projectId is required");
+    }
+    if (!auth.location) {
+      throw new Error("VertexGeminiAdapter: location is required");
+    }
+    this.client = new import_genai2.GoogleGenAI({
+      vertexai: true,
+      project: auth.projectId,
+      location: auth.location,
+      googleAuthOptions: {
+        credentials: auth.credentials
+      }
+    });
+  }
+  stream(req) {
+    return streamFromGemini(this.ensureClient(), req);
+  }
+  appendToolResult(history, toolCallId, result) {
+    return appendGeminiToolResult(history, toolCallId, result);
+  }
+  async listAvailableModels() {
+    return listGeminiModels(this.ensureClient(), vertexGeminiManifest.knownModels);
+  }
+  async warmup() {
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error(
+        "VertexGeminiAdapter: init() must be called before stream()/listAvailableModels()"
+      );
+    }
+    return this.client;
+  }
+};
+
+// src/adapters/vertex-gemini/factory.ts
+var vertexGeminiFactory = {
+  vendor: vertexGeminiManifest.vendor,
+  manifest: vertexGeminiManifest,
+  create: () => new VertexGeminiAdapter()
+};
+
+// src/adapters/vertex-openai/adapter.ts
+var import_openai2 = __toESM(require("openai"), 1);
+var import_google_auth_library = require("google-auth-library");
+
+// src/adapters/vertex-openai/manifest.ts
+var VERTEX_OPENAI_KNOWN_MODELS = [
+  {
+    id: "mistral-large",
+    displayName: "Mistral Large (on Vertex)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "mistral-small",
+    displayName: "Mistral Small (on Vertex)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 32e3
+    }
+  },
+  {
+    id: "meta/llama-3.3-70b-instruct-maas",
+    displayName: "Llama 3.3 70B Instruct (on Vertex)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "meta/llama-3.1-405b-instruct-maas",
+    displayName: "Llama 3.1 405B Instruct (on Vertex)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  }
+];
+var vertexOpenAIManifest = {
+  vendor: "vertex-openai",
+  displayName: "Vertex AI \u2014 OpenAI-compatible",
+  authKinds: [
+    {
+      kind: "vertexServiceAccount",
+      displayName: "Service Account JSON",
+      fields: [
+        {
+          name: "credentials",
+          label: "Service Account Key (JSON)",
+          type: "json-file",
+          required: true,
+          help: "Upload the service account key JSON from Google Cloud Console."
+        },
+        {
+          name: "projectId",
+          label: "Project ID",
+          type: "text",
+          required: true,
+          help: "GCP project that hosts the Vertex AI deployment."
+        },
+        {
+          name: "location",
+          label: "Region",
+          type: "select",
+          required: true,
+          default: "us-central1",
+          options: [
+            { value: "us-central1", label: "us-central1" },
+            { value: "us-east4", label: "us-east4" },
+            { value: "europe-west1", label: "europe-west1" },
+            { value: "europe-west4", label: "europe-west4" },
+            { value: "asia-southeast1", label: "asia-southeast1" }
+          ]
+        }
+      ]
+    }
+  ],
+  knownModels: VERTEX_OPENAI_KNOWN_MODELS,
+  // The OpenAI-compatible endpoint on Vertex does not expose a /models list.
+  supportsModelListing: false,
+  docsUrl: "https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-openai"
+};
+
+// src/adapters/vertex-openai/adapter.ts
+var VertexOpenAIAdapter = class {
+  vendor = vertexOpenAIManifest.vendor;
+  acceptedAuth = ["vertexServiceAccount"];
+  client;
+  init(auth, client) {
+    if (auth.kind !== "vertexServiceAccount") {
+      throw new Error(
+        `VertexOpenAIAdapter: unsupported auth kind '${auth.kind}'`
+      );
+    }
+    if (!auth.credentials) {
+      throw new Error("VertexOpenAIAdapter: service-account credentials are required");
+    }
+    if (!auth.projectId) {
+      throw new Error("VertexOpenAIAdapter: projectId is required");
+    }
+    if (!auth.location) {
+      throw new Error("VertexOpenAIAdapter: location is required");
+    }
+    const baseURL = `https://${auth.location}-aiplatform.googleapis.com/v1/projects/${auth.projectId}/locations/${auth.location}/endpoints/openapi`;
+    const googleAuth = new import_google_auth_library.GoogleAuth({
+      credentials: auth.credentials,
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"]
+    });
+    const authedFetch = async (input, init) => {
+      const googleClient = await googleAuth.getClient();
+      const token = await googleClient.getAccessToken();
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${token.token ?? ""}`);
+      return fetch(input, { ...init, headers });
+    };
+    this.client = new import_openai2.default({
+      apiKey: "vertex-ai",
+      baseURL,
+      fetch: authedFetch,
+      ...client?.timeout !== void 0 ? { timeout: client.timeout } : {},
+      ...client?.maxRetries !== void 0 ? { maxRetries: client.maxRetries } : {}
+    });
+  }
+  stream(req) {
+    return streamFromOpenAI(this.ensureClient(), req, {
+      knownModels: vertexOpenAIManifest.knownModels
+    });
+  }
+  appendToolResult(history, toolCallId, result) {
+    return appendOpenAIToolResult(history, toolCallId, result);
+  }
+  async listAvailableModels() {
+    return [...vertexOpenAIManifest.knownModels];
+  }
+  async warmup() {
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error(
+        "VertexOpenAIAdapter: init() must be called before stream()/listAvailableModels()"
+      );
+    }
+    return this.client;
+  }
+};
+
+// src/adapters/vertex-openai/factory.ts
+var vertexOpenAIFactory = {
+  vendor: vertexOpenAIManifest.vendor,
+  manifest: vertexOpenAIManifest,
+  create: () => new VertexOpenAIAdapter()
+};
+
+// src/adapters/bedrock/adapter.ts
+var import_client_bedrock_runtime = require("@aws-sdk/client-bedrock-runtime");
+
+// src/adapters/bedrock/manifest.ts
+var BEDROCK_KNOWN_MODELS = [
+  {
+    id: "anthropic.claude-opus-4-v1:0",
+    displayName: "Claude Opus 4 (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "anthropic.claude-sonnet-4-v1:0",
+    displayName: "Claude Sonnet 4 (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "anthropic.claude-3-7-sonnet-20250219-v1:0",
+    displayName: "Claude 3.7 Sonnet (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+    displayName: "Claude 3.5 Sonnet v2 (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "anthropic.claude-3-5-haiku-20241022-v1:0",
+    displayName: "Claude 3.5 Haiku (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 2e5
+    }
+  },
+  {
+    id: "meta.llama3-3-70b-instruct-v1:0",
+    displayName: "Llama 3.3 70B Instruct (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "mistral.mistral-large-2407-v1:0",
+    displayName: "Mistral Large (on Bedrock)",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  },
+  {
+    id: "amazon.nova-pro-v1:0",
+    displayName: "Amazon Nova Pro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 3e5
+    }
+  },
+  {
+    id: "amazon.nova-lite-v1:0",
+    displayName: "Amazon Nova Lite",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 3e5
+    }
+  },
+  {
+    id: "amazon.nova-micro-v1:0",
+    displayName: "Amazon Nova Micro",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: false,
+      systemPrompt: true,
+      maxContextTokens: 128e3
+    }
+  }
+];
+var BEDROCK_REGIONS = [
+  { value: "us-east-1", label: "us-east-1 (N. Virginia)" },
+  { value: "us-east-2", label: "us-east-2 (Ohio)" },
+  { value: "us-west-2", label: "us-west-2 (Oregon)" },
+  { value: "eu-west-1", label: "eu-west-1 (Ireland)" },
+  { value: "eu-west-3", label: "eu-west-3 (Paris)" },
+  { value: "eu-central-1", label: "eu-central-1 (Frankfurt)" },
+  { value: "ap-northeast-1", label: "ap-northeast-1 (Tokyo)" },
+  { value: "ap-south-1", label: "ap-south-1 (Mumbai)" },
+  { value: "ap-southeast-1", label: "ap-southeast-1 (Singapore)" },
+  { value: "ap-southeast-2", label: "ap-southeast-2 (Sydney)" },
+  { value: "ca-central-1", label: "ca-central-1 (Canada)" }
+];
+var bedrockManifest = {
+  vendor: "bedrock",
+  displayName: "AWS Bedrock",
+  authKinds: [
+    {
+      kind: "bedrockApiKey",
+      displayName: "API Key",
+      fields: [
+        {
+          name: "apiKey",
+          label: "API Key",
+          type: "password",
+          required: true,
+          help: "Bedrock API key (bearer token). Create one in the AWS console under Amazon Bedrock \u2192 API keys."
+        },
+        {
+          name: "region",
+          label: "Region",
+          type: "select",
+          required: true,
+          default: "us-east-1",
+          options: BEDROCK_REGIONS
+        }
+      ]
+    },
+    {
+      kind: "bedrockIam",
+      displayName: "IAM Credentials",
+      fields: [
+        {
+          name: "accessKeyId",
+          label: "Access Key ID",
+          type: "text",
+          required: true
+        },
+        {
+          name: "secretAccessKey",
+          label: "Secret Access Key",
+          type: "password",
+          required: true
+        },
+        {
+          name: "sessionToken",
+          label: "Session Token",
+          type: "password",
+          required: false,
+          help: "Only required when using temporary credentials (e.g., STS)."
+        },
+        {
+          name: "region",
+          label: "Region",
+          type: "select",
+          required: true,
+          default: "us-east-1",
+          options: BEDROCK_REGIONS
+        }
+      ]
+    }
+  ],
+  knownModels: BEDROCK_KNOWN_MODELS,
+  // The Bedrock runtime client does not expose a `/models` listing — model
+  // enumeration lives in `@aws-sdk/client-bedrock` (control plane), which we
+  // don't pull in. Return the curated set from the manifest.
+  supportsModelListing: false,
+  docsUrl: "https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html"
+};
+
+// src/adapters/bedrock/adapter.ts
+var BedrockAdapter = class {
+  vendor = bedrockManifest.vendor;
+  acceptedAuth = ["bedrockApiKey", "bedrockIam"];
+  client;
+  init(auth, client) {
+    if (!auth.region) {
+      throw new Error("BedrockAdapter: region is required");
+    }
+    const config = {
+      region: auth.region,
+      ...client?.endpoint ? { endpoint: client.endpoint } : {},
+      ...client?.maxRetries !== void 0 ? { maxAttempts: client.maxRetries + 1 } : {}
+    };
+    if (auth.kind === "bedrockApiKey") {
+      if (!auth.apiKey) {
+        throw new Error("BedrockAdapter: apiKey is required for bedrockApiKey auth");
+      }
+      config.token = { token: auth.apiKey };
+      config.authSchemePreference = ["httpBearerAuth"];
+    } else if (auth.kind === "bedrockIam") {
+      if (!auth.accessKeyId || !auth.secretAccessKey) {
+        throw new Error("BedrockAdapter: accessKeyId and secretAccessKey required for bedrockIam auth");
+      }
+      config.credentials = {
+        accessKeyId: auth.accessKeyId,
+        secretAccessKey: auth.secretAccessKey,
+        ...auth.sessionToken ? { sessionToken: auth.sessionToken } : {}
+      };
+    } else {
+      throw new Error(
+        `BedrockAdapter: unsupported auth kind '${auth.kind}'`
+      );
+    }
+    this.client = new import_client_bedrock_runtime.BedrockRuntimeClient(config);
+  }
+  async *stream(req) {
+    assertValidRequest(req);
+    const client = this.ensureClient();
+    if (req.signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    const messages = buildWireMessages3(req);
+    const tools = req.tools && req.tools.length > 0 ? { tools: formatTools4(req.tools) } : void 0;
+    const inferenceConfig = {};
+    if (req.maxTokens !== void 0) inferenceConfig.maxTokens = req.maxTokens;
+    if (req.temperature !== void 0) inferenceConfig.temperature = req.temperature;
+    const commandInput = {
+      modelId: req.model,
+      messages
+    };
+    if (req.system) commandInput.system = [{ text: req.system }];
+    if (tools) commandInput.toolConfig = tools;
+    if (Object.keys(inferenceConfig).length > 0) {
+      commandInput.inferenceConfig = inferenceConfig;
+    }
+    const command = new import_client_bedrock_runtime.ConverseStreamCommand(
+      commandInput
+    );
+    let response;
+    try {
+      response = await client.send(command, { abortSignal: req.signal });
+    } catch (err) {
+      if (isAbortError4(err)) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      throw err;
+    }
+    if (!response.stream) {
+      yield { type: "end", finishReason: "stop" };
+      return;
+    }
+    let currentToolUse = null;
+    const completedToolCalls = [];
+    let stopReason;
+    let inputTokens;
+    let outputTokens;
+    let totalTokens;
+    try {
+      for await (const event of response.stream) {
+        if (req.signal?.aborted) {
+          yield { type: "end", finishReason: "aborted" };
+          return;
+        }
+        if (event.contentBlockStart) {
+          const start = event.contentBlockStart.start;
+          if (start?.toolUse) {
+            currentToolUse = {
+              id: start.toolUse.toolUseId ?? "",
+              name: start.toolUse.name ?? "",
+              inputText: ""
+            };
+            if (currentToolUse.id && currentToolUse.name) {
+              yield {
+                type: "toolCallStart",
+                id: currentToolUse.id,
+                name: currentToolUse.name
+              };
+            }
+          }
+        } else if (event.contentBlockDelta) {
+          const delta = event.contentBlockDelta.delta;
+          if (delta?.text) {
+            yield { type: "token", text: delta.text };
+          }
+          if (delta?.toolUse && currentToolUse && typeof delta.toolUse.input === "string") {
+            currentToolUse.inputText += delta.toolUse.input;
+          }
+        } else if (event.contentBlockStop) {
+          if (currentToolUse && currentToolUse.id && currentToolUse.name) {
+            let parsed = {};
+            try {
+              parsed = currentToolUse.inputText ? JSON.parse(currentToolUse.inputText) : {};
+            } catch {
+              parsed = {};
+            }
+            completedToolCalls.push({
+              id: currentToolUse.id,
+              name: currentToolUse.name,
+              arguments: parsed
+            });
+          }
+          currentToolUse = null;
+        } else if (event.messageStop) {
+          stopReason = event.messageStop.stopReason;
+        } else if (event.metadata) {
+          if (event.metadata.usage) {
+            inputTokens = event.metadata.usage.inputTokens;
+            outputTokens = event.metadata.usage.outputTokens;
+            totalTokens = event.metadata.usage.totalTokens;
+          }
+        }
+      }
+    } catch (err) {
+      if (isAbortError4(err)) {
+        yield { type: "end", finishReason: "aborted" };
+        return;
+      }
+      throw err;
+    }
+    if (req.signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    for (const tc of completedToolCalls) {
+      yield {
+        type: "toolCall",
+        id: tc.id,
+        name: tc.name,
+        arguments: tc.arguments
+      };
+    }
+    const finishReason = mapStopReason2(stopReason, completedToolCalls.length > 0);
+    const usage = inputTokens !== void 0 || outputTokens !== void 0 || totalTokens !== void 0 ? {
+      ...inputTokens !== void 0 ? { inputTokens } : {},
+      ...outputTokens !== void 0 ? { outputTokens } : {},
+      ...totalTokens !== void 0 ? { totalTokens } : {}
+    } : void 0;
+    const endEvent = {
+      type: "end",
+      finishReason,
+      ...usage ? { usage } : {},
+      ...stopReason ? { rawReason: stopReason } : {}
+    };
+    yield endEvent;
+  }
+  appendToolResult(history, toolCallId, result) {
+    const text = typeof result === "string" ? result : JSON.stringify(result);
+    const wireMessage = {
+      role: "user",
+      content: [
+        {
+          toolResult: {
+            toolUseId: toolCallId,
+            content: [{ text }]
+          }
+        }
+      ]
+    };
+    return [
+      ...history,
+      {
+        role: "tool",
+        content: text,
+        vendorRaw: wireMessage
+      }
+    ];
+  }
+  async listAvailableModels() {
+    return [...bedrockManifest.knownModels];
+  }
+  async warmup() {
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error(
+        "BedrockAdapter: init() must be called before stream()/listAvailableModels()"
+      );
+    }
+    return this.client;
+  }
+};
+function buildWireMessages3(req) {
+  const out = [];
+  for (const msg of req.messages) {
+    if (msg.vendorRaw && typeof msg.vendorRaw === "object") {
+      out.push(msg.vendorRaw);
+      continue;
+    }
+    const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    const role = msg.role === "tool" ? "user" : msg.role;
+    out.push({
+      role,
+      content: [{ text }]
+    });
+  }
+  return out;
+}
+function formatTools4(tools) {
+  return tools.map((t) => ({
+    toolSpec: {
+      name: t.name,
+      // Bedrock rejects empty-string descriptions; fall back to a single space.
+      description: t.description && t.description.length > 0 ? t.description : " ",
+      inputSchema: {
+        json: t.parameters ?? { type: "object", properties: {} }
+      }
+    }
+  }));
+}
+function mapStopReason2(r, hadToolCalls) {
+  if (hadToolCalls) return "tool";
+  switch (r) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool";
+    case "max_tokens":
+      return "length";
+    case "content_filtered":
+    case "guardrail_intervened":
+      return "filtered";
+    default:
+      return "stop";
+  }
+}
+function isAbortError4(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "AbortError" || e.name === "APIUserAbortError" || e.code === "ABORT_ERR" || typeof e.message === "string" && /aborted/i.test(e.message);
+}
+
+// src/adapters/bedrock/factory.ts
+var bedrockFactory = {
+  vendor: bedrockManifest.vendor,
+  manifest: bedrockManifest,
+  create: () => new BedrockAdapter()
+};
+
+// src/adapters/index.ts
+registerAdapter(openAIFactory);
+registerAdapter(deepseekFactory);
+registerAdapter(anthropicFactory);
+registerAdapter(googleFactory);
+registerAdapter(vertexGeminiFactory);
+registerAdapter(vertexOpenAIFactory);
+registerAdapter(bedrockFactory);
+
+// src/normalize-auth.ts
+function normalizeAuth(vendor, raw) {
+  switch (vendor) {
+    case "openai":
+    case "anthropic":
+      return requireApiKey(vendor, raw);
+    case "deepseek":
+      return {
+        ...requireApiKey(vendor, raw),
+        baseURL: raw.api_url ?? "https://api.deepseek.com/v1"
+      };
+    case "google":
+      return normalizeGoogle(raw);
+    case "vertex":
+    case "vertex-gemini":
+    case "vertex-openai":
+      return normalizeVertex(vendor, raw);
+    case "bedrock":
+      return normalizeBedrock(raw);
+    default:
+      throw new Error(
+        `normalizeAuth: unknown vendor '${vendor}'. If this is a custom adapter, construct the AuthSpec directly.`
+      );
+  }
+}
+function requireApiKey(vendor, raw) {
+  if (!raw.api_key) {
+    throw new Error(`normalizeAuth: vendor '${vendor}' requires 'api_key'`);
+  }
+  const result = {
+    kind: "apiKey",
+    apiKey: raw.api_key
+  };
+  if (raw.api_url) {
+    result.baseURL = raw.api_url;
+  }
+  return result;
+}
+function normalizeGoogle(raw) {
+  if (raw.service_key) {
+    return {
+      kind: "googleServiceAccount",
+      credentials: parseServiceKey(raw.service_key)
+    };
+  }
+  if (raw.api_key) {
+    return { kind: "googleApiKey", apiKey: raw.api_key };
+  }
+  throw new Error(`normalizeAuth: vendor 'google' requires either 'api_key' or 'service_key'`);
+}
+function normalizeVertex(vendor, raw) {
+  if (!raw.service_key) {
+    throw new Error(`normalizeAuth: vendor '${vendor}' requires 'service_key'`);
+  }
+  if (!raw.location) {
+    throw new Error(`normalizeAuth: vendor '${vendor}' requires 'location'`);
+  }
+  const credentials = parseServiceKey(raw.service_key);
+  const projectId = raw.project_id ?? credentials.project_id;
+  if (!projectId) {
+    throw new Error(
+      `normalizeAuth: vendor '${vendor}' requires 'project_id' (not present in raw credential or service_key.project_id)`
+    );
+  }
+  return {
+    kind: "vertexServiceAccount",
+    credentials,
+    projectId,
+    location: raw.location
+  };
+}
+function normalizeBedrock(raw) {
+  if (!raw.region) {
+    throw new Error(`normalizeAuth: vendor 'bedrock' requires 'region'`);
+  }
+  if (raw.access_key_id && raw.secret_access_key) {
+    const result = {
+      kind: "bedrockIam",
+      accessKeyId: raw.access_key_id,
+      secretAccessKey: raw.secret_access_key,
+      region: raw.region
+    };
+    if (raw.session_token) {
+      result.sessionToken = raw.session_token;
+    }
+    return result;
+  }
+  if (raw.api_key) {
+    return {
+      kind: "bedrockApiKey",
+      apiKey: raw.api_key,
+      region: raw.region
+    };
+  }
+  throw new Error(
+    `normalizeAuth: vendor 'bedrock' requires either (access_key_id + secret_access_key) or api_key`
+  );
+}
+function parseServiceKey(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new Error(`normalizeAuth: 'service_key' is not valid JSON`);
+    }
+  }
+  return value;
+}
+
+// src/index.ts
+async function createLlm(args) {
+  const factory = getAdapterFactory(args.vendor);
+  if (!factory.manifest.authKinds.some((k) => k.kind === args.auth.kind)) {
+    const accepted = factory.manifest.authKinds.map((k) => k.kind).join(", ");
+    throw new Error(
+      `Vendor '${args.vendor}' does not accept auth kind '${args.auth.kind}'. Accepted kinds: ${accepted}`
+    );
+  }
+  const instance = factory.create();
+  await Promise.resolve(instance.init(args.auth, args.client));
+  return instance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertValidRequest,
+  createLlm,
+  getAdapterFactory,
+  getManifest,
+  listVendors,
+  normalizeAuth,
+  registerAdapter,
+  replaceAdapter,
+  unregisterAdapter
+});
+//# sourceMappingURL=index.cjs.map