@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.4

package/src/providers/inference/logit-bias.ts

@@ -0,0 +1,55 @@
+import { KIMI_CJK_SINGLE_CHAR_TOKEN_IDS } from "./kimi-cjk-token-ids.js";
+
+/**
+ * Named logit-bias presets that a profile may opt into via the `logitBias`
+ * field on `ProfileEntry` (see `config/schemas/llm.ts`). A preset resolves to a
+ * `{ "<tokenId>": bias }` map that OpenAI-compatible providers forward as the
+ * `logit_bias` request field.
+ *
+ * Presets are profile-scoped: `RetryProvider.normalizeSendMessageOptions`
+ * resolves the active profile's `logitBias` and only attaches the map on the
+ * Fireworks (OpenAI-compatible) path, so it never reaches providers/models it
+ * wasn't built for. Token IDs are tokenizer-specific — `suppress-cjk` only makes
+ * sense for the Kimi-tokenizer models Fireworks serves.
+ *
+ * The valid preset names must match the `logitBias` enum in
+ * `config/schemas/llm.ts` (kept as a plain literal there to avoid a schema →
+ * provider import cycle).
+ */
+
+/**
+ * Soft negative bias applied to each CJK token. -4 discourages *spontaneous*
+ * Chinese (a marginal-probability slip) while leaving explicitly-requested
+ * Chinese (dominant-probability tokens) intact. Not a hard ban (-100 would
+ * clip legitimate CJK); tunable if slips persist in real usage.
+ */
+export const SUPPRESS_CJK_BIAS = -4;
+
+let suppressCjkMap: Readonly<Record<string, number>> | undefined;
+
+function buildSuppressCjkMap(): Readonly<Record<string, number>> {
+  const map: Record<string, number> = {};
+  for (const id of KIMI_CJK_SINGLE_CHAR_TOKEN_IDS) {
+    map[id] = SUPPRESS_CJK_BIAS;
+  }
+  return map;
+}
+
+/**
+ * Resolve a preset to its `logit_bias` map for `model`, or `undefined` when the
+ * preset is unknown or doesn't apply to the model. `suppress-cjk`'s token IDs
+ * come from the Kimi tokenizer, so it only resolves for Kimi models — this keeps
+ * the preset from being misapplied to a different-tokenizer model that happened
+ * to inherit it. The map is built once and cached (a constant ~5.3k-entry object
+ * reused across every request on the owning profile).
+ */
+export function resolveLogitBiasPreset(
+  preset: string,
+  model: string,
+): Readonly<Record<string, number>> | undefined {
+  if (preset === "suppress-cjk" && /kimi/i.test(model)) {
+    suppressCjkMap ??= buildSuppressCjkMap();
+    return suppressCjkMap;
+  }
+  return undefined;
+}

