@jambonz/llm 0.1.0

package/dist/test-kit/index.cjs

@@ -0,0 +1,2645 @@
+"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/test-kit/index.ts
+var test_kit_exports = {};
+__export(test_kit_exports, {
+  FakeAdapter: () => FakeAdapter,
+  createFakeHarness: () => createFakeHarness,
+  fakeManifest: () => fakeManifest,
+  runContractTests: () => runContractTests
+});
+module.exports = __toCommonJS(test_kit_exports);
+
+// src/test-kit/runner.ts
+var import_vitest = require("vitest");
+
+// 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 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 _resetRegistryForTests() {
+  registry.clear();
+}
+
+// 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, init2) => {
+      const googleClient = await googleAuth.getClient();
+      const token = await googleClient.getAccessToken();
+      const headers = new Headers(init2?.headers);
+      headers.set("Authorization", `Bearer ${token.token ?? ""}`);
+      return fetch(input, { ...init2, 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/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;
+}
+
+// src/test-kit/runner.ts
+var VALID_FINISH_REASONS = [
+  "stop",
+  "tool",
+  "length",
+  "filtered",
+  "error",
+  "aborted"
+];
+var VALID_FORM_FIELD_TYPES = ["text", "password", "url", "json-file", "select"];
+function runContractTests(harness) {
+  (0, import_vitest.describe)(`contract: ${harness.vendor}`, () => {
+    (0, import_vitest.beforeEach)(() => {
+      _resetRegistryForTests();
+      registerAdapter(harness.factory);
+    });
+    (0, import_vitest.afterEach)(async () => {
+      await harness.cleanup();
+      _resetRegistryForTests();
+    });
+    (0, import_vitest.it)("[1] manifest is well-formed", () => {
+      const m = harness.factory.manifest;
+      (0, import_vitest.expect)(m.vendor).toMatch(/^[a-z][a-z0-9-]*$/);
+      (0, import_vitest.expect)(m.displayName.length).toBeGreaterThan(0);
+      (0, import_vitest.expect)(m.authKinds.length).toBeGreaterThan(0);
+      for (const ak of m.authKinds) {
+        (0, import_vitest.expect)(ak.displayName.length).toBeGreaterThan(0);
+        for (const field of ak.fields) {
+          (0, import_vitest.expect)(field.name.length).toBeGreaterThan(0);
+          (0, import_vitest.expect)(field.label.length).toBeGreaterThan(0);
+          (0, import_vitest.expect)(VALID_FORM_FIELD_TYPES).toContain(field.type);
+          if (field.type === "select") {
+            (0, import_vitest.expect)(field.options?.length ?? 0).toBeGreaterThan(0);
+          }
+        }
+      }
+      (0, import_vitest.expect)(m.knownModels.length).toBeGreaterThan(0);
+      for (const model of m.knownModels) {
+        (0, import_vitest.expect)(model.id.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(typeof model.capabilities.streaming).toBe("boolean");
+        (0, import_vitest.expect)(typeof model.capabilities.tools).toBe("boolean");
+        (0, import_vitest.expect)(typeof model.capabilities.vision).toBe("boolean");
+        (0, import_vitest.expect)(typeof model.capabilities.systemPrompt).toBe("boolean");
+      }
+      (0, import_vitest.expect)(typeof m.supportsModelListing).toBe("boolean");
+    });
+    (0, import_vitest.it)("[2] createLlm returns an adapter with matching vendor id", async () => {
+      const firstKind = harness.factory.manifest.authKinds[0].kind;
+      const adapter = await createLlm({
+        vendor: harness.vendor,
+        auth: harness.authFor(firstKind)
+      });
+      (0, import_vitest.expect)(adapter.vendor).toBe(harness.vendor);
+    });
+    (0, import_vitest.it)("[3] init() accepts each declared auth kind", async () => {
+      for (const ak of harness.factory.manifest.authKinds) {
+        await (0, import_vitest.expect)(
+          createLlm({ vendor: harness.vendor, auth: harness.authFor(ak.kind) })
+        ).resolves.toBeDefined();
+      }
+    });
+    if (harness.unsupportedAuth) {
+      (0, import_vitest.it)("[4] init() rejects an unsupported auth kind", async () => {
+        await (0, import_vitest.expect)(
+          createLlm({
+            vendor: harness.vendor,
+            auth: harness.unsupportedAuth
+          })
+        ).rejects.toThrow();
+      });
+    }
+    (0, import_vitest.it)("[18] empty messages array is rejected with a clear error", async () => {
+      const adapter = await init(harness);
+      await (0, import_vitest.expect)(
+        drainStream(adapter, {
+          model: harness.toolCapableModel,
+          messages: []
+        })
+      ).rejects.toThrowError(/messages/i);
+    });
+    (0, import_vitest.it)("[5,6,7] stream emits exactly one end event, as the last event, with a valid finishReason", async () => {
+      await harness.mockScenario("simple-stream");
+      const adapter = await init(harness);
+      const events = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "hello" }]
+      });
+      const endIndexes = events.map((e, i) => e.type === "end" ? i : -1).filter((i) => i >= 0);
+      (0, import_vitest.expect)(endIndexes).toHaveLength(1);
+      (0, import_vitest.expect)(endIndexes[0]).toBe(events.length - 1);
+      const end = events[events.length - 1];
+      (0, import_vitest.expect)(VALID_FINISH_REASONS).toContain(end.finishReason);
+    });
+    (0, import_vitest.it)("[8] tokens stream incrementally (at least two chunks)", async () => {
+      await harness.mockScenario("simple-stream");
+      const adapter = await init(harness);
+      const events = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "hello" }]
+      });
+      const tokens = events.filter((e) => e.type === "token");
+      (0, import_vitest.expect)(tokens.length).toBeGreaterThanOrEqual(2);
+    });
+    (0, import_vitest.it)("[9] pre-fired AbortSignal yields end(aborted) within 500ms", async () => {
+      await harness.mockScenario("simple-stream");
+      const adapter = await init(harness);
+      const controller = new AbortController();
+      controller.abort();
+      const start = Date.now();
+      const events = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "hello" }],
+        signal: controller.signal
+      });
+      const elapsed = Date.now() - start;
+      (0, import_vitest.expect)(elapsed).toBeLessThan(500);
+      const end = events[events.length - 1];
+      (0, import_vitest.expect)(end.type).toBe("end");
+      (0, import_vitest.expect)(end.finishReason).toBe("aborted");
+      (0, import_vitest.expect)(events.filter((e) => e.type === "token").length).toBe(0);
+    });
+    (0, import_vitest.it)("[10] mid-stream abort prevents any pending toolCall from firing", async () => {
+      await harness.mockScenario("long-stream-with-pending-tool");
+      const adapter = await init(harness);
+      const controller = new AbortController();
+      const events = [];
+      let aborted = false;
+      for await (const evt of adapter.stream({
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "go" }],
+        signal: controller.signal
+      })) {
+        events.push(evt);
+        if (!aborted && evt.type === "token") {
+          controller.abort();
+          aborted = true;
+        }
+      }
+      const end = events[events.length - 1];
+      (0, import_vitest.expect)(end.type).toBe("end");
+      (0, import_vitest.expect)(end.finishReason).toBe("aborted");
+      (0, import_vitest.expect)(events.filter((e) => e.type === "toolCall")).toHaveLength(0);
+    });
+    (0, import_vitest.it)("[11] tool-capable request yields a well-formed toolCall event", async () => {
+      await harness.mockScenario("tool-call");
+      const adapter = await init(harness);
+      const events = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "call the tool" }],
+        tools: [
+          {
+            name: "test_tool",
+            description: "A test tool",
+            parameters: { type: "object", properties: {} }
+          }
+        ]
+      });
+      const toolCalls = events.filter(
+        (e) => e.type === "toolCall"
+      );
+      (0, import_vitest.expect)(toolCalls.length).toBeGreaterThanOrEqual(1);
+      const tc = toolCalls[0];
+      (0, import_vitest.expect)(typeof tc.id).toBe("string");
+      (0, import_vitest.expect)(tc.id.length).toBeGreaterThan(0);
+      (0, import_vitest.expect)(typeof tc.name).toBe("string");
+      (0, import_vitest.expect)(tc.name.length).toBeGreaterThan(0);
+      (0, import_vitest.expect)(tc.arguments).toBeDefined();
+    });
+    if (harness.emitsToolCallStart) {
+      (0, import_vitest.it)("[12] every toolCallStart precedes its matching toolCall with the same id", async () => {
+        await harness.mockScenario("tool-call-after-tokens");
+        const adapter = await init(harness);
+        const events = await drainStream(adapter, {
+          model: harness.toolCapableModel,
+          messages: [{ role: "user", content: "hi" }],
+          tools: [
+            {
+              name: "test_tool",
+              description: "A test tool",
+              parameters: { type: "object", properties: {} }
+            }
+          ]
+        });
+        const startIndexById = /* @__PURE__ */ new Map();
+        for (let i = 0; i < events.length; i++) {
+          const evt = events[i];
+          if (evt.type === "toolCallStart") {
+            startIndexById.set(evt.id, i);
+          } else if (evt.type === "toolCall") {
+            const startIndex = startIndexById.get(evt.id);
+            (0, import_vitest.expect)(startIndex, `missing toolCallStart for id ${evt.id}`).toBeDefined();
+            (0, import_vitest.expect)(startIndex).toBeLessThan(i);
+          }
+        }
+      });
+    }
+    (0, import_vitest.it)("[13] appendToolResult produces a history that re-streams without throwing", async () => {
+      await harness.mockScenario("tool-call");
+      const adapter = await init(harness);
+      const events = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "call it" }],
+        tools: [
+          { name: "test_tool", description: "x", parameters: { type: "object" } }
+        ]
+      });
+      const tc = events.find(
+        (e) => e.type === "toolCall"
+      );
+      (0, import_vitest.expect)(tc).toBeDefined();
+      const history = [
+        { role: "user", content: "call it" },
+        harness.buildAssistantWithToolCall(tc)
+      ];
+      const withResult = adapter.appendToolResult(history, tc.id, { ok: true });
+      (0, import_vitest.expect)(withResult.length).toBe(history.length + 1);
+      await harness.mockScenario("simple-stream");
+      await (0, import_vitest.expect)(
+        drainStream(adapter, {
+          model: harness.toolCapableModel,
+          messages: withResult
+        })
+      ).resolves.toBeDefined();
+    });
+    (0, import_vitest.it)("[14] appendToolResult is deterministic for the same inputs", async () => {
+      const adapter = await init(harness);
+      const history = [{ role: "user", content: "hi" }];
+      const a = adapter.appendToolResult(history, "tc_1", { a: 1 });
+      const b = adapter.appendToolResult(history, "tc_1", { a: 1 });
+      (0, import_vitest.expect)(JSON.stringify(a)).toBe(JSON.stringify(b));
+    });
+    (0, import_vitest.it)("[15] listAvailableModels returns a non-empty list", async () => {
+      await harness.mockScenario("list-models");
+      const adapter = await init(harness);
+      const models = await adapter.listAvailableModels();
+      (0, import_vitest.expect)(models.length).toBeGreaterThan(0);
+      for (const m of models) {
+        (0, import_vitest.expect)(m.id.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(typeof m.capabilities.tools).toBe("boolean");
+      }
+    });
+    if (harness.nonToolCapableModel) {
+      (0, import_vitest.it)("[16] non-tool-capable model with tools declared either fails fast or runs without tool calls", async () => {
+        await harness.mockScenario("simple-stream");
+        const adapter = await init(harness);
+        const run = async () => drainStream(adapter, {
+          model: harness.nonToolCapableModel,
+          messages: [{ role: "user", content: "hi" }],
+          tools: [
+            { name: "test_tool", description: "x", parameters: { type: "object" } }
+          ]
+        });
+        try {
+          const events = await run();
+          (0, import_vitest.expect)(events.filter((e) => e.type === "toolCall")).toHaveLength(0);
+          const end = events[events.length - 1];
+          (0, import_vitest.expect)(end.finishReason).not.toBe("error");
+        } catch (err) {
+          (0, import_vitest.expect)(err).toBeInstanceOf(Error);
+        }
+      });
+    }
+    (0, import_vitest.it)("[17] system prompt is present in the upstream request", async () => {
+      await harness.mockScenario("simple-stream");
+      const adapter = await init(harness);
+      await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        system: "You are a test agent.",
+        messages: [{ role: "user", content: "hi" }]
+      });
+      const captured = harness.getCapturedRequest();
+      (0, import_vitest.expect)(captured).not.toBeNull();
+      (0, import_vitest.expect)(captured.system).toBe("You are a test agent.");
+    });
+    (0, import_vitest.it)("[19] multi-turn conversation is preserved in the upstream request", async () => {
+      await harness.mockScenario("simple-stream");
+      const adapter = await init(harness);
+      const messages = [
+        { role: "user", content: "first" },
+        { role: "assistant", content: "one" },
+        { role: "user", content: "second" },
+        { role: "assistant", content: "two" },
+        { role: "user", content: "third" }
+      ];
+      await drainStream(adapter, { model: harness.toolCapableModel, messages });
+      const captured = harness.getCapturedRequest();
+      (0, import_vitest.expect)(captured).not.toBeNull();
+      (0, import_vitest.expect)(captured.messageCount).toBe(messages.length);
+    });
+    (0, import_vitest.it)("[20] vendorRaw on an assistant message round-trips through the next request", async () => {
+      await harness.mockScenario("tool-call");
+      const adapter = await init(harness);
+      const first = await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: [{ role: "user", content: "go" }],
+        tools: [
+          { name: "test_tool", description: "x", parameters: { type: "object" } }
+        ]
+      });
+      const tc = first.find(
+        (e) => e.type === "toolCall"
+      );
+      (0, import_vitest.expect)(tc).toBeDefined();
+      const history = [
+        { role: "user", content: "go" },
+        harness.buildAssistantWithToolCall(tc)
+      ];
+      const withResult = adapter.appendToolResult(history, tc.id, { ok: true });
+      await harness.mockScenario("simple-stream");
+      await drainStream(adapter, {
+        model: harness.toolCapableModel,
+        messages: withResult
+      });
+      const captured = harness.getCapturedRequest();
+      (0, import_vitest.expect)(captured).not.toBeNull();
+      (0, import_vitest.expect)(captured.vendorRawHonored).toBe(true);
+    });
+  });
+}
+async function init(harness) {
+  const kind = harness.factory.manifest.authKinds[0].kind;
+  return createLlm({ vendor: harness.vendor, auth: harness.authFor(kind) });
+}
+async function drainStream(adapter, req) {
+  const events = [];
+  for await (const evt of adapter.stream(req)) {
+    events.push(evt);
+  }
+  return events;
+}
+
+// src/test-kit/fake-adapter.ts
+var FakeAdapter = class {
+  constructor(state) {
+    this.state = state;
+  }
+  state;
+  vendor = fakeManifest.vendor;
+  acceptedAuth = ["apiKey"];
+  initialized = false;
+  init(auth, _client) {
+    if (auth.kind !== "apiKey") {
+      throw new Error(`FakeAdapter: unsupported auth kind '${auth.kind}'`);
+    }
+    if (!auth.apiKey) {
+      throw new Error("FakeAdapter: apiKey is required");
+    }
+    this.initialized = true;
+  }
+  async *stream(req) {
+    this.ensureInitialized();
+    assertValidRequest(req);
+    this.capture(req);
+    const scenario = this.state.scenario ?? "simple-stream";
+    if (req.signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    switch (scenario) {
+      case "simple-stream":
+        yield* simpleStream(req.signal);
+        return;
+      case "tool-call":
+        yield* toolCallOnly(req.signal);
+        return;
+      case "tool-call-after-tokens":
+        yield* toolCallAfterTokens(req.signal);
+        return;
+      case "long-stream":
+        yield* longStream(req.signal);
+        return;
+      case "long-stream-with-pending-tool":
+        yield* longStreamWithPendingTool(req.signal);
+        return;
+      case "list-models":
+        yield* simpleStream(req.signal);
+        return;
+      default:
+        throw new Error(`FakeAdapter: unknown scenario '${scenario}'`);
+    }
+  }
+  appendToolResult(history, toolCallId, result) {
+    const content = typeof result === "string" ? result : JSON.stringify(result);
+    return [
+      ...history,
+      {
+        role: "tool",
+        content,
+        vendorRaw: { tool_call_id: toolCallId }
+      }
+    ];
+  }
+  async listAvailableModels() {
+    this.ensureInitialized();
+    return fakeManifest.knownModels;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("FakeAdapter: init() must be called before stream()/listAvailableModels()");
+    }
+  }
+  capture(req) {
+    this.state.captured = {
+      messageCount: req.messages.length,
+      vendorRawHonored: req.messages.some((m) => m.vendorRaw !== void 0),
+      ...req.system !== void 0 ? { system: req.system } : {}
+    };
+  }
+};
+async function* simpleStream(signal) {
+  const chunks = ["Hello", ", ", "world", "!"];
+  for (const text of chunks) {
+    if (signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    yield { type: "token", text };
+  }
+  yield { type: "end", finishReason: "stop", usage: { inputTokens: 5, outputTokens: 4 } };
+}
+async function* toolCallOnly(signal) {
+  if (signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  yield { type: "toolCallStart", id: "call_fake_1", name: "test_tool" };
+  yield {
+    type: "toolCall",
+    id: "call_fake_1",
+    name: "test_tool",
+    arguments: { foo: "bar" }
+  };
+  yield { type: "end", finishReason: "tool" };
+}
+async function* toolCallAfterTokens(signal) {
+  const tokens = ["Let ", "me ", "check"];
+  for (const text of tokens) {
+    if (signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    yield { type: "token", text };
+  }
+  if (signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  yield { type: "toolCallStart", id: "call_fake_2", name: "test_tool" };
+  yield {
+    type: "toolCall",
+    id: "call_fake_2",
+    name: "test_tool",
+    arguments: { q: "hello" }
+  };
+  yield { type: "end", finishReason: "tool" };
+}
+async function* longStream(signal) {
+  for (let i = 0; i < 12; i++) {
+    if (signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    yield { type: "token", text: `chunk-${i} ` };
+    await sleep(20);
+  }
+  yield { type: "end", finishReason: "stop" };
+}
+async function* longStreamWithPendingTool(signal) {
+  for (let i = 0; i < 5; i++) {
+    if (signal?.aborted) {
+      yield { type: "end", finishReason: "aborted" };
+      return;
+    }
+    yield { type: "token", text: `chunk-${i} ` };
+    await sleep(25);
+  }
+  if (signal?.aborted) {
+    yield { type: "end", finishReason: "aborted" };
+    return;
+  }
+  yield { type: "toolCallStart", id: "call_fake_3", name: "test_tool" };
+  yield {
+    type: "toolCall",
+    id: "call_fake_3",
+    name: "test_tool",
+    arguments: { q: "never-reached" }
+  };
+  yield { type: "end", finishReason: "tool" };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var fakeManifest = {
+  vendor: "fake",
+  displayName: "Fake (test-kit reference)",
+  authKinds: [
+    {
+      kind: "apiKey",
+      displayName: "API Key",
+      fields: [
+        { name: "apiKey", label: "API Key", type: "password", required: true }
+      ]
+    }
+  ],
+  knownModels: [
+    {
+      id: "fake-tool-model",
+      displayName: "Fake Tool-Capable Model",
+      capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        systemPrompt: true,
+        maxContextTokens: 8e3
+      }
+    },
+    {
+      id: "fake-plain-model",
+      displayName: "Fake Plain Model (no tools)",
+      capabilities: {
+        streaming: true,
+        tools: false,
+        vision: false,
+        systemPrompt: true,
+        maxContextTokens: 4e3
+      }
+    }
+  ],
+  supportsModelListing: true
+};
+function createFakeHarness() {
+  const state = { scenario: null, captured: null };
+  const factory = {
+    vendor: fakeManifest.vendor,
+    manifest: fakeManifest,
+    create: () => new FakeAdapter(state)
+  };
+  return {
+    vendor: fakeManifest.vendor,
+    factory,
+    authFor: (kind) => {
+      if (kind === "apiKey") return { kind: "apiKey", apiKey: "sk-fake" };
+      throw new Error(`FakeHarness: asked for unsupported authFor kind '${kind}'`);
+    },
+    unsupportedAuth: {
+      kind: "bedrockIam",
+      accessKeyId: "x",
+      secretAccessKey: "y",
+      region: "us-east-1"
+    },
+    mockScenario(scenario) {
+      state.scenario = scenario;
+      state.captured = null;
+    },
+    cleanup() {
+      state.scenario = null;
+      state.captured = null;
+    },
+    getCapturedRequest() {
+      return state.captured;
+    },
+    toolCapableModel: "fake-tool-model",
+    nonToolCapableModel: "fake-plain-model",
+    emitsToolCallStart: true,
+    buildAssistantWithToolCall(tc) {
+      return {
+        role: "assistant",
+        content: "",
+        vendorRaw: {
+          role: "assistant",
+          toolCall: { id: tc.id, name: tc.name, arguments: tc.arguments }
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FakeAdapter,
+  createFakeHarness,
+  fakeManifest,
+  runContractTests
+});
+//# sourceMappingURL=index.cjs.map