@visual-z/xeno 0.8.4 → 0.9.0

package/src/runtime/program-status.ts

@@ -1,38 +0,0 @@
-import { encodeProgramStatus, PROGRAM_STATUS_QUERY, programStatusReply, type ProgramStatus } from "../core/program-status.ts";
-
-/** Terminal transport only. Capability detection has no relationship to agent evidence. */
-export class ProgramStatusReporter {
-  private readonly write: (text: string) => void;
-  private readonly id: string;
-  private readonly mode: "auto" | "on" | "off";
-  private supported = false;
-  private started = false;
-  private closed = false;
-  private last: ProgramStatus = { state: "idle" };
-  private emitted = "";
-  constructor(options: { write: (text: string) => void; id: string; tty: boolean; mode?: string; multiplexed?: boolean }) {
-    this.write = options.write; this.id = options.id;
-    this.mode = !options.tty || options.mode === "0" ? "off" : options.mode === "1" ? "on" : options.multiplexed ? "off" : "auto";
-  }
-  start(): void {
-    if (this.started || this.closed) return; this.started = true;
-    if (this.mode === "auto") this.write(PROGRAM_STATUS_QUERY);
-    if (this.mode === "on") { this.supported = true; this.flush(); }
-  }
-  receive(sequence: string): void {
-    if (this.closed || !this.started || this.mode !== "auto" || !programStatusReply(sequence)) return;
-    this.supported = true; this.flush();
-  }
-  update(status: ProgramStatus): void { this.last = { ...status }; if (this.started) this.flush(); }
-  private flush(): void {
-    if (this.closed || !this.supported) return;
-    const sequence = encodeProgramStatus(this.last, this.id);
-    if (sequence !== this.emitted) { this.emitted = sequence; this.write(sequence); }
-  }
-  close(): void {
-    if (this.closed) return;
-    // done/error are durable terminal records. Clear only our own transient record.
-    if (this.supported && this.last.state !== "done" && this.last.state !== "error") this.write(encodeProgramStatus({ state: "clear" }, this.id));
-    this.closed = true;
-  }
-}

package/src/runtime/progress.ts

@@ -1,26 +0,0 @@
-/** Display updates are transient; only the completed operation may become a durable result. */
-export async function* withProgress<T, E>(start: (emit: (event: E) => void) => Promise<T>): AsyncGenerator<E, T> {
-  const queue: E[] = [];
-  let wake: (() => void) | undefined;
-  let accepting = true;
-  const box: { result?: { ok: true; value: T } | { ok: false; error: unknown } } = {};
-  const pending = start(event => { if (accepting) queue.push(event); wake?.(); }).then(
-    value => { box.result = { ok: true, value }; wake?.(); },
-    error => { box.result = { ok: false, error }; wake?.(); },
-  );
-  try {
-    while (box.result === undefined || queue.length) {
-      if (queue.length) { yield queue.shift()!; continue; }
-      await new Promise<void>(resolve => { wake = resolve; });
-      wake = undefined;
-    }
-  } finally {
-    accepting = false;
-    queue.length = 0;
-    await pending;
-  }
-  await pending;
-  if (!box.result) throw new Error("operation settled without a result");
-  if (!box.result.ok) throw box.result.error;
-  return box.result.value;
-}

package/src/runtime/provider-access.ts

@@ -1,21 +0,0 @@
-import type { ModelSpec } from "./model.ts";
-
-/** Secrets are not model metadata. Enumerating/serializing a model cannot expose config values. */
-export interface ProviderAccess {
-  apiKey?: string;
-  headers?: Record<string, string | null>;
-  env?: Record<string, string>;
-  auth?: false | "ambient";
-  authHeader?: boolean | string;
-  options?: Record<string, unknown>;
-  body?: Record<string, unknown>;
-  invalid?: string;
-}
-const access = new WeakMap<ModelSpec, ProviderAccess>();
-export function setProviderAccess(model: ModelSpec, value: ProviderAccess): void { access.set(model, value); }
-export function providerAccess(model: ModelSpec): ProviderAccess { return access.get(model) ?? {}; }
-export function hasProviderAccess(model: ModelSpec): boolean { return access.has(model); }
-export function copyProviderAccess(from: ModelSpec, to: ModelSpec): void {
-  const value = access.get(from);
-  if (value) access.set(to, value);
-}

package/src/runtime/provider-connect.ts

