@vellumai/assistant 0.12.6-staging.3 → 0.12.7-staging.1

package/src/i18n/assistant-text.ts

@@ -0,0 +1,18 @@
+/** Resolve persisted daemon-authored assistant text at a presentation edge. */
+
+import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
+import { isMessageKey, t } from "./messages.js";
+
+export function resolveStoredMessageText(
+  text: string,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  const trimmed = text.trim();
+  if (!isMessageKey(trimmed)) {
+    return text;
+  }
+  const start = text.indexOf(trimmed);
+  return `${text.slice(0, start)}${t(trimmed, locale)}${text.slice(
+    start + trimmed.length,
+  )}`;
+}

package/src/i18n/index.ts

@@ -1,3 +1,4 @@
+export { resolveStoredMessageText } from "./assistant-text.js";
 export {
   DEFAULT_LOCALE,
   isSupportedLocale,

package/src/i18n/messages.ts

@@ -16,6 +16,7 @@ import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
 export const MESSAGE_KEYS = {
   CONVERSATION_TITLE_GENERATING: "conversation.title.generating",
   CONVERSATION_TITLE_UNTITLED: "conversation.title.untitled",
+  AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP: "agentLoop.unparseableToolRetryStop",
   PLUGIN_MCP_OAUTH_CREDENTIALS_UNCHECKED:
     "plugin.uninstall.mcp_oauth_credentials_unchecked",
 } as const;
@@ -27,30 +28,40 @@ export const MESSAGE_CATALOGS: Record<
   Record<MessageKey, string>
 > = {
   en: {
+    "agentLoop.unparseableToolRetryStop":
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.",
     "conversation.title.generating": "Generating title...",
     "conversation.title.untitled": "Untitled Conversation",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "Credential storage is unavailable, so historical plugin MCP OAuth credentials could not be checked.",
   },
   es: {
+    "agentLoop.unparseableToolRetryStop":
+      "Me detuve después de varias llamadas de herramienta con formato incorrecto para evitar que esta conversación creciera indefinidamente. Inténtalo de nuevo o cambia de modelo si el problema continúa.",
     "conversation.title.generating": "Generando título...",
     "conversation.title.untitled": "Sin título",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "El almacenamiento de credenciales no está disponible, por lo que no se pudieron comprobar las credenciales históricas de OAuth de MCP del plugin.",
   },
   ru: {
+    "agentLoop.unparseableToolRetryStop":
+      "Выполнение остановлено после нескольких некорректных вызовов инструментов, чтобы этот разговор не рос бесконечно. Попробуйте ещё раз или смените модель, если проблема не исчезнет.",
     "conversation.title.generating": "Создание названия...",
     "conversation.title.untitled": "Без названия",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "Хранилище учетных данных недоступно, поэтому не удалось проверить сохраненные учетные данные OAuth MCP плагина.",
   },
   zh: {
+    "agentLoop.unparseableToolRetryStop":
+      "在工具调用多次格式错误后，我已停止运行，以免此对话无限增长。请重试；如果问题仍然存在，请切换模型。",
     "conversation.title.generating": "标题生成中...",
     "conversation.title.untitled": "无标题",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "凭据存储不可用，因此无法检查该插件之前的 MCP OAuth 凭据。",
   },
   "zh-TW": {
+    "agentLoop.unparseableToolRetryStop":
+      "在工具呼叫多次格式錯誤後，我已停止執行，以免此對話無限增長。請重試；如果問題仍然存在，請切換模型。",
     "conversation.title.generating": "標題產生中...",
     "conversation.title.untitled": "未命名",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":

package/src/ipc/routes/__tests__/route-adapter.test.ts

@@ -41,6 +41,7 @@ interface SchemaEntry {
   policy: {
     requiredScopes: string[];
     allowedPrincipalTypes: string[];
+    allowedTrustClasses: string[];
   } | null;
 }
 
@@ -130,6 +131,7 @@ describe("routeDefinitionsToIpcMethods — schema shape", () => {
         .object({
           requiredScopes: z.array(z.string()),
           allowedPrincipalTypes: z.array(z.string()),
+          allowedTrustClasses: z.array(z.string()),
         })
         .nullable(),
     });
@@ -241,4 +243,42 @@ describe("routeDefinitionsToIpcMethods — policy serialization", () => {
     expect(schema[0].policy?.requiredScopes).toEqual(["settings.write"]);
     expect(schema[1].policy?.requiredScopes).toEqual(["settings.write"]);
   });
+
+  test("a policy declaring no trust classes ships guardian only", async () => {
+    // The gateway is the sole policy check on the IPC path, so the
+    // effective value must cross the wire rather than be re-derived
+    // there from an absent field.
+    const routes: RouteDefinition[] = [
+      defineRoute({
+        operationId: "settings_read",
+        endpoint: "settings",
+        policy: {
+          requiredScopes: ["settings.read"],
+          allowedPrincipalTypes: ["actor"],
+        },
+      }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema[0].policy?.allowedTrustClasses).toEqual(["guardian"]);
+  });
+
+  test("declared trust classes ship verbatim", async () => {
+    const routes: RouteDefinition[] = [
+      defineRoute({
+        operationId: "chat_send",
+        endpoint: "chat",
+        method: "POST",
+        policy: {
+          requiredScopes: ["chat.write"],
+          allowedPrincipalTypes: ["actor"],
+          allowedTrustClasses: ["guardian", "trusted_contact"],
+        },
+      }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema[0].policy?.allowedTrustClasses).toEqual([
+      "guardian",
+      "trusted_contact",
+    ]);
+  });
 });

package/src/ipc/routes/route-adapter.ts

@@ -8,6 +8,7 @@
  * RouteDefinition; no lookup or derivation happens here.
  */
 
+import { GUARDIAN_ONLY } from "../../runtime/auth/route-policy.js";
 import type { RouteDefinition } from "../../runtime/routes/types.js";
 
 function isIpcEligible(r: RouteDefinition): boolean {
@@ -22,6 +23,10 @@ function isIpcEligible(r: RouteDefinition): boolean {
  * unprotected (e.g. health, debug). The gateway respects that and
  * skips enforcement. `policy: { ... }` carries the same scopes /
  * principal types the daemon's HTTP path enforces via `enforcePolicy()`.
+ *
+ * `allowedTrustClasses` is always present on a non-null policy, resolved
+ * to {@link GUARDIAN_ONLY} when the route declares none, so the wire
+ * carries the effective value and no default is duplicated gateway-side.
  */
 interface IpcRouteSchemaEntry {
   operationId: string;
@@ -30,6 +35,7 @@ interface IpcRouteSchemaEntry {
   policy: {
     requiredScopes: string[];
     allowedPrincipalTypes: string[];
+    allowedTrustClasses: string[];
   } | null;
 }
 
@@ -44,6 +50,9 @@ function toSchemaEntry(r: RouteDefinition): IpcRouteSchemaEntry {
           // shape doesn't carry the `Scope` / `PrincipalType` narrowing.
           requiredScopes: [...r.policy.requiredScopes],
           allowedPrincipalTypes: [...r.policy.allowedPrincipalTypes],
+          allowedTrustClasses: [
+            ...(r.policy.allowedTrustClasses ?? GUARDIAN_ONLY),
+          ],
         }
       : null,
   };

package/src/notifications/README.md

@@ -216,7 +216,7 @@ Each policy defines:
 | `start_new_conversation`         | Pairs the delivery with a new or reused conversation, or appends to the producing one (see Conversation Pairing below).                                       | `vellum`                                                                                     |
 | `continue_existing_conversation` | Resolves the destination chat's home conversation, creating one on first delivery. The delivered post is written there only once the channel acknowledges it. | `telegram`, `slack`, `discord`, and the non-deliverable `whatsapp`, `email`, `a2a`, `plugin` |
 | `push_only`                      | Pairs nothing. The push deep-links through the vellum delivery's conversation.                                                                                | `platform`                                                                                   |
-| `not_deliverable`                | Channel cannot receive notifications. Pairing returns null IDs.                                                                                               | `phone`                                                                                      |
+| `not_deliverable`                | Channel cannot receive notifications. Pairing returns null IDs.                                                                                               | `phone`, `vellum-shared`                                                                     |
 
 ### Helper Functions
 

package/src/notifications/signal.ts

@@ -27,6 +27,10 @@ export const NOTIFICATION_SOURCE_CHANNELS = [
   { id: "a2a", description: "Agent-to-agent protocol channel" },
   { id: "discord", description: "Discord channel" },
   { id: "plugin", description: "Channel brought by an installed plugin" },
+  {
+    id: "vellum-shared",
+    description: "Conversation a guardian shared with a contact",
+  },
   { id: "scheduler", description: "Scheduled task runner (reminders, cron)" },
   { id: "watcher", description: "File/event watcher subsystem" },
 ] as const;

package/src/persistence/conversation-key-store.ts

@@ -36,6 +36,13 @@ export function _resetFirstConversationSeenForTesting(): void {
   firstConversationSeen = false;
 }
 
+export function recordStandardConversationCreated(): void {
+  if (firstConversationSeen) {
+    cleanupBootstrapFiles("new conversation created after onboarding");
+  }
+  firstConversationSeen = true;
+}
+
 export interface ConversationKeyMapping {
   id: string;
   conversationKey: string;
@@ -174,6 +181,8 @@ export function getOrCreateConversation(
      * what every caller did before this option existed.
      */
     origin?: ChannelId;
+    /** The caller records creation after required setup succeeds. */
+    deferBootstrapCleanup?: boolean;
   },
 ): {
   conversationId: string;
@@ -233,17 +242,6 @@ export function getOrCreateConversation(
       };
     }
 
-    // The first standard conversation is the onboarding one, so BOOTSTRAP.md
-    // survives its whole duration and any later standard create means
-    // onboarding is over. Background rows stay inert: a hidden side thread
-    // minted before the user's first visible chat must not consume that slot.
-    if (conversationType === "standard") {
-      if (firstConversationSeen) {
-        cleanupBootstrapFiles("new conversation created after onboarding");
-      }
-      firstConversationSeen = true;
-    }
-
     const now = Date.now();
     const conversationId = uuid();
     const customTitle = opts?.title?.trim();
@@ -300,6 +298,9 @@ export function getOrCreateConversation(
 
   if (result.created) {
     initConversationDir(result.conversation);
+    if (conversationType === "standard" && !opts?.deferBootstrapCleanup) {
+      recordStandardConversationCreated();
+    }
     // Attribution for every key-materialized conversation: this is the single
     // choke point through which all unseen-key creations flow, and the key
     // shape + caller frames identify the entry point from the log alone. The

package/src/providers/__tests__/unparseable-tool-args.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  boundUnparseableToolArgs,
+  boundUnparseableToolArgsRaw,
   isUnparseableToolArgs,
   unparseableToolArgsMessage,
   wrapUnparseableToolArgs,
@@ -31,6 +33,29 @@ describe("unparseable tool args marker", () => {
     expect(isUnparseableToolArgs({})).toBe(false);
   });
 
+  test("bounds long raw args while preserving the marker shape", () => {
+    const raw = "a".repeat(1_000);
+    const bounded = boundUnparseableToolArgs(wrapUnparseableToolArgs(raw));
+
+    expect(isUnparseableToolArgs(bounded)).toBe(true);
+    expect(bounded).toEqual({ _raw: "a".repeat(200) + "…" });
+  });
+
+  test("bounds raw diagnostic copies with the same preview contract", () => {
+    expect(boundUnparseableToolArgsRaw("a".repeat(1_000))).toBe(
+      "a".repeat(200) + "…",
+    );
+    expect(boundUnparseableToolArgsRaw("short")).toBe("short");
+  });
+
+  test("leaves short markers and ordinary input unchanged", () => {
+    const marker = wrapUnparseableToolArgs("short");
+    const ordinary = { command: "ls" };
+
+    expect(boundUnparseableToolArgs(marker)).toBe(marker);
+    expect(boundUnparseableToolArgs(ordinary)).toBe(ordinary);
+  });
+
   test("message includes tool name, raw preview, and retry instruction", () => {
     const msg = unparseableToolArgsMessage("ui_show", '{"surface_type": ');
     expect(msg).toContain('"ui_show"');

package/src/providers/inference/adapter-factory.ts

@@ -35,6 +35,7 @@ import { AtlasCloudProvider } from "../atlascloud/client.js";
 import { BasetenProvider } from "../baseten/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
+import { IonetProvider } from "../ionet/client.js";
 import { JevProvider } from "../jev/client.js";
 import { MinimaxProvider } from "../minimax/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
@@ -206,6 +207,11 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  ionet: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new IonetProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
   typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new JevProvider(apiKey, model, {
       streamTimeoutMs,

package/src/providers/ionet/client.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Verifies the IO Intelligence (io.net) provider wiring: the SDK client must
+ * resolve to the documented IO Intelligence chat-completions endpoint unless
+ * an explicit override is supplied (custom-connection / test usage).
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { IonetProvider } from "./client.js";
+
+type MockChunk = {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason?: string | null;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number };
+};
+
+const OK_CHUNKS: MockChunk[] = [
+  {
+    choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 1 },
+  },
+];
+
+function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const c of chunks) {
+        yield c;
+      }
+    },
+  };
+}
+
+function clientOf(provider: IonetProvider) {
+  return (
+    provider as unknown as {
+      client: {
+        baseURL: string;
+        chat: {
+          completions: {
+            create: (params: unknown) => Promise<AsyncIterable<MockChunk>>;
+          };
+        };
+      };
+    }
+  ).client;
+}
+
+describe("IonetProvider", () => {
+  test("defaults the SDK client to the IO Intelligence endpoint", async () => {
+    const provider = new IonetProvider(
+      "test-key",
+      "meta-llama/Llama-3.3-70B-Instruct",
+    );
+
+    const client = clientOf(provider);
+    expect(client.baseURL).toBe("https://api.intelligence.io.solutions/api/v1");
+
+    // The same base URL must be reported on the response, read off the live
+    // client instance rather than a constant.
+    client.chat.completions.create = async () => makeStream(OK_CHUNKS);
+    const response = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+    expect(response.resolvedEndpoint).toBe(
+      "https://api.intelligence.io.solutions/api/v1",
+    );
+  });
+
+  test("sends tool_choice auto when tools are offered without an explicit choice", async () => {
+    // io.net defaults an unspecified tool_choice to "none" (not OpenAI's
+    // "auto"), so the provider must send the explicit default or the model
+    // could never invoke an offered tool.
+    const provider = new IonetProvider(
+      "test-key",
+      "meta-llama/Llama-3.3-70B-Instruct",
+    );
+    const client = clientOf(provider);
+
+    let seenParams:
+      | {
+          tools?: unknown;
+          tool_choice?: unknown;
+        }
+      | undefined;
+    client.chat.completions.create = async (params) => {
+      seenParams = params as { tools?: unknown; tool_choice?: unknown };
+      return makeStream(OK_CHUNKS);
+    };
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "get_weather",
+            description: "Get the weather",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+      },
+    );
+    expect(Array.isArray(seenParams?.tools)).toBe(true);
+    expect(seenParams?.tool_choice).toBe("auto");
+
+    // An explicit caller choice still wins.
+    let forcedParams: { tool_choice?: unknown } | undefined;
+    client.chat.completions.create = async (params) => {
+      forcedParams = params as { tool_choice?: unknown };
+      return makeStream(OK_CHUNKS);
+    };
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "get_weather",
+            description: "Get the weather",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        config: { tool_choice: { type: "none" } },
+      },
+    );
+    expect(forcedParams?.tool_choice).toBe("none");
+  });
+
+  test("honours an explicit baseURL override", async () => {
+    const provider = new IonetProvider("test-key", "test-model", {
+      baseURL: "https://inference.example.test/v1",
+    });
+
+    const client = clientOf(provider);
+    expect(client.baseURL).toBe("https://inference.example.test/v1");
+
+    client.chat.completions.create = async () => makeStream(OK_CHUNKS);
+    const response = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+    expect(response.resolvedEndpoint).toBe("https://inference.example.test/v1");
+  });
+});

package/src/providers/ionet/client.ts

@@ -0,0 +1,37 @@
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+export interface IonetProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+const DEFAULT_IONET_BASE_URL = "https://api.intelligence.io.solutions/api/v1";
+
+/**
+ * IO Intelligence (io.net) serves an OpenAI chat-completions API with
+ * Hugging Face-style `org/name` model ids, so it rides the shared
+ * chat-completions client with its own default base URL.
+ */
+export class IonetProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: IonetProviderOptions = {},
+  ) {
+    super(apiKey, model, {
+      baseURL: options.baseURL?.trim() || DEFAULT_IONET_BASE_URL,
+      providerName: "ionet",
+      providerLabel: "IO Intelligence",
+      streamTimeoutMs: options.streamTimeoutMs,
+      // IO Intelligence serves DeepSeek- and GLM-style thinking models whose
+      // reasoning arrives as `reasoning_content`; replay it there so
+      // follow-up requests that include tools stay acceptable upstream.
+      assistantReasoningField: "reasoning_content",
+      // io.net defaults an unspecified `tool_choice` to "none" (unlike
+      // OpenAI's "auto"), so tools offered without an explicit choice must
+      // still send one or the model could never invoke them.
+      defaultToolChoiceAuto: true,
+    });
+  }
+}