package/src/providers/openai/__tests__/vision-not-supported.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+import OpenAI from "openai";
+
+import { detectVisionNotSupported } from "../chat-completions-provider.js";
+
+function buildApiError(
+  status: number,
+  body: unknown,
+): InstanceType<typeof OpenAI.APIError> {
+  return new OpenAI.APIError(
+    status,
+    body as Record<string, unknown>,
+    undefined,
+    new Headers(),
+  );
+}
+
+describe("detectVisionNotSupported", () => {
+  test("detects OpenRouter 'No endpoints found that support image input'", () => {
+    const err = buildApiError(404, {
+      error: {
+        message: "No endpoints found that support image input",
+        code: 404,
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'does not support image' phrasing", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "This model does not support image input",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'image input is not supported'", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "image input is not supported for this model",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("detects 'vision is not supported'", () => {
+    const err = buildApiError(400, {
+      error: {
+        message: "Vision is not supported by this model",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(true);
+  });
+
+  test("returns false for unrelated errors", () => {
+    const err = buildApiError(429, {
+      error: {
+        message: "Rate limit exceeded",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(false);
+  });
+
+  test("returns false for context overflow", () => {
+    const err = buildApiError(400, {
+      error: {
+        code: "context_length_exceeded",
+        message: "This model's maximum context length is 128000 tokens",
+      },
+    });
+    expect(detectVisionNotSupported(err)).toBe(false);
+  });
+});

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

@@ -101,6 +101,22 @@ export function extractApiErrorDetail(
  *  OpenRouter's `error.metadata.raw` strings, which are typically <1KB. */
 const MAX_API_ERROR_DETAIL_CHARS = 2000;
 
+const VISION_NOT_SUPPORTED_PATTERNS = [
+  /no endpoints found that support image input/i,
+  /does not support image/i,
+  /image input is not supported/i,
+  /this model does not support vision/i,
+  /vision is not supported/i,
+  /multi-?modal.*not.*support/i,
+];
+
+export function detectVisionNotSupported(
+  error: InstanceType<typeof OpenAI.APIError>,
+): boolean {
+  const haystack = `${error.message} ${JSON.stringify((error as { error?: unknown }).error ?? "")}`;
+  return VISION_NOT_SUPPORTED_PATTERNS.some((re) => re.test(haystack));
+}
+
 /**
  * Fallback `content` for an assistant turn that has neither visible text nor
  * tool calls (e.g. a reasoning-only turn truncated at the output-token limit).
@@ -293,6 +309,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const effort = configObj?.effort as string | undefined;
+    const logitBias = configObj?.logit_bias as
+      | Record<string, number>
+      | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
@@ -313,6 +332,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.max_completion_tokens = maxTokens;
       }
 
+      // Profile-scoped token biasing (e.g. the `suppress-cjk` preset). Resolved
+      // and gated to this provider family upstream in `RetryProvider`.
+      if (logitBias) {
+        params.logit_bias = logitBias;
+      }
+
       // Subclasses (OpenRouter) may already have nested effort under
       // `reasoning.effort` via `buildExtraCreateParams`. Skip the flat
       // `reasoning_effort` assignment in that case to avoid sending both forms,
@@ -625,7 +650,16 @@ export class OpenAIChatCompletionsProvider implements Provider {
             : {}),
         },
         stopReason: finishReason,
-        rawRequest: params,
+        // `rawRequest` is persisted to the request-log DB and inspector on every
+        // call. A `logit_bias` preset (e.g. `suppress-cjk`) is ~5.3k deterministic
+        // entries (~68KB); summarize it here so logs don't balloon. The full map
+        // still went out on the wire above.
+        rawRequest: params.logit_bias
+          ? {
+              ...params,
+              logit_bias: `<${Object.keys(params.logit_bias).length} token biases omitted>`,
+            }
+          : params,
         rawResponse,
       };
     } catch (error) {
@@ -649,6 +683,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
             cause: error,
           });
         }
+        if (detectVisionNotSupported(error)) {
+          const model = modelOverride ?? this.model;
+          throw new ProviderError(
+            `This model (${model}) doesn't support image input. Remove the image or switch to a vision-capable model.`,
+            this.name,
+            error.status,
+            abortReason ? { abortReason } : undefined,
+          );
+        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
           retryAfterMs?: number;

package/src/providers/retry.ts

@@ -13,6 +13,7 @@ import {
   isRetryableNetworkError,
   sleep,
 } from "../util/retry.js";
+import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
 import {
   isThinkingConfigDisabled,
   normalizeThinkingConfigForWire,
@@ -277,6 +278,27 @@ function normalizeSendMessageOptions(
     ) {
       nextConfig.openrouter = { only: resolved.openrouter.only };
     }
+    // Forward a profile's opted-in `logit_bias` preset only on the Fireworks
+    // (OpenAI-compatible) path. `resolved.logitBias` is set by the resolver from
+    // the single winning profile (not the deep-merge), so it can't leak from a
+    // lower-precedence profile into one that didn't opt in.
+    // `resolveLogitBiasPreset` additionally gates on the resolved model's
+    // tokenizer. Strict-schema clients (Anthropic) reject unknown body fields,
+    // hence the provider gate.
+    if (
+      providerName === "fireworks" &&
+      nextConfig.logit_bias === undefined &&
+      resolved.logitBias !== undefined &&
+      typeof nextConfig.model === "string"
+    ) {
+      const biasMap = resolveLogitBiasPreset(
+        resolved.logitBias,
+        nextConfig.model,
+      );
+      if (biasMap !== undefined) {
+        nextConfig.logit_bias = biasMap;
+      }
+    }
     // `contextWindow` and `provider` are server-side concerns, not provider
     // request parameters: effective context is resolved per call site/profile
     // by the agent/conversation path, while `provider` selection is handled by

package/src/providers/types.ts

@@ -207,6 +207,12 @@ export interface SendMessageConfig {
   effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
   speed?: "standard" | "fast";
   verbosity?: "low" | "medium" | "high";
+  /**
+   * Wire-format `logit_bias` map (`{ "<tokenId>": bias }`). Set by
+   * `RetryProvider` from a profile's `logitBias` preset and forwarded only on
+   * the OpenAI-compatible (Fireworks) path; other providers ignore it.
+   */
+  logit_bias?: Record<string, number>;
   /**
    * When true, the most recent user message's content varies across
    * otherwise-identical turns (e.g. a per-turn memory block was injected into

package/src/runtime/routes/__tests__/stt-routes.test.ts

@@ -1,3 +1,8 @@
+import { randomUUID } from "node:crypto";
+import { writeFileSync } from "node:fs";
+import { unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
@@ -26,6 +31,35 @@ mock.module("../../../providers/speech-to-text/resolve.js", () => ({
   },
 }));
 
+// -- Spawn mock (ffmpeg/ffprobe) for the file-transcription path ------------
+
+type SpawnResult = { exitCode: number; stdout: string; stderr: string };
+let spawnOverride: ((args: string[]) => SpawnResult) | null = null;
+
+/**
+ * Default spawn behavior: ffmpeg writes the requested output file so the
+ * downstream readFile succeeds, ffprobe reports a short duration.
+ */
+function defaultSpawn(args: string[]): SpawnResult {
+  if (args[0] === "ffmpeg") {
+    const outputPath = args[args.length - 1];
+    writeFileSync(outputPath, Buffer.from("fake-wav-bytes"));
+    return { exitCode: 0, stdout: "", stderr: "" };
+  }
+  if (args[0] === "ffprobe") {
+    return { exitCode: 0, stdout: "1.0", stderr: "" };
+  }
+  return { exitCode: 0, stdout: "", stderr: "" };
+}
+
+mock.module("../../../util/spawn.js", () => ({
+  FFMPEG_TRANSCODE_TIMEOUT_MS: 60_000,
+  FFPROBE_TIMEOUT_MS: 10_000,
+  STT_REQUEST_TIMEOUT_MS: 300_000,
+  spawnWithTimeout: async (args: string[]) =>
+    (spawnOverride ?? defaultSpawn)(args),
+}));
+
 // ---------------------------------------------------------------------------
 // Import under test — after mocks
 // ---------------------------------------------------------------------------
@@ -86,6 +120,7 @@ const fakeTranscriber: BatchTranscriber = {
 beforeEach(() => {
   mockTranscriber = fakeTranscriber;
   mockResolveError = null;
+  spawnOverride = null;
 });
 
 afterEach(() => {
@@ -366,4 +401,81 @@ describe("stt-routes", () => {
       "BAD_GATEWAY",
     );
   });
+
+  // -- File transcription: provider error categorization --------------------
+
+  async function withTempAudioFile(
+    run: (filePath: string) => Promise<void>,
+  ): Promise<void> {
+    const filePath = join(tmpdir(), `vellum-stt-test-${randomUUID()}.wav`);
+    await writeFile(filePath, Buffer.from("fake-audio"));
+    try {
+      await run(filePath);
+    } finally {
+      await unlink(filePath).catch(() => {});
+    }
+  }
+
+  test("transcribe-file maps provider auth failures (403) to 401", async () => {
+    // Reproduces JARVIS-994: a raw Gemini 403 denial must surface as an
+    // actionable 401, not a generic 502, and must not be treated as a
+    // daemon-level error.
+    mockTranscriber = {
+      providerId: "google-gemini",
+      boundaryId: "daemon-batch",
+      transcribe: async () => {
+        throw new Error(
+          'Google Gemini API error (403): {"error":{"code":403,"message":"Your project has been denied access. Please contact support.","status":"PERMISSION_DENIED"}}',
+        );
+      },
+    };
+
+    await withTempAudioFile(async (filePath) => {
+      const { handler } = getRoute("stt/transcribe-file");
+      const err = await expectRouteError(
+        () => handler(makeArgs({ filePath })),
+        401,
+        "UNAUTHORIZED",
+      );
+      expect(err.message).toContain("credentials");
+    });
+  });
+
+  test("transcribe-file maps generic provider failures to 502", async () => {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
+      transcribe: async () => {
+        throw new Error("upstream kaboom");
+      },
+    };
+
+    await withTempAudioFile(async (filePath) => {
+      const { handler } = getRoute("stt/transcribe-file");
+      await expectRouteError(
+        () => handler(makeArgs({ filePath })),
+        502,
+        "BAD_GATEWAY",
+      );
+    });
+  });
+
+  test("transcribe-file maps ffmpeg failures to 502 even when stderr contains a status-like number", async () => {
+    // Guards against ffmpeg stderr (or a user-supplied path) deciding the HTTP
+    // category: a conversion failure whose message contains "403" must stay a
+    // 502 conversion error, not become a misleading 401 auth error.
+    spawnOverride = (args) =>
+      args[0] === "ffmpeg"
+        ? { exitCode: 1, stdout: "", stderr: "Error opening /tmp/403/clip.wav" }
+        : { exitCode: 0, stdout: "1.0", stderr: "" };
+
+    await withTempAudioFile(async (filePath) => {
+      const { handler } = getRoute("stt/transcribe-file");
+      await expectRouteError(
+        () => handler(makeArgs({ filePath })),
+        502,
+        "BAD_GATEWAY",
+      );
+    });
+  });
 });

package/src/runtime/routes/acp-routes.test.ts

@@ -2,9 +2,9 @@
  * Tests for the ACP route handlers.
  *
  * Suites:
- *  - POST /v1/acp/spawn: resolver failure paths (acp_disabled,
- *    unknown_agent) and the body-shape guard. The binary_not_found /
- *    auto-install surface is covered in `__tests__/acp-routes.test.ts`.
+ *  - POST /v1/acp/spawn: resolver failure paths (unknown_agent) and the
+ *    body-shape guard. The binary_not_found / auto-install surface is
+ *    covered in `__tests__/acp-routes.test.ts`.
  *  - POST /v1/acp/spawn (env injection) — CLAUDE_CODE_OAUTH_TOKEN is read
  *    from the credential broker (policy-gated + audited) and merged into
  *    `agentConfig.env` ONLY for the `claude` agent.
@@ -200,21 +200,6 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("POST /v1/acp/spawn", () => {
-  test("throws BadRequestError when ACP is disabled", async () => {
-    config.setConfig({ enabled: false });
-
-    const handler = getSpawnHandler();
-    await expect(
-      handler({
-        body: {
-          agent: "claude",
-          task: "do a thing",
-          conversationId: "conv-1",
-        },
-      }),
-    ).rejects.toThrow("acp.enabled");
-  });
-
   test("throws BadRequestError with merged available list when agent id is unknown", async () => {
     config.setConfig({
       agents: {
@@ -235,8 +220,6 @@ describe("POST /v1/acp/spawn", () => {
   });
 
   test("body-shape guard short-circuits before the resolver runs", async () => {
-    config.setConfig({ enabled: false });
-
     const handler = getSpawnHandler();
     await expect(handler({ body: { agent: "claude" } })).rejects.toThrow(
       "agent, task, and conversationId are required",

package/src/runtime/routes/app-management-routes.ts

@@ -89,6 +89,7 @@ function listAppsFiltered(apps?: AppDefinition[]): Array<{
   description?: string;
   icon?: string;
   createdAt: number;
+  updatedAt: number;
   version: string;
   contentId: string;
 }> {
@@ -101,6 +102,7 @@ function listAppsFiltered(apps?: AppDefinition[]): Array<{
       description: a.description,
       icon: a.icon,
       createdAt: a.createdAt,
+      updatedAt: a.updatedAt,
       version,
       contentId,
     };
@@ -751,6 +753,7 @@ export const ROUTES: RouteDefinition[] = [
           description: z.string().optional(),
           icon: z.string().optional(),
           createdAt: z.number(),
+          updatedAt: z.number(),
           version: z.string(),
           contentId: z.string(),
         }),

package/src/runtime/routes/conversation-routes.ts

@@ -1741,6 +1741,7 @@ export async function handleSendMessage(
         ...(body.automated === true ? { automated: true } : {}),
       },
       isInteractive,
+      sourceActorPrincipalId,
       transport,
       clientMessageId,
     });
@@ -1842,6 +1843,7 @@ export async function handleSendMessage(
     userMessageInterface: sourceInterface,
     assistantMessageInterface: sourceInterface,
   });
+  conversation.currentTurnSourceActorPrincipalId = sourceActorPrincipalId;
 
   await conversation.ensureActorScopedHistory();