@@ -1,109 +0,0 @@
-/**
- * The `models.json` edit `/provider` makes for a connected provider, as a pure transform.
- *
- * The file stays the single source of model configuration and keeps the
- * documented `providers.<id>` shape (docs/providers.md), so a connected
- * provider is indistinguishable from a hand-written one and `/reload`,
- * startup and `--list-models` need no second code path. Secrets never enter
- * it: keys go to `auth.json` (0600) or stay `$ENV` references.
- *
- * - Catalog provider: `allowlist` is the chosen ids, so the picker offers
- *   exactly what the user enabled; ids the live listing has but the catalog
- *   lacks are added under `models`.
- * - Custom endpoint: `api` + `baseUrl` + `models`. Limits/capabilities are
- *   copied from a catalog model with the same id when the listing lacks
- *   them (a gateway serving `claude-sonnet-4-5` has that model's limits);
- *   price never is, because gateway billing is not the vendor's.
- */
-import type { ModelSpec } from "./model.ts";
-import type { ProviderApi } from "./provider-protocols.ts";
-import type { DiscoveredModel } from "./model-discovery.ts";
-
-export interface ConnectRequest {
-  id: string;
-  name: string;
-  api: ProviderApi;
-  baseUrl: string;
-  /** True when the provider ships in the catalog with its own models. */
-  catalog: boolean;
-  /** Catalog default base URL; an equal value is not written as an override. */
-  catalogBaseUrl?: string;
-  keyless: boolean;
-  /** `$VAR` / `{env:VAR}` reference kept in config instead of a stored key. */
-  keyReference?: string;
-  chosen: readonly DiscoveredModel[];
-}
-
-function record(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-/** The bare model name a gateway may prefix: `anthropic/claude-x` → `claude-x`. */
-function bare(id: string): string {
-  return id.slice(id.lastIndexOf("/") + 1).toLowerCase();
-}
-
-export function catalogTwin(id: string, catalog: readonly ModelSpec[]): ModelSpec | undefined {
-  const exact = catalog.find(model => model.id === id);
-  if (exact) return exact;
-  const name = bare(id);
-  return catalog.find(model => bare(model.id) === name);
-}
-
-export function modelEntry(model: DiscoveredModel, catalog: readonly ModelSpec[]): Record<string, unknown> {
-  const twin = catalogTwin(model.id, catalog);
-  const entry: Record<string, unknown> = {};
-  const name = model.name ?? twin?.name;
-  if (name && name !== model.id) entry["name"] = name;
-  const contextWindow = model.contextWindow ?? twin?.contextWindow;
-  const maxTokens = model.maxTokens ?? twin?.maxTokens;
-  if (contextWindow) entry["contextWindow"] = contextWindow;
-  if (maxTokens) entry["maxTokens"] = maxTokens;
-  if (twin?.reasoning) entry["reasoning"] = true;
-  if (twin?.input?.includes("image")) entry["input"] = [...twin.input];
-  return entry;
-}
-
-export function applyConnect(json: unknown, request: ConnectRequest, catalog: readonly ModelSpec[]): Record<string, unknown> {
-  // The legacy flat array form is still a valid file; keep its rows.
-  const root: Record<string, unknown> = Array.isArray(json) ? { models: json } : record(json) ? { ...json } : {};
-  const providers = record(root["providers"]) ? { ...root["providers"] } : {};
-  const previous = record(providers[request.id]) ? providers[request.id] as Record<string, unknown> : {};
-  const known = new Set(catalog.filter(model => model.provider === request.id).map(model => model.id));
-  const entry: Record<string, unknown> = { ...previous };
-  for (const key of ["allowlist", "whitelist", "models", "disabled", "enabled"]) delete entry[key];
-  if (!request.catalog) {
-    entry["name"] = request.name;
-    entry["api"] = request.api;
-    // Unknown Chat Completions gateways: the lowest common denominator. The
-    // `developer` role, `store` and `max_completion_tokens` are OpenAI-only
-    // and are the usual 400s from DeepSeek-, vLLM- and one-api-style servers.
-    if (request.api === "openai-completions" && !record(entry["compat"])) entry["compat"] = { supportsDeveloperRole: false, supportsStore: false, maxTokensField: "max_tokens" };
-  }
-  if (!request.catalog || request.baseUrl !== request.catalogBaseUrl) entry["baseUrl"] = request.baseUrl;
-  else delete entry["baseUrl"];
-  if (request.keyless) entry["auth"] = false;
-  else if (entry["auth"] === false) delete entry["auth"];
-  if (request.keyReference) entry["apiKey"] = request.keyReference;
-  const models: Record<string, unknown> = {};
-  for (const model of request.chosen) {
-    if (request.catalog && known.has(model.id)) continue;
-    models[model.id] = modelEntry(model, catalog);
-  }
-  if (Object.keys(models).length) entry["models"] = models;
-  if (request.catalog) entry["allowlist"] = request.chosen.map(model => model.id);
-  providers[request.id] = entry;
-  root["providers"] = providers;
-  return root;
-}
-
-/** Remove what `/provider` wrote for a provider; other providers and flat rows are untouched. */
-export function applyDisconnect(json: unknown, id: string): Record<string, unknown> {
-  const root: Record<string, unknown> = Array.isArray(json) ? { models: json } : record(json) ? { ...json } : {};
-  if (record(root["providers"])) {
-    const providers = { ...root["providers"] };
-    delete providers[id];
-    root["providers"] = providers;
-  }
-  return root;
-}

package/src/runtime/provider-presets.ts

@@ -1,98 +0,0 @@
-/**
- * What `/provider` offers for custom endpoints before the user types anything.
- *
- * A preset names a catalog provider (whose API, base URL and model metadata
- * already ship in model-data) or a custom endpoint family. Order is the
- * "Popular" section, modelled on OpenCode's PROVIDER_PRIORITY and magpie's
- * vendor list; everything else in the catalog stays reachable by search.
- * Key URLs are where a user actually gets a key, shown as a hint.
- */
-import { SOURCE_PROVIDERS } from "./model-data.ts";
-import type { ProviderApi } from "./provider-protocols.ts";
-
-export interface ProviderPreset {
-  /** Catalog provider id, or the suggested id for a custom endpoint. */
-  id: string;
-  label: string;
-  api: ProviderApi;
-  baseUrl: string;
-  /** Present for catalog providers: their models carry metadata already. */
-  catalog: boolean;
-  /** Custom endpoints ask for id and URL; keyless ones skip the key. */
-  custom: boolean;
-  keyless?: boolean;
-  keyUrl?: string;
-  hint?: string;
-}
-
-const POPULAR: readonly { id: string; keyUrl?: string; hint?: string }[] = [
-  { id: "anthropic", keyUrl: "https://console.anthropic.com/settings/keys" },
-  { id: "openai", keyUrl: "https://platform.openai.com/api-keys" },
-  { id: "google", keyUrl: "https://aistudio.google.com/apikey", hint: "Gemini API" },
-  { id: "deepseek", keyUrl: "https://platform.deepseek.com/api_keys" },
-  { id: "openrouter", keyUrl: "https://openrouter.ai/keys", hint: "one key, many vendors" },
-  { id: "moonshotai-cn", keyUrl: "https://platform.moonshot.cn/console/api-keys", hint: "Kimi" },
-  { id: "kimi-coding", keyUrl: "https://www.kimi.com/coding", hint: "Kimi Coding plan" },
-  { id: "zhipuai", keyUrl: "https://open.bigmodel.cn/usercenter/apikeys", hint: "GLM" },
-  { id: "zhipuai-coding-plan", keyUrl: "https://open.bigmodel.cn/usercenter/apikeys", hint: "GLM Coding plan" },
-  { id: "siliconflow-cn", keyUrl: "https://cloud.siliconflow.cn/account/ak" },
-  { id: "alibaba-cn", keyUrl: "https://bailian.console.aliyun.com/?apiKey=1", hint: "Qwen / DashScope" },
-  { id: "volcengine", keyUrl: "https://console.volcengine.com/ark", hint: "Doubao / Ark" },
-  { id: "minimax-cn", keyUrl: "https://platform.minimaxi.com/user-center/basic-information/interface-key" },
-  { id: "xai", keyUrl: "https://console.x.ai" },
-  { id: "groq", keyUrl: "https://console.groq.com/keys" },
-  { id: "mistral", keyUrl: "https://console.mistral.ai/api-keys" },
-];
-
-/** Custom families: the four wire formats a generic endpoint can speak. */
-export const CUSTOM_PRESETS: readonly ProviderPreset[] = [
-  { id: "custom-openai", label: "OpenAI-compatible endpoint", api: "openai-completions", baseUrl: "https://", catalog: false, custom: true, hint: "Chat Completions · /v1/chat/completions" },
-  { id: "custom-responses", label: "OpenAI Responses endpoint", api: "openai-responses", baseUrl: "https://", catalog: false, custom: true, hint: "Responses API · /v1/responses" },
-  { id: "custom-anthropic", label: "Anthropic-compatible endpoint", api: "anthropic-messages", baseUrl: "https://", catalog: false, custom: true, hint: "Messages API · /v1/messages" },
-  { id: "custom-gemini", label: "Gemini-compatible endpoint", api: "google-generative-ai", baseUrl: "https://generativelanguage.googleapis.com/v1beta", catalog: false, custom: true, hint: "generateContent" },
-  { id: "ollama", label: "Ollama (local)", api: "openai-completions", baseUrl: "http://127.0.0.1:11434/v1", catalog: false, custom: true, keyless: true, hint: "no key needed" },
-  { id: "lmstudio", label: "LM Studio (local)", api: "openai-completions", baseUrl: "http://127.0.0.1:1234/v1", catalog: false, custom: true, keyless: true, hint: "no key needed" },
-];
-
-function fromCatalog(id: string, extra: { keyUrl?: string; hint?: string } = {}): ProviderPreset | undefined {
-  const source = SOURCE_PROVIDERS[id];
-  if (!source?.api || !source.baseUrl) return undefined;
-  return { id, label: source.name, api: source.api, baseUrl: source.baseUrl, catalog: true, custom: false,
-    ...(extra.keyUrl ? { keyUrl: extra.keyUrl } : {}), ...(extra.hint ? { hint: extra.hint } : {}) };
-}
-
-export function popularPresets(): ProviderPreset[] {
-  return POPULAR.flatMap(entry => fromCatalog(entry.id, entry) ?? []);
-}
-
-export function presetById(id: string): ProviderPreset | undefined {
-  return CUSTOM_PRESETS.find(preset => preset.id === id) ?? fromCatalog(id, POPULAR.find(entry => entry.id === id));
-}
-
-/** Provider ids are config keys and auth.json keys: OpenCode's rule. */
-export function validProviderId(id: string): boolean {
-  return /^[a-z0-9][a-z0-9_-]{0,63}$/.test(id);
-}
-
-/**
- * The valid id a rejected one most likely meant ("My Gateway" → "my-gateway"),
- * or "" when nothing Latin survives ("网关"). Only offered in the error, never
- * applied silently: the id becomes a config and auth.json key the user will
- * type in /model, so they should see it before it is saved.
- */
-export function slugProviderId(raw: string): string {
-  if (validProviderId(raw)) return raw;
-  return raw.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, 64).replace(/-+$/, "");
-}
-
-/** A readable default id from a URL host: api.example.com → example. */
-export function suggestProviderId(baseUrl: string, taken: ReadonlySet<string>): string {
-  let host = "custom";
-  try { host = new URL(baseUrl).hostname; } catch { /* keep default */ }
-  const parts = host.split(".").filter(part => !["api", "www", "openai", "gateway", "com", "cn", "net", "io", "ai", "org", "dev", "co"].includes(part));
-  let base = (parts.at(-1) ?? "custom").toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+/, "") || "custom";
-  if (/^\d/.test(base) || base === "127" || host === "localhost") base = "local";
-  let id = base, n = 2;
-  while (taken.has(id)) id = `${base}-${n++}`;
-  return id;
-}

