@vostride/agent-qa-model 0.0.0-stage → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1701 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FAMILIES: () => FAMILIES,
+  MODEL_CALL_EVENT_KINDS: () => MODEL_CALL_EVENT_KINDS,
+  MODEL_CALL_REPORT_ORIGINS: () => MODEL_CALL_REPORT_ORIGINS,
+  MODEL_CATALOG: () => MODEL_CATALOG,
+  UNKNOWN_FLOOR: () => UNKNOWN_FLOOR,
+  anthropicCompatible: () => anthropicCompatible,
+  anthropicSubscription: () => anthropicSubscription,
+  capabilityKey: () => capabilityKey,
+  capabilityUpdateMiddleware: () => capabilityUpdateMiddleware,
+  clearProviderRegistry: () => clearProviderRegistry,
+  compactLogs: () => compactLogs,
+  createModel: () => createModel,
+  createTokenAccounting: () => createTokenAccounting,
+  debugLoggingMiddleware: () => debugLoggingMiddleware,
+  deriveExamplesMiddleware: () => deriveExamplesMiddleware,
+  deriveTransport: () => deriveTransport,
+  dropEmptyMessagesMiddleware: () => dropEmptyMessagesMiddleware,
+  extractJsonStrategy: () => extractJsonStrategy,
+  fetchLiveModels: () => fetchLiveModels,
+  gemini: () => gemini,
+  getModelCatalog: () => getModelCatalog,
+  getObservedWindow: () => getObservedWindow,
+  getProvider: () => getProvider,
+  getProviderOptions: () => getProviderOptions,
+  guardBlob: () => guardBlob,
+  guardToolOutput: () => guardToolOutput,
+  isContextLengthOverflow: () => isContextOverflow,
+  isContextOverflow: () => isContextOverflow,
+  listProviders: () => listProviders,
+  matchFamily: () => matchFamily,
+  mergeCatalog: () => mergeCatalog,
+  openaiCompatible: () => openaiCompatible,
+  openaiSubscription: () => openaiSubscription,
+  overrideStore: () => overrideStore,
+  parseRealWindow: () => parseRealWindow,
+  registerProvider: () => registerProvider,
+  repairMiddleware: () => repairMiddleware,
+  resolveCapabilities: () => resolveCapabilities,
+  resolveVisionConfig: () => resolveVisionConfig,
+  resolveVisionGate: () => resolveVisionGate,
+  retryMiddleware: () => retryMiddleware,
+  stripUnsupportedParamsMiddleware: () => stripUnsupportedParamsMiddleware,
+  toolSchemaMiddleware: () => toolSchemaMiddleware,
+  validateProfile: () => validateProfile,
+  visionFromConfig: () => visionFromConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters/anthropic.ts
+var import_anthropic = require("@ai-sdk/anthropic");
+
+// src/auth.ts
+var import_ai = require("ai");
+function deriveTransport(profile, auth) {
+  const transport = {
+    ...profile.baseURL ? { baseURL: profile.baseURL } : {},
+    ...profile.headers ? { headers: profile.headers } : {},
+    ...profile.providerOptions ? { providerOptions: profile.providerOptions } : {}
+  };
+  switch (auth.kind) {
+    case "api-key":
+      return { ...transport, apiKey: auth.apiKey };
+    case "bearer-token":
+      return { ...transport, authToken: auth.token };
+    case "auth-fetch":
+      return { ...transport, apiKey: placeholderApiKey(profile.provider), fetch: auth.fetch };
+    case "none":
+      return { ...transport, apiKey: placeholderApiKey(profile.provider) };
+  }
+}
+function applyProviderOptions(model, transport) {
+  if (!transport.providerOptions) return model;
+  return (0, import_ai.wrapLanguageModel)({
+    model,
+    middleware: (0, import_ai.defaultSettingsMiddleware)({
+      settings: {
+        providerOptions: transport.providerOptions
+      }
+    })
+  });
+}
+function placeholderApiKey(provider) {
+  switch (provider) {
+    case "openai-compatible":
+      return "openai-compatible";
+    case "anthropic-compatible":
+      return "anthropic-compatible";
+    default:
+      return "placeholder";
+  }
+}
+
+// src/adapters/anthropic.ts
+function anthropicCompatible(transport, modelId) {
+  return applyProviderOptions(
+    (0, import_anthropic.createAnthropic)({
+      baseURL: transport.baseURL,
+      headers: transport.headers,
+      fetch: transport.fetch,
+      ...transport.authToken ? { authToken: transport.authToken } : { apiKey: transport.apiKey ?? "anthropic-compatible" }
+    })(modelId),
+    transport
+  );
+}
+function anthropicSubscription(transport, modelId) {
+  return applyProviderOptions(
+    (0, import_anthropic.createAnthropic)({
+      apiKey: transport.apiKey ?? "placeholder",
+      fetch: transport.fetch
+    })(modelId),
+    transport
+  );
+}
+
+// src/adapters/gemini.ts
+var import_google = require("@ai-sdk/google");
+function gemini(transport, modelId) {
+  return applyProviderOptions(
+    (0, import_google.createGoogleGenerativeAI)({
+      apiKey: transport.apiKey,
+      fetch: transport.fetch
+    })(modelId),
+    transport
+  );
+}
+
+// src/adapters/openai.ts
+var import_openai = require("@ai-sdk/openai");
+function openaiCompatible(transport, modelId) {
+  return applyProviderOptions(
+    (0, import_openai.createOpenAI)({
+      apiKey: transport.apiKey ?? "openai-compatible",
+      baseURL: transport.baseURL,
+      fetch: transport.fetch,
+      ...transport.headers ? { headers: transport.headers } : {}
+    }).chat(modelId),
+    transport
+  );
+}
+function openaiSubscription(transport, modelId) {
+  return applyProviderOptions(
+    (0, import_openai.createOpenAI)({
+      apiKey: transport.apiKey ?? "placeholder",
+      fetch: transport.fetch
+    }).responses(modelId),
+    transport
+  );
+}
+function getProviderOptions(config) {
+  if (config.fetch && (config.modelAdapter === "openai-responses" || !config.modelAdapter && config.provider === "openai-subscription")) {
+    return {
+      openai: {
+        instructions: "You are a helpful assistant.",
+        store: false
+      }
+    };
+  }
+  return void 0;
+}
+
+// src/accounting/compact.ts
+var DEFAULT_LEVEL = "log";
+var MAX_SAMPLES = 5;
+var SAMPLE_PREFIX = "  \xB7 ";
+var TRUNCATION_MARKER = "\u2026[truncated to fit context budget]";
+var BLOB_CEILING = 8e3;
+var PLACEHOLDER = "<*>";
+var NORMALIZERS = [
+  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+  // UUID
+  /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g,
+  // ISO timestamp
+  /\b(?:[0-9a-f]{1,4}:){2,}[0-9a-f]{0,4}\b/gi,
+  // IPv6-ish
+  /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+  // IPv4
+  /\b0x[0-9a-f]+\b/gi,
+  // hex literal
+  /\b[0-9a-f]{7,}\b/gi,
+  // long bare hex id
+  /\b\d+(?:\.\d+)?\b/g
+  // bare number (last)
+];
+function normalize(message) {
+  let out = message;
+  for (const pattern of NORMALIZERS) out = out.replace(pattern, PLACEHOLDER);
+  return out;
+}
+function compactLogs(entries) {
+  const classes = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const level = entry.level ?? DEFAULT_LEVEL;
+    const normalized = normalize(entry.message);
+    const key = `${entry.source}::${level}::${normalized}`;
+    const existing = classes.get(key);
+    if (existing) {
+      existing.count++;
+      if (existing.samples.length < MAX_SAMPLES) existing.samples.push(entry.message);
+    } else {
+      classes.set(key, { source: entry.source, level, normalized, count: 1, samples: [entry.message] });
+    }
+  }
+  const sortedKeys = [...classes.keys()].sort();
+  const blocks = [];
+  for (const key of sortedKeys) {
+    const klass = classes.get(key);
+    if (klass === void 0) continue;
+    const header = `[${klass.source}] ${klass.level} \xD7${klass.count}: ${klass.normalized}`;
+    const lines = klass.samples.map((sample) => `${SAMPLE_PREFIX}${sample}`);
+    blocks.push([header, ...lines].join("\n"));
+  }
+  return blocks.join("\n");
+}
+function guardBlob(value) {
+  if (value === void 0) return void 0;
+  const str = safeStringify(value);
+  if (str.length <= BLOB_CEILING) return str;
+  return str.slice(0, BLOB_CEILING) + TRUNCATION_MARKER;
+}
+function asLogEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const c = value;
+  const text = typeof c.text === "string" ? c.text : typeof c.message === "string" ? c.message : void 0;
+  if (text !== void 0) {
+    return {
+      source: typeof c.source === "string" ? c.source : "console",
+      level: typeof c.level === "string" ? c.level : void 0,
+      message: text
+    };
+  }
+  const n = value;
+  if (typeof n.url === "string" && typeof n.method === "string") {
+    return {
+      source: "network",
+      level: n.status === void 0 ? void 0 : String(n.status),
+      message: `${n.method} ${n.url}`
+    };
+  }
+  return void 0;
+}
+function guardToolOutput(value) {
+  if (Array.isArray(value) && value.length > 0) {
+    const entries = value.map(asLogEntry);
+    if (entries.every((e) => e !== void 0)) {
+      const compacted = compactLogs(entries);
+      if (compacted.length <= BLOB_CEILING) return compacted;
+      return compacted.slice(0, BLOB_CEILING) + TRUNCATION_MARKER;
+    }
+  }
+  return guardBlob(value);
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, node) => {
+      if (typeof node === "object" && node !== null) {
+        if (seen.has(node)) return "[Circular]";
+        seen.add(node);
+      }
+      return node;
+    }) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/capability/overflow-parse.ts
+var import_provider = require("@ai-sdk/provider");
+var PATTERNS = [
+  /maximum context length is (\d+) tokens/i,
+  />\s*(\d+)\s*maximum/i,
+  /maximum number of tokens allowed \((\d+)\)/i
+];
+var MIN_WINDOW = 512;
+var MAX_WINDOW = 1e7;
+function parseRealWindow(error) {
+  if (!import_provider.APICallError.isInstance(error) || error.statusCode !== 400) return void 0;
+  const text = `${error.message ?? ""}
+${error.responseBody ?? ""}`;
+  for (const pattern of PATTERNS) {
+    const match = pattern.exec(text);
+    if (!match) continue;
+    const parsed = Number.parseInt(match[1], 10);
+    if (Number.isFinite(parsed) && parsed >= MIN_WINDOW && parsed <= MAX_WINDOW) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function isContextOverflow(error) {
+  return parseRealWindow(error) !== void 0;
+}
+
+// src/accounting/degrade.ts
+var import_ai2 = require("ai");
+var SCREENSHOT_OMITTED = "\u2026[historical screenshot omitted]";
+var DUPLICATE_ELIDED = "\u2026[duplicate tool result elided]";
+var TRUNCATION_MARKER2 = "\u2026[truncated to fit context budget]";
+function degrade(messages, options) {
+  const estimate = options.estimate ?? defaultEstimate;
+  let working = runHygiene(messages);
+  if (estimate(protectedMessages(working, options)) > options.budget) {
+    return { ok: false, reason: "pinned-content-exceeds-budget", messages: working };
+  }
+  while (estimate(working) > options.budget) {
+    const evicted = evictOldestExchange(working, options);
+    if (!evicted) break;
+    working = evicted;
+  }
+  const exhausted = /* @__PURE__ */ new Set();
+  while (estimate(working) > options.budget) {
+    const isProtectedAt = makeIsProtected(working, options);
+    let targetIndex = -1;
+    let targetLength = 0;
+    working.forEach((message, index) => {
+      if (isProtectedAt(index) || exhausted.has(index)) return;
+      const length = messageTextLength(message);
+      if (length > targetLength) {
+        targetLength = length;
+        targetIndex = index;
+      }
+    });
+    if (targetIndex === -1 || targetLength === 0) break;
+    const overshootChars = Math.max(1, (estimate(working) - options.budget) * 4);
+    const keepChars = Math.max(0, targetLength - overshootChars);
+    const truncatedMessage = truncateMessage(working[targetIndex], keepChars);
+    if (messageTextLength(truncatedMessage) >= messageTextLength(working[targetIndex])) {
+      exhausted.add(targetIndex);
+      continue;
+    }
+    working = working.map((message, index) => index === targetIndex ? truncatedMessage : message);
+    if (keepChars === 0) exhausted.add(targetIndex);
+  }
+  return { ok: true, messages: working };
+}
+function defaultEstimate(messages) {
+  let chars = 0;
+  for (const message of messages) chars += messageTextLength(message);
+  return Math.ceil(chars / 4);
+}
+function makeIsProtected(messages, options) {
+  const lastIndex = messages.length - 1;
+  return (index) => {
+    const message = messages[index];
+    if (message.role === "system") return true;
+    if (index === lastIndex) return true;
+    return options.pin ? options.pin(message, index) === true : false;
+  };
+}
+function protectedMessages(messages, options) {
+  const isProtectedAt = makeIsProtected(messages, options);
+  return messages.filter((_, index) => isProtectedAt(index));
+}
+function toolCallIdsOf(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.content)) return [];
+  const ids = [];
+  for (const part of message.content) if (part.type === "tool-call") ids.push(part.toolCallId);
+  return ids;
+}
+function resultIdsOf(message) {
+  const ids = [];
+  if (message.role === "tool") {
+    for (const part of message.content) if (part.type === "tool-result") ids.push(part.toolCallId);
+  } else if (message.role === "assistant" && Array.isArray(message.content)) {
+    for (const part of message.content) if (part.type === "tool-result") ids.push(part.toolCallId);
+  }
+  return ids;
+}
+function evictOldestExchange(messages, options) {
+  const isProtectedAt = makeIsProtected(messages, options);
+  for (let i = 0; i < messages.length; i++) {
+    const callIds = toolCallIdsOf(messages[i]);
+    if (callIds.length === 0) continue;
+    const idSet = new Set(callIds);
+    const exchange = /* @__PURE__ */ new Set([i]);
+    for (let j = 0; j < messages.length; j++) {
+      if (j === i) continue;
+      if (resultIdsOf(messages[j]).some((id) => idSet.has(id))) exchange.add(j);
+    }
+    let evictable = true;
+    for (const index of exchange) {
+      if (isProtectedAt(index)) {
+        evictable = false;
+        break;
+      }
+    }
+    if (!evictable) continue;
+    return messages.filter((_, index) => !exchange.has(index));
+  }
+  return void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function messageTextLength(message) {
+  const content = message.content;
+  if (typeof content === "string") return content.length;
+  let total = 0;
+  for (const part of content) total += partTextLength(part);
+  return total;
+}
+function partTextLength(part) {
+  if (!isRecord(part)) return 0;
+  if (part.type === "text" && typeof part.text === "string") return part.text.length;
+  if (part.type === "tool-result") return outputTextLength(part.output);
+  return 0;
+}
+function outputTextLength(output) {
+  if (!isRecord(output)) return 0;
+  if ((output.type === "text" || output.type === "error-text") && typeof output.value === "string") {
+    return output.value.length;
+  }
+  if (output.type === "content" && Array.isArray(output.value)) {
+    let total = 0;
+    for (const item of output.value) {
+      if (isRecord(item) && item.type === "text" && typeof item.text === "string") total += item.text.length;
+    }
+    return total;
+  }
+  return 0;
+}
+function truncateMessage(message, keepChars) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return { ...message, content: sliceWithMarker(content, keepChars) };
+  }
+  const parts = content;
+  let largestIndex = -1;
+  let largestLength = -1;
+  parts.forEach((part, index) => {
+    const length = partTextLength(part);
+    if (length > largestLength) {
+      largestLength = length;
+      largestIndex = index;
+    }
+  });
+  if (largestIndex === -1 || largestLength <= 0) return message;
+  const removeTarget = Math.max(0, messageTextLength(message) - Math.max(0, keepChars));
+  const partKeep = Math.max(0, largestLength - removeTarget);
+  const newParts = parts.map((part, index) => index === largestIndex ? truncatePart(part, partKeep) : part);
+  return { ...message, content: newParts };
+}
+function sliceWithMarker(text, keep) {
+  const base = text.endsWith(TRUNCATION_MARKER2) ? text.slice(0, text.length - TRUNCATION_MARKER2.length) : text;
+  return base.slice(0, Math.max(0, keep)) + TRUNCATION_MARKER2;
+}
+function truncatePart(part, keep) {
+  if (!isRecord(part)) return part;
+  if (part.type === "text" && typeof part.text === "string") {
+    return { ...part, text: sliceWithMarker(part.text, keep) };
+  }
+  if (part.type === "tool-result") {
+    return { ...part, output: truncateOutput(part.output, keep) };
+  }
+  return part;
+}
+function truncateOutput(output, keep) {
+  if (!isRecord(output)) return output;
+  if ((output.type === "text" || output.type === "error-text") && typeof output.value === "string") {
+    return { ...output, value: sliceWithMarker(output.value, keep) };
+  }
+  return output;
+}
+function runHygiene(messages) {
+  const pruned = (0, import_ai2.pruneMessages)({
+    messages,
+    reasoning: "before-last-message",
+    emptyMessages: "remove"
+  });
+  return clearHistoricalToolResults(pruned);
+}
+function clearHistoricalToolResults(messages) {
+  let lastToolIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "tool") {
+      lastToolIndex = i;
+      break;
+    }
+  }
+  const seenHashes = /* @__PURE__ */ new Set();
+  return messages.map((message, index) => {
+    if (message.role !== "tool" || index === lastToolIndex) return message;
+    const rewritten = message.content.map((part) => rewriteHistoricalPart(part, seenHashes));
+    return { ...message, content: rewritten };
+  });
+}
+function rewriteHistoricalPart(part, seenHashes) {
+  if (part.type !== "tool-result") return part;
+  const hash = contentHash(part.output);
+  if (seenHashes.has(hash)) {
+    return { ...part, output: { type: "text", value: DUPLICATE_ELIDED } };
+  }
+  seenHashes.add(hash);
+  const stripped = stripScreenshots(part.output);
+  return stripped === part.output ? part : { ...part, output: stripped };
+}
+function stripScreenshots(output) {
+  if (output.type !== "content") return output;
+  let changed = false;
+  const value = output.value.map((item) => {
+    if (item.type === "image-data" || item.type === "media") {
+      changed = true;
+      return { type: "text", text: SCREENSHOT_OMITTED };
+    }
+    return item;
+  });
+  return changed ? { type: "content", value } : output;
+}
+function contentHash(value) {
+  const str = safeStringify2(value);
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16);
+}
+function safeStringify2(value) {
+  const ancestors = [];
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return node;
+    if (ancestors.includes(node)) return "[Circular]";
+    ancestors.push(node);
+    let result;
+    if (Array.isArray(node)) {
+      result = node.map(walk);
+    } else {
+      const sortedKeys = Object.keys(node).sort();
+      const obj = {};
+      for (const key of sortedKeys) obj[key] = walk(node[key]);
+      result = obj;
+    }
+    ancestors.pop();
+    return result;
+  };
+  try {
+    return JSON.stringify(walk(value)) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/accounting/token-accounting.ts
+var DEFAULT_PER_IMAGE_TOKENS = 1600;
+function createTokenAccounting(options) {
+  const perImageTokens = options.perImageTokens ?? DEFAULT_PER_IMAGE_TOKENS;
+  let anchor;
+  function estimate(messages) {
+    let chars = 0;
+    let images = 0;
+    for (const message of messages) {
+      chars += messageTextChars(message);
+      images += messageImageCount(message);
+    }
+    let textTokens = Math.ceil(chars / 4);
+    if (anchor !== void 0 && prefixMatches(messages, anchor)) {
+      textTokens = Math.max(textTokens, anchor.promptTokens);
+    }
+    return textTokens + images * perImageTokens;
+  }
+  function recordUsage(usage, messages) {
+    const inputTokens = usage.inputTokens;
+    if (inputTokens === void 0) return;
+    anchor = { promptTokens: inputTokens, prefixLength: messages.length, prefixDigest: digestPrefix(messages) };
+  }
+  function getCeilings() {
+    const c = options.getCapabilities();
+    return { contextWindow: c.contextWindow, maxOutput: c.maxOutput };
+  }
+  function degrade2(messages, opts) {
+    return degrade(messages, { ...opts, estimate });
+  }
+  return { estimate, recordUsage, getCeilings, degrade: degrade2 };
+}
+function prefixMatches(messages, anchor) {
+  if (messages.length < anchor.prefixLength) return false;
+  const prefix = messages.length === anchor.prefixLength ? messages : messages.slice(0, anchor.prefixLength);
+  return digestPrefix(prefix) === anchor.prefixDigest;
+}
+function messageTextChars(message) {
+  const content = message.content;
+  if (typeof content === "string") return content.length;
+  let total = 0;
+  for (const part of content) total += partTextChars(part);
+  return total;
+}
+function partTextChars(part) {
+  if (!isRecord2(part)) return 0;
+  if (part.type === "text" && typeof part.text === "string") return part.text.length;
+  if (part.type === "tool-result") return outputTextChars(part.output);
+  return 0;
+}
+function outputTextChars(output) {
+  if (!isRecord2(output)) return 0;
+  if ((output.type === "text" || output.type === "error-text") && typeof output.value === "string") {
+    return output.value.length;
+  }
+  if (output.type === "content" && Array.isArray(output.value)) {
+    let total = 0;
+    for (const item of output.value) {
+      if (isRecord2(item) && item.type === "text" && typeof item.text === "string") total += item.text.length;
+    }
+    return total;
+  }
+  return 0;
+}
+function messageImageCount(message) {
+  const content = message.content;
+  if (typeof content === "string") return 0;
+  let count2 = 0;
+  for (const part of content) {
+    if (!isRecord2(part)) continue;
+    if (part.type === "image") count2 += 1;
+    else if (part.type === "tool-result") count2 += outputImageCount(part.output);
+  }
+  return count2;
+}
+function outputImageCount(output) {
+  if (!isRecord2(output) || output.type !== "content" || !Array.isArray(output.value)) return 0;
+  let count2 = 0;
+  for (const item of output.value) {
+    if (isRecord2(item) && (item.type === "image-data" || item.type === "media")) count2 += 1;
+  }
+  return count2;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function digestPrefix(messages) {
+  const str = safeStringify3(messages);
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${messages.length}:${(hash >>> 0).toString(16)}`;
+}
+function safeStringify3(value) {
+  const ancestors = [];
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return node;
+    if (ancestors.includes(node)) return "[Circular]";
+    ancestors.push(node);
+    let result;
+    if (Array.isArray(node)) {
+      result = node.map(walk);
+    } else {
+      const sortedKeys = Object.keys(node).sort();
+      const obj = {};
+      for (const key of sortedKeys) obj[key] = walk(node[key]);
+      result = obj;
+    }
+    ancestors.pop();
+    return result;
+  };
+  try {
+    return JSON.stringify(walk(value)) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/capability/family-table.ts
+function caps(contextWindow, maxOutput, vision, visionToolMessages) {
+  return {
+    text: true,
+    vision,
+    visionToolMessages,
+    toolCalling: true,
+    structuredOutput: true,
+    streaming: true,
+    contextWindow,
+    maxOutput
+  };
+}
+var UNKNOWN_FLOOR = caps(8192, 4096, false, false);
+var FAMILIES = [
+  { match: ["claude-3-5-haiku", "claude-haiku"], caps: caps(2e5, 8192, true, true) },
+  { match: ["claude-opus", "claude-sonnet", "claude-"], caps: caps(2e5, 32e3, true, true) },
+  { match: ["gpt-4o"], caps: caps(128e3, 16384, true, false) },
+  { match: ["gpt-4.1"], caps: caps(1047576, 32768, true, false) },
+  { match: ["gpt-5"], caps: caps(4e5, 128e3, true, false) },
+  { match: ["o1", "o3", "o4"], caps: caps(2e5, 1e5, true, false) },
+  { match: ["gpt-4"], caps: caps(8192, 4096, false, false) },
+  { match: ["gpt-3.5"], caps: caps(16385, 4096, false, false) },
+  { match: ["gpt-"], caps: caps(128e3, 16384, true, false) },
+  { match: ["gemini-2.5", "gemini-3", "gemini-1.5", "gemini-"], caps: caps(1048576, 65536, true, true) },
+  { match: ["gemini-2.0-flash"], caps: caps(1048576, 8192, true, true) },
+  { match: ["deepseek-chat", "deepseek-r1", "deepseek-"], caps: caps(65536, 8192, false, false) },
+  { match: ["qwen2.5-vl", "qwen-vl", "qwen2-vl"], caps: caps(32768, 8192, true, false) },
+  { match: ["qwen"], caps: caps(32768, 8192, false, false) },
+  { match: ["llava"], caps: caps(8192, 4096, true, false) },
+  { match: ["llama-3-vision", "llama3.2-vision", "vision"], caps: caps(128e3, 8192, true, false) },
+  { match: ["llama-3", "llama3"], caps: caps(128e3, 8192, false, false) },
+  { match: ["llama"], caps: caps(8192, 4096, false, false) },
+  { match: ["pixtral"], caps: caps(128e3, 8192, true, false) },
+  { match: ["mixtral", "mistral"], caps: caps(32768, 8192, false, false) }
+];
+var BOUNDARIES = /* @__PURE__ */ new Set(["-", "_", ".", "/", ":"]);
+function matchesAtBoundary(id, token) {
+  let from = 0;
+  for (; ; ) {
+    const idx = id.indexOf(token, from);
+    if (idx === -1) return false;
+    if (idx === 0 || BOUNDARIES.has(id[idx - 1])) return true;
+    from = idx + 1;
+  }
+}
+function matchFamily(model) {
+  const id = model.toLowerCase();
+  let best;
+  for (const family of FAMILIES) {
+    for (const match of family.match) {
+      const normalized = match.toLowerCase();
+      if (!matchesAtBoundary(id, normalized)) continue;
+      if (!best || normalized.length > best.length) {
+        best = { length: normalized.length, caps: family.caps };
+      }
+    }
+  }
+  return best?.caps;
+}
+
+// src/capability/override-store.ts
+var overrideStore = /* @__PURE__ */ new Map();
+function capabilityKey(provider, model) {
+  return `${provider}:${model.toLowerCase().trim()}`;
+}
+function getObservedWindow(key) {
+  return overrideStore.get(key);
+}
+
+// src/capability/resolve.ts
+function resolveCapabilities(profile) {
+  const base = matchFamily(profile.model) ?? UNKNOWN_FLOOR;
+  const declared = { ...base, ...profile.capabilities ?? {} };
+  const observed = getObservedWindow(capabilityKey(profile.provider, profile.model));
+  if (observed !== void 0) {
+    return { ...declared, contextWindow: observed };
+  }
+  return declared;
+}
+
+// src/catalog/catalog.ts
+function deriveVision(id, override) {
+  return override ?? matchFamily(id)?.vision ?? false;
+}
+function expose(entry) {
+  return {
+    id: entry.id,
+    label: entry.label,
+    vision: deriveVision(entry.id, entry.vision),
+    ...entry.notes ? { notes: entry.notes } : {}
+  };
+}
+var CLAUDE = [
+  { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
+  { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+  { id: "claude-haiku-4-5", label: "Claude Haiku 4.5" }
+];
+var OPENAI_CLOUD = [
+  { id: "gpt-5.5", label: "GPT-5.5" },
+  { id: "gpt-4.1", label: "GPT-4.1" },
+  { id: "o3", label: "o3" },
+  { id: "o4-mini", label: "o4-mini" }
+];
+var LOCAL_OPENAI_WIRE = [
+  {
+    id: "deepseek-chat",
+    label: "DeepSeek Chat",
+    notes: "text-only model; use accessibility tree and DOM context."
+  },
+  { id: "deepseek-r1", label: "DeepSeek R1", notes: "Text-only reasoning model." },
+  { id: "qwen2.5-vl", label: "Qwen2.5 VL" },
+  { id: "llava", label: "LLaVA" },
+  { id: "llama3.2-vision", label: "Llama 3.2 Vision" }
+];
+var GEMINI = [
+  { id: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview" },
+  { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+  { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+];
+var AUTHORED = {
+  "openai-compatible": [...OPENAI_CLOUD, ...LOCAL_OPENAI_WIRE],
+  "anthropic-compatible": CLAUDE,
+  "openai-subscription": OPENAI_CLOUD,
+  "anthropic-subscription": CLAUDE,
+  gemini: GEMINI
+};
+function exposeCatalog() {
+  return {
+    "openai-compatible": AUTHORED["openai-compatible"].map(expose),
+    "anthropic-compatible": AUTHORED["anthropic-compatible"].map(expose),
+    "openai-subscription": AUTHORED["openai-subscription"].map(expose),
+    "anthropic-subscription": AUTHORED["anthropic-subscription"].map(expose),
+    gemini: AUTHORED.gemini.map(expose)
+  };
+}
+var MODEL_CATALOG = exposeCatalog();
+function getModelCatalog() {
+  return {
+    "openai-compatible": MODEL_CATALOG["openai-compatible"].map((entry) => ({ ...entry })),
+    "anthropic-compatible": MODEL_CATALOG["anthropic-compatible"].map((entry) => ({ ...entry })),
+    "openai-subscription": MODEL_CATALOG["openai-subscription"].map((entry) => ({ ...entry })),
+    "anthropic-subscription": MODEL_CATALOG["anthropic-subscription"].map((entry) => ({ ...entry })),
+    gemini: MODEL_CATALOG.gemini.map((entry) => ({ ...entry }))
+  };
+}
+
+// src/catalog/live.ts
+var liveCache = /* @__PURE__ */ new Map();
+var DEFAULT_TIMEOUT_MS = 2500;
+var DEFAULT_TTL_MS = 6e4;
+var MAX_LIVE_MODELS = 1e3;
+function normalizeBaseURL(baseURL) {
+  return baseURL.trim().replace(/\/+$/, "");
+}
+function cacheKey(baseURL) {
+  return normalizeBaseURL(baseURL).toLowerCase();
+}
+function liveEntry(id) {
+  return {
+    id,
+    label: id,
+    vision: matchFamily(id)?.vision ?? false
+  };
+}
+function parseLiveBody(body) {
+  if (!body || typeof body !== "object" || !Array.isArray(body.data)) {
+    return [];
+  }
+  return body.data.slice(0, MAX_LIVE_MODELS).flatMap((model) => {
+    if (!model || typeof model !== "object") return [];
+    const id = model.id;
+    return typeof id === "string" && id.trim() ? [liveEntry(id)] : [];
+  });
+}
+async function fetchLiveModels(opts) {
+  const normalized = normalizeBaseURL(opts.baseURL);
+  if (!normalized) return [];
+  const now = Date.now();
+  const key = cacheKey(normalized);
+  const cached = liveCache.get(key);
+  if (cached && cached.expiresAt > now) return cached.entries;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  try {
+    const doFetch = opts.fetchImpl ?? globalThis.fetch;
+    const res = await doFetch(`${normalized}/models`, {
+      signal: controller.signal,
+      ...opts.headers ? { headers: opts.headers } : {}
+    });
+    if (!res.ok) return [];
+    const entries = parseLiveBody(await res.json());
+    liveCache.set(key, {
+      entries,
+      expiresAt: Date.now() + (opts.ttlMs ?? DEFAULT_TTL_MS)
+    });
+    return entries;
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function mergeCatalog(staticEntries, live) {
+  const seen = new Set(staticEntries.map((entry) => entry.id.toLowerCase()));
+  return [...staticEntries, ...live.filter((entry) => !seen.has(entry.id.toLowerCase()))];
+}
+
+// src/middleware.ts
+var toolSchemaMiddleware = {
+  specificationVersion: "v3",
+  transformParams: async ({ params }) => {
+    if (!params.tools) return params;
+    return {
+      ...params,
+      tools: params.tools.map((t) => {
+        if (t.type !== "function") return t;
+        const schema = { ...t.inputSchema };
+        if ("$schema" in schema) delete schema.$schema;
+        if (!schema.type) schema.type = "object";
+        return { ...t, inputSchema: schema };
+      })
+    };
+  }
+};
+
+// src/middleware/capability-update.ts
+function capabilityUpdateMiddleware(profile) {
+  const key = capabilityKey(profile.provider, profile.model);
+  async function observe(call) {
+    try {
+      return await call();
+    } catch (error) {
+      const observedWindow = parseRealWindow(error);
+      if (observedWindow !== void 0) {
+        overrideStore.set(key, observedWindow);
+      }
+      throw error;
+    }
+  }
+  return {
+    specificationVersion: "v3",
+    wrapGenerate: ({ doGenerate }) => observe(doGenerate),
+    wrapStream: ({ doStream }) => observe(doStream)
+  };
+}
+
+// src/middleware/debug-logging.ts
+var REQUEST_PREFIX = "[agent-qa:llm] request";
+var ERROR_PREFIX = "[agent-qa:llm] provider-error";
+function isEnvEnabled() {
+  const raw = typeof process !== "undefined" ? process.env?.AGENT_QA_DEBUG_LLM : void 0;
+  if (typeof raw !== "string") return false;
+  const value = raw.trim().toLowerCase();
+  return value !== "" && value !== "0" && value !== "false" && value !== "off" && value !== "no";
+}
+function modelIdOf(model) {
+  if (model && typeof model === "object" && "modelId" in model) {
+    const id = model.modelId;
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return "unknown";
+}
+function requestShapeLine(params, model) {
+  const record = params;
+  const prompt = record.prompt;
+  const messages = Array.isArray(prompt) ? prompt : [];
+  const roles = messages.map((message) => message.role ?? "?").join(",");
+  const toolCount = Array.isArray(record.tools) ? record.tools.length : 0;
+  const paramKeys = Object.keys(record).filter((key) => key !== "prompt" && key !== "tools").join(",");
+  return `${REQUEST_PREFIX} model=${modelIdOf(model)} messages=${messages.length} roles=[${roles}] tools=${toolCount} params=[${paramKeys}]`;
+}
+function compactRequestBodyValues(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const record = value;
+  const model = typeof record.model === "string" ? record.model : void 0;
+  const items = Array.isArray(record.input) ? record.input : Array.isArray(record.messages) ? record.messages : void 0;
+  const roles = items?.map(
+    (item) => item && typeof item === "object" && "role" in item ? String(item.role) : "?"
+  );
+  const parts = [];
+  if (model) parts.push(`model=${model}`);
+  if (roles) parts.push(`roles=[${roles.join(",")}]`);
+  return parts.length > 0 ? `{${parts.join(",")}}` : void 0;
+}
+function originAndPath(url) {
+  if (typeof url !== "string") return void 0;
+  try {
+    const parsed = new URL(url);
+    return `${parsed.origin}${parsed.pathname}`;
+  } catch {
+    return void 0;
+  }
+}
+function stringField(record, key) {
+  if (record === null || typeof record !== "object") return void 0;
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function providerErrorLine(err) {
+  const e = err ?? {};
+  const statusCode = typeof e.statusCode === "number" ? e.statusCode : void 0;
+  const url = originAndPath(e.url);
+  const responseBody = typeof e.responseBody === "string" ? e.responseBody : void 0;
+  const request = compactRequestBodyValues(e.requestBodyValues);
+  const nested = e.data !== null && typeof e.data === "object" ? e.data.error : void 0;
+  const type = stringField(nested, "type") ?? stringField(e.data, "type");
+  const code = stringField(nested, "code") ?? stringField(e.data, "code");
+  const headerNames = e.responseHeaders !== null && typeof e.responseHeaders === "object" ? Object.keys(e.responseHeaders) : void 0;
+  const parts = [ERROR_PREFIX];
+  if (statusCode !== void 0) parts.push(`statusCode=${statusCode}`);
+  if (typeof e.name === "string") parts.push(`name=${e.name}`);
+  if (typeof e.isRetryable === "boolean") parts.push(`isRetryable=${e.isRetryable}`);
+  if (url !== void 0) parts.push(`url=${url}`);
+  if (type !== void 0) parts.push(`type=${type}`);
+  if (code !== void 0) parts.push(`code=${code}`);
+  if (headerNames !== void 0) parts.push(`responseHeaders=[${headerNames.join(",")}]`);
+  if (responseBody !== void 0) parts.push(`responseBodyLength=${responseBody.length}`);
+  if (request !== void 0) parts.push(`request=${request}`);
+  if (statusCode === void 0 && responseBody === void 0) {
+    const message = e.message !== void 0 ? String(e.message) : String(err);
+    parts.push(`messageLength=${message.length}`);
+  }
+  return parts.join(" ");
+}
+function debugLoggingMiddleware(options = {}) {
+  const enabled = options.enabled ?? isEnvEnabled();
+  if (!enabled) {
+    return { specificationVersion: "v3" };
+  }
+  const sink = options.sink ?? ((line) => {
+    process.stderr.write(`${line}
+`);
+  });
+  const emit = (line) => {
+    sink(line);
+  };
+  return {
+    specificationVersion: "v3",
+    wrapGenerate: async ({ doGenerate, params, model }) => {
+      emit(requestShapeLine(params, model));
+      try {
+        return await doGenerate();
+      } catch (err) {
+        emit(providerErrorLine(err));
+        throw err;
+      }
+    },
+    wrapStream: async ({ doStream, params, model }) => {
+      emit(requestShapeLine(params, model));
+      try {
+        return await doStream();
+      } catch (err) {
+        emit(providerErrorLine(err));
+        throw err;
+      }
+    }
+  };
+}
+
+// src/middleware/drop-empty-messages.ts
+function isEmptyMessage(message) {
+  if (message.role === "system") {
+    return typeof message.content === "string" && message.content.trim().length === 0;
+  }
+  const parts = message.content;
+  if (!Array.isArray(parts) || parts.length === 0) return true;
+  for (const part of parts) {
+    if (part.type === "text" || part.type === "reasoning") {
+      if (typeof part.text === "string" && part.text.trim().length > 0) return false;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function dropEmptyMessagesMiddleware() {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      const prompt = params.prompt;
+      if (!prompt) return params;
+      const filtered = prompt.filter((message) => !isEmptyMessage(message));
+      if (filtered.length === prompt.length) return params;
+      return { ...params, prompt: filtered };
+    }
+  };
+}
+
+// src/middleware/examples.ts
+function deriveExamplesMiddleware() {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      if (!params.tools) return params;
+      return {
+        ...params,
+        tools: params.tools.map((t) => {
+          if (t.type !== "function") return t;
+          if (t.inputExamples?.length) return t;
+          const input = sampleFromSchema(t.inputSchema);
+          if (!input || Object.keys(input).length === 0) return t;
+          return { ...t, inputExamples: [{ input }] };
+        })
+      };
+    }
+  };
+}
+function sampleFromSchema(inputSchema) {
+  const properties = inputSchema?.properties;
+  if (!properties || Object.keys(properties).length === 0) return void 0;
+  const fields = inputSchema?.required && inputSchema.required.length > 0 ? inputSchema.required : Object.keys(properties);
+  const input = {};
+  for (const field of fields) {
+    if (!properties[field]) continue;
+    input[field] = sampleValue(properties[field]);
+  }
+  return Object.keys(input).length > 0 ? input : void 0;
+}
+function sampleValue(schema) {
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    default:
+      return null;
+  }
+}
+
+// src/middleware/extract-json.ts
+var MAX_SCAN_LENGTH = 2e5;
+function extractJsonStrategy(text) {
+  const bounded = text.slice(0, MAX_SCAN_LENGTH);
+  const fenced = bounded.match(/```(?:json)?[^\S\r\n]*(?:\r?\n)?([\s\S]*?)```/i);
+  if (fenced?.[1] !== void 0) return fenced[1].trim();
+  const span = firstJsonSpan(bounded);
+  if (span) return span.trim();
+  return bounded.trim();
+}
+function firstJsonSpan(text) {
+  const start = firstJsonStart(text);
+  if (start < 0) return void 0;
+  const opener = text[start];
+  const closer = opener === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+    } else if (char === opener) {
+      depth += 1;
+    } else if (char === closer) {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, index + 1);
+    }
+  }
+  return void 0;
+}
+function firstJsonStart(text) {
+  const objectStart = text.indexOf("{");
+  const arrayStart = text.indexOf("[");
+  if (objectStart < 0) return arrayStart;
+  if (arrayStart < 0) return objectStart;
+  return Math.min(objectStart, arrayStart);
+}
+
+// src/middleware/repair.ts
+var import_ai3 = require("ai");
+function repairMiddleware() {
+  return {
+    specificationVersion: "v3",
+    async wrapGenerate({ doGenerate }) {
+      const result = await doGenerate();
+      const content = await Promise.all(
+        result.content.map(async (part) => {
+          if (part.type !== "tool-call" || typeof part.input !== "string") return part;
+          try {
+            JSON.parse(part.input);
+            return part;
+          } catch {
+            const repaired = await (0, import_ai3.parsePartialJson)(part.input);
+            if ((repaired.state === "repaired-parse" || repaired.state === "successful-parse") && repaired.value !== void 0) {
+              return { ...part, input: JSON.stringify(repaired.value) };
+            }
+            return part;
+          }
+        })
+      );
+      return { ...result, content };
+    },
+    wrapStream({ doStream }) {
+      return doStream();
+    }
+  };
+}
+
+// src/middleware/retry.ts
+var import_provider3 = require("@ai-sdk/provider");
+
+// src/middleware/classify.ts
+var import_provider2 = require("@ai-sdk/provider");
+var TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EPIPE"]);
+function isTransientError(error) {
+  return import_provider2.APICallError.isInstance(error) && error.isRetryable === true || isTransientNetworkError(error);
+}
+function isTransientNetworkError(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  if (typeof code === "string" && TRANSIENT_NETWORK_CODES.has(code)) return true;
+  if (error instanceof TypeError) {
+    return /fetch failed|network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|EPIPE/i.test(error.message);
+  }
+  return false;
+}
+
+// src/middleware/retry.ts
+function retryMiddleware({
+  maxRetries = 2,
+  initialDelayInMs = 1e3,
+  backoffFactor = 2
+} = {}) {
+  async function run(call) {
+    let delay = initialDelayInMs;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await call();
+      } catch (error) {
+        if (isAbortError(error)) throw error;
+        if (!isTransientError(error) || attempt >= maxRetries) throw error;
+        const headerDelay = retryAfterMs(error, delay);
+        await sleep(headerDelay ?? delay);
+        delay *= backoffFactor;
+      }
+    }
+  }
+  return {
+    specificationVersion: "v3",
+    wrapGenerate: ({ doGenerate }) => run(doGenerate),
+    wrapStream: ({ doStream }) => run(doStream)
+  };
+}
+function isAbortError(error) {
+  return !!error && typeof error === "object" && error.name === "AbortError";
+}
+function retryAfterMs(error, delay) {
+  if (!import_provider3.APICallError.isInstance(error)) return void 0;
+  const headerMs = parseMs(error.responseHeaders?.["retry-after-ms"]);
+  if (headerMs !== void 0 && shouldHonorRetryAfter(headerMs, delay)) return headerMs;
+  const retryAfter = error.responseHeaders?.["retry-after"];
+  const seconds = parseSeconds(retryAfter);
+  if (seconds !== void 0 && shouldHonorRetryAfter(seconds, delay)) return seconds;
+  return void 0;
+}
+function parseMs(value) {
+  if (!value) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseSeconds(value) {
+  if (!value) return void 0;
+  const seconds = Number.parseFloat(value);
+  if (Number.isFinite(seconds)) return Math.round(seconds * 1e3);
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) return void 0;
+  return date - Date.now();
+}
+function shouldHonorRetryAfter(ms, delay) {
+  return ms >= 0 && (ms < 6e4 || ms < delay);
+}
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/middleware/strip-unsupported-params.ts
+function stripUnsupportedParamsMiddleware(params) {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params: callOptions }) => {
+      const present = params.filter((name) => name in callOptions);
+      if (present.length === 0) return callOptions;
+      const next = { ...callOptions };
+      for (const name of present) {
+        delete next[name];
+      }
+      return next;
+    }
+  };
+}
+
+// src/providers/builtins.ts
+function seedBuiltins() {
+  registerProvider({
+    id: "openai-compatible",
+    label: "OpenAI-compatible",
+    adapter: openaiCompatible,
+    needsBaseURL: true,
+    authModes: ["api-key"],
+    credentialOptional: true,
+    modelAdapter: "openai-responses",
+    baseURLPlaceholder: "https://openrouter.ai/api/v1",
+    defaultModel: "gpt-5.5"
+  });
+  registerProvider({
+    id: "anthropic-compatible",
+    label: "Anthropic-compatible",
+    adapter: anthropicCompatible,
+    needsBaseURL: true,
+    authModes: ["api-key", "bearer-token"],
+    credentialOptional: true,
+    modelAdapter: "anthropic-messages",
+    baseURLPlaceholder: "https://anthropic-proxy.example/messages",
+    defaultModel: "claude-sonnet-4-6"
+  });
+  registerProvider({
+    id: "openai-subscription",
+    label: "OpenAI subscription",
+    adapter: openaiSubscription,
+    needsBaseURL: false,
+    authModes: ["subscription"],
+    subscription: true,
+    modelAdapter: "openai-responses",
+    defaultModel: "gpt-6.1-sol",
+    // RUNX-01: the codex/ChatGPT-subscription Responses backend rejects the output cap
+    // (`max_output_tokens`) with HTTP 400. Strip it at egress for this provider ONLY —
+    // standard OpenAI-compatible `.chat()` endpoints and Anthropic support the cap.
+    // 2026-10-20 (446-11, D-18): it also answers 400 "Unsupported parameter: temperature".
+    unsupportedParams: ["maxOutputTokens", "temperature"]
+  });
+  registerProvider({
+    id: "anthropic-subscription",
+    label: "Anthropic subscription",
+    adapter: anthropicSubscription,
+    needsBaseURL: false,
+    authModes: ["subscription"],
+    subscription: true,
+    modelAdapter: "anthropic-messages",
+    defaultModel: "claude-sonnet-5-5"
+  });
+  registerProvider({
+    id: "gemini",
+    label: "Gemini",
+    adapter: gemini,
+    needsBaseURL: false,
+    authModes: ["api-key"],
+    defaultModel: "gemini-3-flash-preview"
+  });
+}
+
+// src/providers/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function validateDescriptor(descriptor) {
+  if (!descriptor.id?.trim()) {
+    throw new Error("Provider descriptor id is required");
+  }
+  if (!descriptor.label?.trim()) {
+    throw new Error(`Provider descriptor "${descriptor.id}" label is required`);
+  }
+  if (typeof descriptor.adapter !== "function") {
+    throw new Error(`Provider descriptor "${descriptor.id}" adapter is required`);
+  }
+  if (!Array.isArray(descriptor.authModes) || descriptor.authModes.length === 0) {
+    throw new Error(`Provider descriptor "${descriptor.id}" authModes must be a non-empty array`);
+  }
+}
+function registerProvider(descriptor) {
+  validateDescriptor(descriptor);
+  registry.set(descriptor.id, descriptor);
+}
+function getProvider(id) {
+  return registry.get(id);
+}
+function listProviders() {
+  return [...registry.values()];
+}
+function clearProviderRegistry() {
+  registry.clear();
+  seedBuiltins();
+}
+seedBuiltins();
+
+// src/registry.ts
+var import_ai4 = require("ai");
+var import_agent_qa_safety = require("@vostride/agent-qa-safety");
+
+// src/validate.ts
+function validateProfile(profile) {
+  if (profile.provider === "openai-compatible" && !profile.baseURL?.trim()) {
+    throw new Error("OpenAI-Compatible provider requires a baseURL");
+  }
+  if (profile.provider === "anthropic-compatible" && !profile.baseURL?.trim()) {
+    throw new Error("Anthropic-Compatible provider requires a baseURL");
+  }
+  if (profile.headers && profile.provider !== "anthropic-compatible" && profile.provider !== "openai-compatible") {
+    throw new Error(
+      `${displayProvider(profile.provider)} provider custom headers are only supported on anthropic-compatible`
+    );
+  }
+}
+function displayProvider(provider) {
+  switch (provider) {
+    case "openai-compatible":
+      return "OpenAI-Compatible";
+    case "anthropic-compatible":
+      return "Anthropic-Compatible";
+    case "openai-subscription":
+      return "OpenAI Subscription";
+    case "anthropic-subscription":
+      return "Anthropic Subscription";
+    case "gemini":
+      return "Gemini";
+    default:
+      return provider;
+  }
+}
+
+// src/provider-call-report.ts
+var MODEL_CALL_EVENT_KINDS = [
+  "start",
+  "success",
+  "failure"
+];
+var MODEL_CALL_REPORT_ORIGINS = [
+  "openai-chat",
+  "openai-responses",
+  "anthropic-messages",
+  "gemini"
+];
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function providerCallReport(result, origin, mask) {
+  const inputTokens = count(result.usage.inputTokens.total);
+  const outputTokens = count(result.usage.outputTokens.total);
+  const cachedInputTokens = rawCacheCount(result.usage, origin);
+  const modelId = origin === void 0 ? void 0 : result.response?.modelId ?? (origin === "gemini" ? object(result.response?.body)?.modelVersion : void 0);
+  const respondingModelId = typeof modelId === "string" && modelId.length > 0 ? mask(modelId) : void 0;
+  return {
+    ...inputTokens === void 0 ? {} : { inputTokens },
+    ...outputTokens === void 0 ? {} : { outputTokens },
+    ...cachedInputTokens === void 0 ? {} : { cachedInputTokens },
+    ...respondingModelId === void 0 ? {} : { respondingModelId }
+  };
+}
+function rawCacheCount(usage, origin) {
+  const raw = object(usage.raw);
+  if (!raw) return void 0;
+  switch (origin) {
+    case "openai-chat":
+      return count(object(raw.prompt_tokens_details)?.cached_tokens);
+    case "openai-responses":
+      return count(object(raw.input_tokens_details)?.cached_tokens);
+    case "anthropic-messages":
+      return count(raw.cache_read_input_tokens);
+    case "gemini":
+      return count(raw.cachedContentTokenCount);
+    case void 0:
+      return void 0;
+    default: {
+      const exhaustive = origin;
+      return exhaustive;
+    }
+  }
+}
+
+// src/registry.ts
+var MIDDLEWARE = [
+  retryMiddleware(),
+  repairMiddleware(),
+  (0, import_ai4.extractJsonMiddleware)({ transform: extractJsonStrategy }),
+  toolSchemaMiddleware,
+  deriveExamplesMiddleware(),
+  (0, import_ai4.addToolInputExamplesMiddleware)(),
+  // RUNX-04: flag-gated debug logging (AGENT_QA_DEBUG_LLM); catches the raw APICallError first.
+  debugLoggingMiddleware(),
+  // RUNX-01: strip empty-content messages just before the wire.
+  dropEmptyMessagesMiddleware()
+];
+function createModel(profile, auth, mask, overrides = {}, observation = {}) {
+  validateProfile(profile);
+  profile.capabilities ??= resolveCapabilities(profile);
+  const transport = deriveTransport(profile, auth);
+  const descriptor = getProvider(profile.provider);
+  if (!descriptor) {
+    throw new Error(
+      `Unknown provider "${profile.provider}". Supported: ${listProviders().map((provider2) => provider2.id).join(", ")}.`
+    );
+  }
+  const baseProvider = toProviderV3((modelId) => descriptor.adapter(transport, modelId));
+  const provider = (0, import_ai4.customProvider)({
+    languageModels: overrides.languageModels ?? {},
+    fallbackProvider: baseProvider
+  });
+  const onProviderCall = observation.onProviderCall;
+  const onCall = observation.onCall;
+  const origin = overrides.providerReportOrigin ?? (overrides.languageModels?.[profile.model] ? void 0 : descriptor.adapter === openaiCompatible ? "openai-chat" : descriptor.adapter === openaiSubscription ? "openai-responses" : descriptor.adapter === anthropicCompatible || descriptor.adapter === anthropicSubscription ? "anthropic-messages" : descriptor.adapter === gemini ? "gemini" : void 0);
+  const observe = (event) => {
+    try {
+      Promise.resolve(onCall?.(event)).catch(() => {
+      });
+    } catch {
+    }
+  };
+  const start = () => {
+    try {
+      Promise.resolve(onProviderCall?.()).catch(() => {
+      });
+    } catch {
+    }
+    observe({ kind: "start" });
+  };
+  const observedProvider = onProviderCall === void 0 && onCall === void 0 ? provider : (0, import_ai4.wrapProvider)({
+    provider,
+    languageModelMiddleware: {
+      specificationVersion: "v3",
+      wrapGenerate: async ({ doGenerate }) => {
+        start();
+        try {
+          const result = await doGenerate();
+          try {
+            observe({ kind: "success", report: providerCallReport(result, origin, mask) });
+          } catch {
+            observe({ kind: "success", report: {} });
+          }
+          return result;
+        } catch (error) {
+          observe({ kind: "failure" });
+          throw error;
+        }
+      },
+      wrapStream: async ({ doStream }) => {
+        start();
+        try {
+          const result = await doStream();
+          if (onCall === void 0) return result;
+          const reader = result.stream.getReader();
+          let terminal = false;
+          let modelId;
+          const failure = () => {
+            if (!terminal) {
+              terminal = true;
+              observe({ kind: "failure" });
+            }
+          };
+          return {
+            ...result,
+            stream: new ReadableStream({
+              async pull(controller) {
+                try {
+                  const next = await reader.read();
+                  if (next.done) {
+                    failure();
+                    controller.close();
+                    return;
+                  }
+                  const part = next.value;
+                  if (part.type === "response-metadata") modelId = part.modelId;
+                  if (part.type === "error") failure();
+                  if (part.type === "finish" && !terminal) {
+                    terminal = true;
+                    try {
+                      observe({ kind: "success", report: providerCallReport({
+                        usage: part.usage,
+                        response: { modelId }
+                      }, origin, mask) });
+                    } catch {
+                      observe({ kind: "success", report: {} });
+                    }
+                  }
+                  controller.enqueue(part);
+                } catch (error) {
+                  failure();
+                  controller.error(error);
+                }
+              },
+              async cancel(reason) {
+                failure();
+                await reader.cancel(reason);
+              }
+            }, { highWaterMark: 0 })
+          };
+        } catch (error) {
+          observe({ kind: "failure" });
+          throw error;
+        }
+      }
+    }
+  });
+  const middleware = [
+    capabilityUpdateMiddleware(profile),
+    ...descriptor.unsupportedParams?.length ? [stripUnsupportedParamsMiddleware(descriptor.unsupportedParams)] : [],
+    ...MIDDLEWARE,
+    (0, import_agent_qa_safety.createMaskingMiddleware)(mask)
+  ];
+  const registry2 = (0, import_ai4.createProviderRegistry)(
+    { [profile.provider]: observedProvider },
+    { languageModelMiddleware: middleware }
+  );
+  return registry2.languageModel(`${profile.provider}:${profile.model}`);
+}
+function toProviderV3(build) {
+  return {
+    specificationVersion: "v3",
+    languageModel: build,
+    embeddingModel(modelId) {
+      throw new Error(`No embedding model for provider model "${modelId}"`);
+    },
+    imageModel(modelId) {
+      throw new Error(`No image model for provider model "${modelId}"`);
+    }
+  };
+}
+
+// src/vision/resolve-config.ts
+function resolveVisionConfig(servicesVision) {
+  return {
+    screenshotSize: servicesVision?.screenshotSize,
+    effectiveResolution: servicesVision?.effectiveResolution
+  };
+}
+
+// src/vision/resolve-gate.ts
+var TEXT_ONLY_PROMPT_NOTE = [
+  "Visual screenshot is unavailable for this step.",
+  "Rely on the accessibility tree and DOM context for element identification, including roles, names, values, refs, and URLs.",
+  "Verify functional state from the available structured context rather than purely visual appearance."
+].join(" ");
+function visionFromConfig(configured, capabilities) {
+  return configured ?? capabilities.vision;
+}
+function resolveVisionGate(model) {
+  if (model.vision) {
+    return {
+      attachImage: true,
+      captureMode: "full",
+      promptNote: ""
+    };
+  }
+  return {
+    attachImage: false,
+    captureMode: "textOnly",
+    promptNote: TEXT_ONLY_PROMPT_NOTE
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FAMILIES,
+  MODEL_CALL_EVENT_KINDS,
+  MODEL_CALL_REPORT_ORIGINS,
+  MODEL_CATALOG,
+  UNKNOWN_FLOOR,
+  anthropicCompatible,
+  anthropicSubscription,
+  capabilityKey,
+  capabilityUpdateMiddleware,
+  clearProviderRegistry,
+  compactLogs,
+  createModel,
+  createTokenAccounting,
+  debugLoggingMiddleware,
+  deriveExamplesMiddleware,
+  deriveTransport,
+  dropEmptyMessagesMiddleware,
+  extractJsonStrategy,
+  fetchLiveModels,
+  gemini,
+  getModelCatalog,
+  getObservedWindow,
+  getProvider,
+  getProviderOptions,
+  guardBlob,
+  guardToolOutput,
+  isContextLengthOverflow,
+  isContextOverflow,
+  listProviders,
+  matchFamily,
+  mergeCatalog,
+  openaiCompatible,
+  openaiSubscription,
+  overrideStore,
+  parseRealWindow,
+  registerProvider,
+  repairMiddleware,
+  resolveCapabilities,
+  resolveVisionConfig,
+  resolveVisionGate,
+  retryMiddleware,
+  stripUnsupportedParamsMiddleware,
+  toolSchemaMiddleware,
+  validateProfile,
+  visionFromConfig
+});
+//# sourceMappingURL=index.cjs.map