package/src/providers/model-catalog.ts

@@ -2746,6 +2746,46 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://app.baseten.co/settings/api_keys",
     apiKeyPlaceholder: "Your Baseten API key",
   },
+  {
+    id: "ionet",
+    displayName: "IO Intelligence",
+    subtitle:
+      "Open models served by IO Intelligence, io.net's inference platform (OpenAI-compatible). Requires an IO Intelligence API key.",
+    setupMode: "api-key",
+    setupHint:
+      "Enter your IO Intelligence API key to enable IO Intelligence models.",
+    envVar: "IONET_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to io.net and create an IO Intelligence API key.",
+      url: "https://io.net/docs/guides/intelligence/api-keys-and-secrets",
+      linkLabel: "Open io.net",
+    },
+    // Model ids are Hugging Face-style `org/name`. Context windows and tool
+    // support come from the endpoint's live `GET /models` catalog, and every
+    // entry is accessible at the basic access tier.
+    models: [
+      {
+        id: "meta-llama/Llama-3.3-70B-Instruct",
+        displayName: "Llama 3.3 70B Instruct",
+        contextWindowTokens: 128000,
+        defaultContextWindowTokens: 128000,
+        maxOutputTokens: 4096,
+        supportsToolUse: true,
+      },
+      {
+        id: "openai/gpt-oss-20b",
+        displayName: "GPT-OSS 20B",
+        contextWindowTokens: 64000,
+        defaultContextWindowTokens: 64000,
+        maxOutputTokens: 32768,
+        supportsThinking: true,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "meta-llama/Llama-3.3-70B-Instruct",
+    apiKeyUrl: "https://io.net/docs/guides/intelligence/api-keys-and-secrets",
+    apiKeyPlaceholder: "Your IO Intelligence API key",
+  },
   {
     id: "poolside",
     displayName: "Poolside",

package/src/providers/openai/chat-completions-provider.ts

@@ -39,6 +39,7 @@ import {
   extractOverflowTokensFromMessage,
 } from "../types.js";
 import {
+  boundUnparseableToolArgsRaw,
   isUnparseableToolArgs,
   wrapUnparseableToolArgs,
 } from "../unparseable-tool-args.js";
@@ -212,6 +213,12 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  (Fireworks, Together) keep sending `none` / forced choices. Enabled for
    *  the generic `openai-compatible` adapter, whose upstream is unknown. */
   omitToolChoiceWhenReasoning?: boolean;
+  /** Send `tool_choice: "auto"` whenever tools are offered and the caller
+   *  left the choice unspecified. Strict OpenAI-compatible upstreams default
+   *  an unspecified `tool_choice` to "none" (io.net documents exactly that),
+   *  which would leave the model unable to call any tool; OpenAI's own
+   *  default is "auto", so this option only exists for upstreams that differ. */
+  defaultToolChoiceAuto?: boolean;
   /** Wire field for the output-token limit. OpenAI and OpenAI-compatible
    *  backends use `max_completion_tokens`. OpenRouter defaults to
    *  `max_tokens` because its parameter router matches that key on
@@ -864,6 +871,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private coerceObjectArgsToJsonString: boolean;
   private salvageXmlToolCalls: boolean;
   private omitToolChoiceWhenReasoning: boolean;
+  private defaultToolChoiceAuto: boolean;
   private outputTokenLimitField: "max_completion_tokens" | "max_tokens";
 
   constructor(
@@ -896,6 +904,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
       options.salvageXmlToolCalls ?? shouldSalvageXmlToolCalls(model);
     this.omitToolChoiceWhenReasoning =
       options.omitToolChoiceWhenReasoning ?? false;
+    this.defaultToolChoiceAuto = options.defaultToolChoiceAuto ?? false;
     this.outputTokenLimitField =
       options.outputTokenLimitField ?? "max_completion_tokens";
   }
@@ -958,6 +967,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
           maxTokens;
       }
 
+      // Per-conversation prompt-cache key (OpenAI Chat Completions
+      // `prompt_cache_key`). `RetryProvider` stamps it from the durable
+      // conversation id for providers in PROMPT_CACHE_KEY_PROVIDERS; omitted
+      // from the wire when absent.
+      const promptCacheKey = configObj?.promptCacheKey;
+      if (typeof promptCacheKey === "string" && promptCacheKey.length > 0) {
+        params.prompt_cache_key = promptCacheKey;
+      }
+
       // Profile-scoped token biasing (e.g. the `suppress-cjk` preset). Resolved
       // and gated to this provider family upstream in `RetryProvider`.
       if (logitBias) {
@@ -1028,7 +1046,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
         // wire. Catalog providers that honor `none` / forced choices still
         // receive them; the generic openai-compatible adapter drops every
         // explicit value in thinking mode via `omitToolChoiceWhenReasoning`.
-        const toolChoice = mapNeutralToolChoice(configObj?.tool_choice);
+        const callerToolChoice = mapNeutralToolChoice(configObj?.tool_choice);
+        const toolChoice =
+          callerToolChoice ??
+          (this.defaultToolChoiceAuto
+            ? ("auto" as OpenAI.Chat.Completions.ChatCompletionToolChoiceOption)
+            : undefined);
         xmlToolCallSalvageEnabled =
           this.salvageXmlToolCalls && toolChoice !== "none";
         if (toolChoice !== undefined) {
@@ -1149,6 +1172,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           id: string;
           name: string;
           args: string;
+          inspectableArgs?: string;
           providerMetadata?: ToolUseContent["providerMetadata"];
         }
       >();
@@ -1450,6 +1474,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           input = JSON.parse(tc.args);
         } catch {
           input = wrapUnparseableToolArgs(tc.args);
+          tc.inspectableArgs = boundUnparseableToolArgsRaw(tc.args);
         }
         const objectKeys = coercedObjectKeys.get(tc.name);
         if (objectKeys && !isUnparseableToolArgs(input)) {
@@ -1457,6 +1482,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
           input = decoded.failedKey
             ? wrapUnparseableToolArgs(tc.args)
             : decoded.input;
+          if (decoded.failedKey) {
+            tc.inspectableArgs = boundUnparseableToolArgsRaw(tc.args);
+          }
         }
         content.push({
           type: "tool_use",
@@ -1484,7 +1512,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
                         {
                           id: tc.id,
                           type: "function",
-                          function: { name: tc.name, arguments: tc.args },
+                          function: {
+                            name: tc.name,
+                            arguments: tc.inspectableArgs ?? tc.args,
+                          },
                         },
                         thoughtSignatureFromToolUseMetadata(
                           tc.providerMetadata,

package/src/providers/retry.ts

@@ -78,10 +78,16 @@ const USAGE_ATTRIBUTION_HEADER_NAMES = {
   subagentSpawnMode: "X-Vellum-Subagent-Spawn-Mode",
 } as const;
 
-/** Providers whose transports consume `promptCacheKey` (OpenAI Responses
- *  `prompt_cache_key`); `RetryProvider` derives it from `selectionSeed` for
- *  these only. */
-const PROMPT_CACHE_KEY_PROVIDERS = new Set(["openai", "openrouter"]);
+/** Providers whose transports consume `promptCacheKey` (OpenAI Responses /
+ *  Chat Completions `prompt_cache_key`); `RetryProvider` derives it from
+ *  `selectionSeed` for these only. `openai-compatible` is included so
+ *  self-hosted bridges (e.g. a Claude Code shim) receive a stable
+ *  per-conversation key and can pin server-side sessions / prompt caches to it. */
+const PROMPT_CACHE_KEY_PROVIDERS = new Set([
+  "openai",
+  "openrouter",
+  "openai-compatible",
+]);
 
 /** Providers that support the `effort` config (extended thinking / reasoning). */
 const EFFORT_SUPPORTED_PROVIDERS = new Set([