package/src/runtime/provider-protocols.ts

@@ -1,29 +0,0 @@
-/** Protocol vocabulary is local; SDK types and IO never enter core (D13). */
-export const PROVIDER_APIS = [
-  "anthropic-messages", "openai-completions", "openai-responses", "google-generative-ai",
-  "google-vertex", "bedrock-converse-stream", "azure-openai-responses", "openai-codex-responses",
-  "mistral-conversations", "pi-messages",
-] as const;
-export type ProviderApi = typeof PROVIDER_APIS[number];
-export function isProviderApi(value: unknown): value is ProviderApi {
-  return typeof value === "string" && (PROVIDER_APIS as readonly string[]).includes(value);
-}
-
-/** SDK dispatch from OpenCode's model-level `provider.npm` before provider defaults. */
-export const SDK_APIS: Readonly<Record<string, ProviderApi>> = {
-  "@ai-sdk/anthropic": "anthropic-messages",
-  "@ai-sdk/openai": "openai-responses",
-  "@ai-sdk/openai-compatible": "openai-completions",
-  "@openrouter/ai-sdk-provider": "openai-completions",
-  "@ai-sdk/groq": "openai-completions",
-  "@ai-sdk/cerebras": "openai-completions",
-  "@ai-sdk/deepinfra": "openai-completions",
-  "@ai-sdk/togetherai": "openai-completions",
-  "@ai-sdk/xai": "openai-completions",
-  "@ai-sdk/mistral": "mistral-conversations",
-  "@ai-sdk/google": "google-generative-ai",
-  "@ai-sdk/google-vertex": "google-vertex",
-  "@ai-sdk/amazon-bedrock": "bedrock-converse-stream",
-  "@ai-sdk/azure": "azure-openai-responses",
-  "@ai-sdk/gateway": "anthropic-messages",
-};

