@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

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

@@ -17,7 +17,6 @@ import {
   mediaSourceByteLength,
   resolveMediaReferences,
 } from "../media-resolve.js";
-import { supportsForcedToolChoiceWithThinking } from "../model-catalog.js";
 import { PLACEHOLDER_EMPTY_TURN } from "../placeholder-sentinels.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
 import { createStreamTimeout } from "../stream-timeout.js";
@@ -28,7 +27,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolUseContent,
 } from "../types.js";
 import {
   ContextOverflowError,
@@ -53,15 +51,6 @@ import {
   coerceObjectParamsToJsonString,
   decodeCoercedObjectArgs,
 } from "./coerce-object-args.js";
-import {
-  applyGemini3UnsignedToolCallFallback,
-  attachGoogleThoughtSignatureIfNeeded,
-  classifyGoogleThoughtSignatureRetry,
-  geminiThoughtSignaturesByToolCallId,
-  type GoogleToolCallExtraContent,
-  thoughtSignatureFromToolUseMetadata,
-  toolUseMetadataFromChatCompletionsDelta,
-} from "./google-thought-signature.js";
 import {
   isOpenAICompatInlineAudio,
   OPENAI_COMPAT_MAX_INLINE_AUDIO_BYTES,
@@ -215,13 +204,7 @@ const log = getLogger("chat-completions");
 /** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
  *  `"max"`, but Fireworks accepts it for DeepSeek V4; the assignment to
  *  `params.reasoning_effort` casts through this union. */
-export type ReasoningEffortWire =
-  | "none"
-  | "low"
-  | "medium"
-  | "high"
-  | "xhigh"
-  | "max";
+export type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
 
 const REASONING_EFFORT_RANK: Record<ReasoningEffortWire, number> = {
   none: 0,
@@ -405,15 +388,9 @@ export function isThinkingEnabledOnWire(params: unknown): boolean {
  * rejected it because thinking/reasoning mode forbids that parameter.
  * DeepSeek thinking mode 400s with `Thinking mode does not support this
  * tool_choice` for any explicit value, including `"auto"` and `"none"`.
- * Kimi 400s with `tool_choice 'specified' is incompatible with thinking
- * enabled`. One retry without `tool_choice` lets the same provider succeed
- * instead of failing over to a different backend.
+ * One retry without `tool_choice` lets the same provider succeed instead of
+ * failing over to a different backend.
  */
-const THINKING_MODE_TOOL_CHOICE_REJECTION_PATTERNS: RegExp[] = [
-  /does not support this tool_choice/i,
-  /tool_choice\s+'specified'\s+is incompatible with thinking/i,
-];
-
 function isThinkingModeToolChoiceRejection(
   error: unknown,
   params: unknown,
@@ -425,9 +402,8 @@ function isThinkingModeToolChoiceRejection(
   if (!isClientErrorStatus(error)) {
     return false;
   }
-  const haystack = openaiCompatErrorHaystack(error);
-  return THINKING_MODE_TOOL_CHOICE_REJECTION_PATTERNS.some((pattern) =>
-    pattern.test(haystack),
+  return /does not support this tool_choice/i.test(
+    openaiCompatErrorHaystack(error),
   );
 }
 
@@ -565,10 +541,8 @@ function isMissingReasoningContentRejection(
 
 /**
  * True when the request included an assistant `reasoning` / `reasoning_content`
- * extra and the provider rejected it as an unknown or unsupported message
- * property. One retry without those extras lets a strict Chat Completions
- * schema succeed. Groq phrases this as
- * `property 'reasoning_content' is unsupported`.
+ * extra and the provider rejected it as an unknown message property. One retry
+ * without those extras lets a strict Chat Completions schema succeed.
  */
 function isUnknownAssistantReasoningFieldRejection(
   error: unknown,
@@ -587,7 +561,7 @@ function isUnknownAssistantReasoningFieldRejection(
   if (!haystackNamesAssistantReasoningField(haystack)) {
     return false;
   }
-  return /unknown|unexpected|unrecognized|unsupported|not supported|additional propert|extra (?:field|property)|not (?:a )?valid|invalid (?:argument|parameter|field|property)/i.test(
+  return /unknown|unexpected|unrecognized|additional propert|extra (?:field|property)|not (?:a )?valid|invalid (?:argument|parameter|field|property)/i.test(
     haystack,
   );
 }
@@ -660,82 +634,6 @@ function flattenContentPartsToStrings(params: unknown): boolean {
   return flattened;
 }
 
-type OpenAICompatRetryKind =
-  | "reasoning-opt-out"
-  | "thinking-tool-choice"
-  | "missing-reasoning-content"
-  | "unknown-reasoning-field"
-  | "missing-thought-signature"
-  | "unknown-extra-content"
-  | "chat-template";
-
-function classifyOpenAICompatRetry(
-  error: unknown,
-  params: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming,
-  thoughtSignaturesByCallId: ReadonlyMap<string, string>,
-): { kind: OpenAICompatRetryKind; message: string; apply: () => void } | null {
-  if (isReasoningOptOutRejection(error, params)) {
-    return {
-      kind: "reasoning-opt-out",
-      message:
-        "Model rejected the explicit reasoning opt-out; retrying without reasoning params",
-      apply: () => {
-        delete params.reasoning_effort;
-        delete (params as unknown as Record<string, unknown>).reasoning;
-      },
-    };
-  }
-  if (isThinkingModeToolChoiceRejection(error, params)) {
-    return {
-      kind: "thinking-tool-choice",
-      message:
-        "Upstream rejected tool_choice in thinking mode; retrying without tool_choice",
-      apply: () => {
-        delete params.tool_choice;
-      },
-    };
-  }
-  if (isMissingReasoningContentRejection(error, params)) {
-    return {
-      kind: "missing-reasoning-content",
-      message:
-        "Upstream requires reasoning_content round-trip; retrying with empty field on assistant messages",
-      apply: () => {
-        backfillEmptyReasoningContent(params);
-      },
-    };
-  }
-  if (isUnknownAssistantReasoningFieldRejection(error, params)) {
-    return {
-      kind: "unknown-reasoning-field",
-      message:
-        "Upstream rejected assistant reasoning field; retrying without it",
-      apply: () => {
-        stripAssistantReasoningFields(params);
-      },
-    };
-  }
-  const thoughtSignatureRetry = classifyGoogleThoughtSignatureRetry(params, {
-    isClientError: isClientErrorStatus(error),
-    haystack: openaiCompatErrorHaystack(error),
-    capturedByCallId: thoughtSignaturesByCallId,
-  });
-  if (thoughtSignatureRetry) {
-    return thoughtSignatureRetry;
-  }
-  if (isChatTemplateRejection(error, params)) {
-    return {
-      kind: "chat-template",
-      message:
-        "Upstream chat template rejected structured message content; retrying with flattened plain-text content",
-      apply: () => {
-        flattenContentPartsToStrings(params);
-      },
-    };
-  }
-  return null;
-}
-
 /**
  * Translate the neutral (Anthropic-shaped) `tool_choice` carried on the call
  * config into the OpenAI chat-completions wire format. Callers express
@@ -876,13 +774,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const coercedObjectKeys = new Map<string, string[]>();
 
     try {
-      const thoughtSignaturesByCallId =
-        geminiThoughtSignaturesByToolCallId(messages);
       const openaiMessages = await this.toOpenAIMessages(
         messages,
         systemPrompt,
         requestSupportsInlineAudio(modelOverride ?? this.model),
-        modelOverride ?? this.model,
       );
 
       recordProviderRequestDiagnostics({
@@ -979,18 +874,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           const thinkingOn = isThinkingEnabledOnWire(params);
           const skipAutoDefault = thinkingOn && toolChoice === "auto";
           const skipAllChoices = thinkingOn && this.omitToolChoiceWhenReasoning;
-          const skipIncompatibleForcedChoice =
-            thinkingOn &&
-            !supportsForcedToolChoiceWithThinking(
-              this.name,
-              modelOverride ?? this.model,
-            ) &&
-            (toolChoice === "required" || typeof toolChoice === "object");
-          if (
-            !skipAutoDefault &&
-            !skipAllChoices &&
-            !skipIncompatibleForcedChoice
-          ) {
+          if (!skipAutoDefault && !skipAllChoices) {
             params.tool_choice = toolChoice;
           }
         }
@@ -1089,12 +973,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
 
       const toolCallMap = new Map<
         number,
-        {
-          id: string;
-          name: string;
-          args: string;
-          providerMetadata?: ToolUseContent["providerMetadata"];
-        }
+        { id: string; name: string; args: string }
       >();
       const toolProgress = createToolProgressEmitter(onEvent);
       let finishReason = "unknown";
@@ -1122,31 +1001,68 @@ export class OpenAIChatCompletionsProvider implements Provider {
               ? { headers: requestHeaders }
               : {}),
           });
-        const attemptedCompatRetries = new Set<OpenAICompatRetryKind>();
         let stream: Awaited<ReturnType<typeof createStream>>;
-        for (;;) {
-          try {
+        try {
+          stream = await createStream();
+        } catch (error) {
+          if (isReasoningOptOutRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Model rejected the explicit reasoning opt-out; retrying without reasoning params",
+            );
+            delete params.reasoning_effort;
+            delete (params as unknown as Record<string, unknown>).reasoning;
             stream = await createStream();
-            break;
-          } catch (error) {
-            const retry = classifyOpenAICompatRetry(
-              error,
-              params,
-              thoughtSignaturesByCallId,
+          } else if (isThinkingModeToolChoiceRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream rejected tool_choice in thinking mode; retrying without tool_choice",
             );
-            if (!retry || attemptedCompatRetries.has(retry.kind)) {
-              throw error;
-            }
-            attemptedCompatRetries.add(retry.kind);
+            delete params.tool_choice;
+            stream = await createStream();
+          } else if (isMissingReasoningContentRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream requires reasoning_content round-trip; retrying with empty field on assistant messages",
+            );
+            backfillEmptyReasoningContent(params);
+            stream = await createStream();
+          } else if (isUnknownAssistantReasoningFieldRejection(error, params)) {
             log.warn(
               {
                 provider: this.name,
                 model: modelOverride ?? this.model,
                 error: error instanceof Error ? error.message : String(error),
               },
-              retry.message,
+              "Upstream rejected assistant reasoning field; retrying without it",
             );
-            retry.apply();
+            stripAssistantReasoningFields(params);
+            stream = await createStream();
+          } else if (isChatTemplateRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream chat template rejected structured message content; retrying with flattened plain-text content",
+            );
+            flattenContentPartsToStrings(params);
+            stream = await createStream();
+          } else {
+            throw error;
           }
         }
 
@@ -1234,14 +1150,6 @@ export class OpenAIChatCompletionsProvider implements Provider {
                     entry.args,
                   );
                 }
-                const providerMetadata =
-                  toolUseMetadataFromChatCompletionsDelta(tc);
-                if (
-                  providerMetadata &&
-                  !thoughtSignatureFromToolUseMetadata(entry.providerMetadata)
-                ) {
-                  entry.providerMetadata = providerMetadata;
-                }
               }
             }
 
@@ -1363,9 +1271,6 @@ export class OpenAIChatCompletionsProvider implements Provider {
           id: tc.id,
           name: tc.name,
           input,
-          ...(tc.providerMetadata
-            ? { providerMetadata: tc.providerMetadata }
-            : {}),
         });
       }
 
@@ -1379,19 +1284,11 @@ export class OpenAIChatCompletionsProvider implements Provider {
               content: contentText || null,
               tool_calls:
                 toolCallMap.size > 0
-                  ? Array.from(toolCallMap.values()).map((tc) =>
-                      attachGoogleThoughtSignatureIfNeeded(
-                        {
-                          id: tc.id,
-                          type: "function",
-                          function: { name: tc.name, arguments: tc.args },
-                        },
-                        thoughtSignatureFromToolUseMetadata(
-                          tc.providerMetadata,
-                        ),
-                        modelOverride ?? this.model,
-                      ),
-                    )
+                  ? Array.from(toolCallMap.values()).map((tc) => ({
+                      id: tc.id,
+                      type: "function",
+                      function: { name: tc.name, arguments: tc.args },
+                    }))
                   : undefined,
             },
             finish_reason: finishReason,
@@ -1595,7 +1492,6 @@ export class OpenAIChatCompletionsProvider implements Provider {
     messages: Message[],
     systemPrompt?: string,
     audioInputEnabled = false,
-    model = this.model,
   ): Promise<OpenAI.Chat.Completions.ChatCompletionMessageParam[]> {
     // Swap any persisted attachment references back to inline base64 before
     // serializing, so the block transforms below can read `source.data`.
@@ -1617,7 +1513,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const emittedToolCallIds = new Set<string>();
     for (const msg of messages) {
       if (msg.role === "assistant") {
-        const assistantMessage = this.toOpenAIAssistantMessage(msg, model);
+        const assistantMessage = this.toOpenAIAssistantMessage(msg);
         for (const toolCall of assistantMessage.tool_calls ?? []) {
           emittedToolCallIds.add(toolCall.id);
         }
@@ -1695,14 +1591,11 @@ export class OpenAIChatCompletionsProvider implements Provider {
   /** Convert an assistant message with text + tool_use blocks to OpenAI format. */
   private toOpenAIAssistantMessage(
     msg: Message,
-    model: string,
   ): OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam {
     const textParts: string[] = [];
     const reasoningParts: string[] = [];
-    const toolCalls: Array<
-      OpenAI.Chat.Completions.ChatCompletionMessageToolCall &
-        GoogleToolCallExtraContent
-    > = [];
+    const toolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] =
+      [];
 
     for (const block of msg.content) {
       switch (block.type) {
@@ -1716,20 +1609,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
           }
           break;
         case "tool_use":
-          toolCalls.push(
-            attachGoogleThoughtSignatureIfNeeded(
-              {
-                id: block.id,
-                type: "function",
-                function: {
-                  name: block.name,
-                  arguments: JSON.stringify(block.input),
-                },
-              },
-              thoughtSignatureFromToolUseMetadata(block.providerMetadata),
-              model,
-            ),
-          );
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input),
+            },
+          });
           break;
         case "server_tool_use":
           textParts.push(`[Web search: ${block.name}]`);
@@ -1748,7 +1635,6 @@ export class OpenAIChatCompletionsProvider implements Provider {
       };
 
     if (toolCalls.length > 0) {
-      applyGemini3UnsignedToolCallFallback(toolCalls, model);
       result.tool_calls = toolCalls;
     }
 

package/src/providers/openai/codex-models.ts

@@ -14,6 +14,10 @@ export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-5.6-terra",
   "gpt-5.6-luna",
   "gpt-5.5",
+  // OpenAI retires these two from ChatGPT sign-in on 2026-08-31; API-key
+  // auth is unaffected.
+  "gpt-5.4",
+  "gpt-5.4-mini",
 ]);
 
 /** True when `model` is allowlisted for Codex subscription routing. */

package/src/runtime/AGENTS.md

@@ -12,8 +12,6 @@ The single HTTP send endpoint is `POST /v1/messages`. Key behaviors:
 
 Do NOT add new send endpoints. All message ingress should go through `POST /v1/messages` (HTTP).
 
-`POST /v1/channels/send` is not ingress: it is outbound delivery, the assistant posting text to a channel chat. It runs `sendChannelText` (`runtime/channel-send.ts`), the one send implementation for every channel whose transport declares proactive addressing (`ChannelTransport.addressFor`), and the messaging tool's channel branch runs the same function in-process, as the CLI's channel send door does over the route. A model-directed channel send goes through that function or it is not recorded; do not add a provider-side send for a channel that has a transport. The route names no sending turn: only the in-process tool call can claim a send landed in the turn's own chat, so everything sent through the route is recorded.
-
 **`interrupt-on-send`: a send may stop the running turn instead of queueing behind it.** With the flag on, a busy conversation is handed to `interruptRunningTurn` (`daemon/conversation-interrupt.ts`), which aborts the turn with `preempted_by_new_message`, waits for it to release the processing lock AND for its turn-boundary commit to finish, repairs the abandoned `tool_use` blocks with a persisted synthetic `tool_result`, and answers `released`. The route then falls through to the code an idle conversation already uses, so there is one turn dispatch rather than a second one for interrupts. The queue is not discarded: it may hold another actor's messages.
 
 **The handover runs off the response, not on it.** Fire-and-forget is not suspended for an interrupt. The eligibility decision is synchronous (`classifyInterruptEligibility`), so the route answers `202 { accepted, requestId }` the moment it accepts the message, then runs the abort, the release wait, the commit wait, the repair, the persist and the dispatch in a detached task. Holding the request would cost the abort budget (`ABORT_RELEASE_WAIT_MS`) plus the turn-boundary commit wait, long enough for a client to time out and retry a message the daemon is still placing. That 202 carries `messageId` as well as `requestId`, and they are the same value: a user turn persists its row under its `requestId` (`persistUserMessage` passes `id: requestId`), which is what lets the id be answered before the row exists. Both are required, not decorative: `postChatMessage` rejects an accepted, non-queued response without a string `messageId` and the client drops the optimistic row. Clients reconcile that row on `user_message_echo`. Two rules for anything added to that task: it must not be able to drop the message (every failure path falls back to `queueSend`, which never takes the enqueue's idle fast path, and a queue that refuses the fallback is reported to the sender as a `QUEUE_FULL` error keyed on the `requestId` the 202 carried, since the 429 itself reaches nobody), and a duplicate `clientMessageId` is answered from the existing row BEFORE the abort, since the insert's own dedup settles too late to un-abort a turn.

package/src/runtime/auth/same-actor.ts

@@ -142,7 +142,9 @@ function detectRejection(
     ? args.hub.getActorPrincipalIdForClient(args.targetClientId)
     : (args.targetActorPrincipalId ??
       (isHttpAuthDisabled() && targetClientId
-        ? args.hubForMissingTarget?.getActorPrincipalIdForClient(targetClientId)
+        ? args.hubForMissingTarget?.getActorPrincipalIdForClient(
+            targetClientId,
+          )
         : undefined));
 
   let reason: RejectionReason | undefined;
@@ -262,43 +264,6 @@ export function pickSameUserAutoResolve(args: {
   return { kind: "ambiguous" };
 }
 
-/**
- * Pick the most recently active capable client owned by the turn actor.
- * `listClientsByCapability` is ordered by recent activity, so the first
- * same-user match provides deterministic routing without broadcasting a host
- * request across multiple devices.
- */
-export function pickMostRecentSameUserClient(args: {
-  hub: Pick<AssistantEventHub, "listClientsByCapability">;
-  capability: HostProxyCapability;
-  sourceActorPrincipalId: string | undefined;
-}): string | undefined {
-  const { hub, capability, sourceActorPrincipalId } = args;
-  if (sourceActorPrincipalId == null) {
-    return undefined;
-  }
-  return hub
-    .listClientsByCapability(capability)
-    .find((client) => client.actorPrincipalId === sourceActorPrincipalId)
-    ?.clientId;
-}
-
-/**
- * Error result for an automatic host route with no capable client owned by the
- * actor that initiated the turn.
- */
-export function unavailableSameUserClientError(
-  capability: HostProxyCapability,
-): {
-  content: string;
-  isError: true;
-} {
-  return {
-    content: `No connected ${capability} client belongs to this user. Connect a capable client signed in as the same user, then retry.`,
-    isError: true,
-  };
-}
-
 /**
  * Actor principal persisted on a host-proxy pending interaction.
  *