package/src/runtime/provider-request.ts

@@ -1,87 +0,0 @@
-import { providerEnvironment, resolveKeyValue, type ResolveEffects } from "./auth.ts";
-import { providerAccess } from "./provider-access.ts";
-import type { ModelSpec } from "./model.ts";
-import { GROK_PROVIDER, GROK_BASE_URL, GROK_PROTOCOL_VERSION } from "./oauth.ts";
-import { XENO_VERSION } from "./version.ts";
-
-const SDK_IDENTITY_HEADERS = ["x-app", "editor-version", "editor-plugin-version", "copilot-integration-id", "http-referer", "x-title"];
-
-/** D18/D16: a protocol SDK may not silently identify xeno as a different product. */
-function clientIdentity(headers: Headers): void {
-  headers.set("User-Agent", `xeno/${XENO_VERSION}`);
-  for (const name of SDK_IDENTITY_HEADERS) headers.delete(name);
-  if (headers.has("originator")) headers.set("originator", "xeno");
-  const beta = headers.get("anthropic-beta");
-  if (beta) headers.set("anthropic-beta", beta.split(",").filter(value => !value.trim().startsWith("claude-code-")).join(","));
-}
-
-export function requestEffects(): ResolveEffects {
-  return { env: name => process.env[name], run: command => {
-    const result = Bun.spawnSync(["bash", "-lc", command]);
-    if (result.exitCode !== 0) throw new Error("credential command failed");
-    return new TextDecoder().decode(result.stdout);
-  } };
-}
-
-export function providerRequest(spec: ModelSpec, key: string, effects: ResolveEffects = requestEffects(), fetchImpl: typeof fetch = globalThis.fetch, oauth = false): {
-  baseUrl: string; env: Record<string, string>; headers: Record<string, string | null>; fetch: typeof fetch;
-  options: Record<string, unknown>; body: Record<string, unknown>; key?: string;
-} {
-  const access = providerAccess(spec);
-  if (access.invalid) throw new Error(access.invalid);
-  const scoped = providerEnvironment(spec, effects);
-  const env = scoped.env;
-  const resolve = (value: string, field: string) => {
-    const resolved = resolveKeyValue(value, scoped.effects);
-    if (!resolved.ok) throw new Error(`${spec.provider} ${field}: could not resolve configured value`);
-    return resolved.key;
-  };
-  let baseUrl = spec.baseUrl ?? (spec.api === "anthropic-messages" ? "https://api.anthropic.com" : "");
-  if (baseUrl) baseUrl = resolve(baseUrl, "baseUrl");
-  if (baseUrl && !/^https?:\/\//.test(baseUrl)) throw new Error(`${spec.provider} baseUrl must use http or https`);
-  const headers: Record<string, string | null> = { ...spec.defaultHeaders };
-  for (const [name, value] of Object.entries(access.headers ?? {})) headers[name] = value === null ? null : resolve(value, `headers.${name}`);
-  if (spec.provider === GROK_PROVIDER) {
-    if (baseUrl.replace(/\/$/, "") !== GROK_BASE_URL) throw new Error("Grok account tokens require the official inference proxy");
-    // These select the auth protocol and backend; the User-Agent still identifies xeno (D18).
-    headers["X-XAI-Token-Auth"] = "xai-grok-cli";
-    headers["x-grok-model-override"] = spec.wireId ?? spec.id;
-    headers["x-grok-client-version"] = GROK_PROTOCOL_VERSION;
-    headers["x-grok-client-identifier"] = "xeno";
-  }
-  const anthropicOAuth = spec.api === "anthropic-messages" && spec.provider !== "github-copilot" && (oauth || key.includes("sk-ant-oat"));
-  const noAutomaticAuth = access.auth === false || access.authHeader === false || typeof access.authHeader === "string" || anthropicOAuth;
-  if (noAutomaticAuth && (spec.api === "google-generative-ai" || spec.api === "google-vertex")) {
-    throw new Error(`${spec.api} owns API-key authentication; use apiKey or an OpenAI-compatible local endpoint`);
-  }
-  if (noAutomaticAuth && spec.api === "bedrock-converse-stream") env["AWS_BEDROCK_SKIP_AUTH"] = "1";
-  if (typeof access.authHeader === "string") headers[access.authHeader] = key;
-  if (anthropicOAuth && access.auth !== false && access.authHeader !== false) {
-    headers["authorization"] = `Bearer ${key}`;
-    headers["anthropic-beta"] = "oauth-2025-04-20";
-  }
-  // Apply the same identity to native SDKs which own their HTTP stack.
-  const identity = new Headers();
-  for (const [name, value] of Object.entries(headers)) if (value !== null) identity.set(name, value);
-  clientIdentity(identity);
-  for (const name of Object.keys(headers)) if (!identity.has(name)) headers[name] = null;
-  identity.forEach((value, name) => { headers[name] = value; });
-  delete headers["user-agent"];
-  headers["User-Agent"] = `xeno/${XENO_VERSION}`;
-  // SDKs still require a key to construct local clients. The placeholder never leaves this boundary.
-  const privateKey = noAutomaticAuth ? "xeno-keyless-local" : key || undefined;
-  const transport = (async (input: RequestInfo | URL, init?: RequestInit) => {
-    const request = new Request(input, init);
-    const grokAccount = spec.provider === GROK_PROVIDER;
-    // Check the SDK's final target too, and never forward an account token through a redirect.
-    if (grokAccount && new URL(request.url).origin !== new URL(GROK_BASE_URL).origin) {
-      throw new Error("Grok account tokens require the official inference proxy");
-    }
-    const nextHeaders = new Headers(request.headers);
-    if (noAutomaticAuth) for (const name of ["authorization", "x-api-key", "api-key", "x-goog-api-key"]) nextHeaders.delete(name);
-    for (const [name, value] of Object.entries(headers)) { if (value === null) nextHeaders.delete(name); else nextHeaders.set(name, value); }
-    clientIdentity(nextHeaders);
-    return fetchImpl(new Request(request, { headers: nextHeaders, ...(grokAccount ? { redirect: "error" } : {}) }));
-  }) as typeof fetch;
-  return { baseUrl, env, headers, fetch: transport, options: access.options ?? {}, body: access.body ?? {}, ...(privateKey ? { key: privateKey } : {}) };
-}

package/src/runtime/provider-tool-policy.ts

@@ -1,33 +0,0 @@
-/** D6: native request controls may change; frozen system and tool declarations may not. */
-import { assertNever } from "../core/exhaustive.ts";
-import type { Api } from "./model.ts";
-
-export interface ProviderSendOptions { toolUse: "disabled" }
-
-export function supportsToolDisabling(api: Api): boolean {
-  // Bedrock's SDK implements none by deleting toolConfig. It cannot preserve D6.
-  switch (api) {
-    case "anthropic-messages": case "openai-completions": case "openai-responses": case "azure-openai-responses": case "openai-codex-responses":
-    case "google-generative-ai": case "google-vertex": case "mistral-conversations": case "pi-messages": return true;
-    case "bedrock-converse-stream": return false;
-    default: return assertNever(api, "tool disabling capability");
-  }
-}
-const object = (value: unknown): Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
-
-/** Called after provider body overrides, at the last native payload boundary. */
-export function disablePayloadTools(api: Api, payload: Record<string, unknown>): Record<string, unknown> {
-  switch (api) {
-    case "anthropic-messages": return { ...payload, tool_choice: { type: "none" } };
-    case "openai-completions": case "openai-responses": case "azure-openai-responses": case "openai-codex-responses":
-      return { ...payload, tool_choice: "none" };
-    case "google-generative-ai": case "google-vertex": {
-      const config = object(payload["config"]), toolConfig = object(config["toolConfig"]);
-      return { ...payload, config: { ...config, toolConfig: { ...toolConfig, functionCallingConfig: { mode: "NONE" } } } };
-    }
-    case "mistral-conversations": return { ...payload, toolChoice: "none" };
-    case "pi-messages": return { ...payload, options: { ...object(payload["options"]), toolChoice: "none" } };
-    case "bedrock-converse-stream": throw new Error("Bedrock cannot disable tools while preserving frozen definitions");
-    default: return assertNever(api, "tool disabling protocol");
-  }
-}