@vellumai/assistant 0.11.5 → 0.11.6-staging.1

package/src/persistence/migrations/369-create-app-pins.ts

@@ -0,0 +1,37 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Creates `app_pins`: which apps the user pinned to the sidebar.
+ *
+ * A pin is a preference about an app rather than part of one, so it is keyed by
+ * app id here instead of living in the app's own on-disk record. That is what
+ * lets a plugin app be pinned: its record belongs to the plugin that ships it
+ * and the daemon does not write to it.
+ *
+ * `sort_position` is a fractional index, the same idiom `conversation_groups`
+ * uses, so a pin can be placed between two others by averaging their positions
+ * instead of renumbering the list.
+ *
+ * A row holds no display fields. Name and icon are read from the app at list
+ * time, so a renamed app renames its pin and a pin whose app is gone reaches
+ * no client.
+ *
+ * Idempotent: `IF NOT EXISTS` on the table and the index.
+ */
+export function migrateCreateAppPins(db: DrizzleDb): void {
+  const raw = getSqliteFrom(db);
+
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS app_pins (
+      app_id        TEXT PRIMARY KEY,
+      sort_position REAL NOT NULL,
+      color         TEXT,
+      created_at    INTEGER NOT NULL
+    )
+  `);
+
+  // The only read path: every pin, in sidebar order.
+  raw.exec(
+    `CREATE INDEX IF NOT EXISTS idx_app_pins_sort_position ON app_pins(sort_position)`,
+  );
+}

package/src/persistence/migrations/__tests__/367-create-watch-timeline-entries.test.ts

@@ -0,0 +1,98 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateWatchTimelineEntries } from "../367-create-watch-timeline-entries.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function columnNames(raw: Database): string[] {
+  const rows = raw
+    .prepare("PRAGMA table_info(watch_timeline_entries)")
+    .all() as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+function indexNames(raw: Database): string[] {
+  const rows = raw
+    .prepare(
+      `SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'watch_timeline_entries' AND sql IS NOT NULL ORDER BY name`,
+    )
+    .all() as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+function insertEntry(raw: Database, id: string, atMs: number): void {
+  raw.run(
+    `INSERT INTO watch_timeline_entries
+       (id, session_id, conversation_id, at_ms, kind, text, ax_tree, ax_diff, screenshot_attachment_id, created_at)
+     VALUES (?, 'sess-1', 'conv-1', ?, 'narration', 'hello', NULL, NULL, NULL, 1000)`,
+    [id, atMs],
+  );
+}
+
+describe("migration 367: create watch_timeline_entries", () => {
+  test("creates the table with every timeline column", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateCreateWatchTimelineEntries(db);
+
+    expect(columnNames(raw).sort()).toEqual([
+      "at_ms",
+      "ax_diff",
+      "ax_tree",
+      "conversation_id",
+      "created_at",
+      "id",
+      "kind",
+      "screenshot_attachment_id",
+      "session_id",
+      "text",
+    ]);
+  });
+
+  test("creates the session and conversation indexes", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateCreateWatchTimelineEntries(db);
+
+    expect(indexNames(raw)).toEqual([
+      "idx_watch_timeline_entries_conversation",
+      "idx_watch_timeline_entries_session",
+    ]);
+  });
+
+  test("is idempotent and preserves existing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateCreateWatchTimelineEntries(db);
+    insertEntry(raw, "entry-1", 1000);
+
+    expect(() => migrateCreateWatchTimelineEntries(db)).not.toThrow();
+
+    const rows = raw
+      .prepare("SELECT id, at_ms FROM watch_timeline_entries")
+      .all() as Array<{ id: string; at_ms: number }>;
+    expect(rows).toEqual([{ id: "entry-1", at_ms: 1000 }]);
+  });
+
+  test("rejects a duplicate entry id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateCreateWatchTimelineEntries(db);
+    insertEntry(raw, "entry-1", 1000);
+
+    expect(() => insertEntry(raw, "entry-1", 2000)).toThrow();
+  });
+});

package/src/persistence/migrations/__tests__/368-watch-timeline-screenshot-blob.test.ts

@@ -0,0 +1,98 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateWatchTimelineEntries } from "../367-create-watch-timeline-entries.js";
+import { migrateWatchTimelineScreenshotBlob } from "../368-watch-timeline-screenshot-blob.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateWatchTimelineEntries(db);
+  return db;
+}
+
+function columnNames(raw: Database): string[] {
+  const rows = raw
+    .prepare("PRAGMA table_info(watch_timeline_entries)")
+    .all() as Array<{ name: string }>;
+  return rows.map((row) => row.name).sort();
+}
+
+function insertEntry(raw: Database, id: string, screenshot: Buffer | null) {
+  raw.run(
+    `INSERT INTO watch_timeline_entries
+       (id, session_id, conversation_id, at_ms, kind, text, ax_tree, ax_diff, screenshot, created_at)
+     VALUES (?, 'sess-1', 'conv-1', 1000, 'observation', '', NULL, NULL, ?, 1000)`,
+    [id, screenshot],
+  );
+}
+
+describe("migration 368: watch timeline screenshot blob", () => {
+  test("adds the blob column and drops the attachment id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateWatchTimelineScreenshotBlob(db);
+
+    expect(columnNames(raw)).toEqual([
+      "at_ms",
+      "ax_diff",
+      "ax_tree",
+      "conversation_id",
+      "created_at",
+      "id",
+      "kind",
+      "screenshot",
+      "session_id",
+      "text",
+    ]);
+  });
+
+  test("stores frame bytes in the row and reads them back whole", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    migrateWatchTimelineScreenshotBlob(db);
+
+    const frame = Buffer.from([0xff, 0xd8, 0xff, 0x00, 0x10]);
+    insertEntry(raw, "entry-1", frame);
+    insertEntry(raw, "entry-2", null);
+
+    const rows = raw
+      .prepare(
+        "SELECT id, screenshot, length(screenshot) AS bytes FROM watch_timeline_entries ORDER BY id",
+      )
+      .all() as Array<{
+      id: string;
+      screenshot: unknown;
+      bytes: number | null;
+    }>;
+
+    expect(rows.map((row) => row.bytes)).toEqual([frame.length, null]);
+    expect(Buffer.from(rows[0]?.screenshot as Uint8Array)).toEqual(frame);
+  });
+
+  test("is idempotent and preserves existing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateWatchTimelineScreenshotBlob(db);
+    const frame = Buffer.from([1, 2, 3]);
+    insertEntry(raw, "entry-1", frame);
+
+    expect(() => migrateWatchTimelineScreenshotBlob(db)).not.toThrow();
+
+    const rows = raw
+      .prepare(
+        "SELECT id, length(screenshot) AS bytes FROM watch_timeline_entries",
+      )
+      .all() as Array<{ id: string; bytes: number }>;
+    expect(rows).toEqual([{ id: "entry-1", bytes: frame.length }]);
+    expect(columnNames(raw)).toContain("screenshot");
+    expect(columnNames(raw)).not.toContain("screenshot_attachment_id");
+  });
+});

package/src/persistence/schema/index.ts

@@ -16,4 +16,5 @@ export * from "./memory-injection.js";
 export * from "./notifications.js";
 export * from "./oauth.js";
 export * from "./tasks.js";
+export * from "./watch.js";
 export * from "./workflows.js";

package/src/persistence/schema/infrastructure.ts

@@ -91,6 +91,23 @@ export const sharedAppLinks = sqliteTable("shared_app_links", {
   expiresAt: integer("expires_at"),
 });
 
+/**
+ * Which apps the user pinned to the sidebar. A pin is a preference about an
+ * app rather than part of one, so it lives here rather than in the app's own
+ * record: plugin apps are pinnable and their records belong to the plugin that
+ * ships them.
+ *
+ * `sortPosition` is a fractional index, matching `conversation_groups`, so a
+ * pin can be placed between two others without renumbering the rest.
+ */
+export const appPins = sqliteTable("app_pins", {
+  appId: text("app_id").primaryKey(),
+  sortPosition: real("sort_position").notNull(),
+  /** An id from the client's pinned-app colour registry; null = uncoloured. */
+  color: text("color"),
+  createdAt: integer("created_at").notNull(),
+});
+
 export const publishedPages = sqliteTable("published_pages", {
   id: text("id").primaryKey(),
   deploymentId: text("deployment_id").notNull().unique(),

package/src/persistence/schema/watch.ts

@@ -0,0 +1,29 @@
+import { blob, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+/**
+ * One entry in a watch session's timeline: what the user narrated, or what
+ * was on their screen while they narrated it.
+ *
+ * The timeline is not conversation history. Entries are keyed by session and
+ * ordered by `atMs`, the offset from the session's start, and only a rendered
+ * summary reaches a model, composed by the retrospective that reads them.
+ *
+ * `screenshot` holds the frame itself, so the row is an entry's only home: one
+ * row, one lifetime, one delete. Reads that do not want the pixels select the
+ * other columns and leave this one alone.
+ */
+export const watchTimelineEntries = sqliteTable("watch_timeline_entries", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull(),
+  conversationId: text("conversation_id").notNull(),
+  /** Milliseconds since the session started. */
+  atMs: integer("at_ms").notNull(),
+  /** `narration` or `observation`. */
+  kind: text("kind").notNull(),
+  text: text("text").notNull(),
+  axTree: text("ax_tree"),
+  axDiff: text("ax_diff"),
+  /** JPEG bytes of the screen at `atMs`, or NULL when none was kept. */
+  screenshot: blob("screenshot", { mode: "buffer" }),
+  createdAt: integer("created_at").notNull(),
+});

package/src/persistence/steps.ts

@@ -474,6 +474,9 @@ import { migrateBackfillScheduleInferenceProfile } from "./migrations/363-backfi
 import { migrateAddScheduleSourceKey } from "./migrations/364-add-schedule-source-key.js";
 import { migrateAddConversationForkStrategy } from "./migrations/365-add-conversation-fork-strategy.js";
 import { migrateChatgptSubscriptionRowIdentity } from "./migrations/366-chatgpt-subscription-row-identity.js";
+import { migrateCreateWatchTimelineEntries } from "./migrations/367-create-watch-timeline-entries.js";
+import { migrateWatchTimelineScreenshotBlob } from "./migrations/368-watch-timeline-screenshot-blob.js";
+import { migrateCreateAppPins } from "./migrations/369-create-app-pins.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1582,4 +1585,7 @@ export const migrationSteps: MigrationStep[] = [
     // permanently checkpoint the no-op.
     dependsOn: ["migrateCreateProviderConnections"],
   },
+  migrateCreateWatchTimelineEntries,
+  migrateWatchTimelineScreenshotBlob,
+  migrateCreateAppPins,
 ];

package/src/plugins/mtime-cache.ts

@@ -291,6 +291,17 @@ export async function reconcilePluginSourcesNow(): Promise<void> {
     } catch (err) {
       log.error({ err }, "plugin MCP reconcile failed");
     }
+    // Converge sidebar pins the same way: an uninstalled plugin's app stops
+    // existing, and its id is a stable path identity, so a pin left behind
+    // would return to the sidebar when the plugin does. Lazily imported and
+    // self-contained for the same reasons as the two reconciles above.
+    try {
+      const { reconcileAppPins } =
+        await import("../apps/app-pin-reconciler.js");
+      reconcileAppPins();
+    } catch (err) {
+      log.error({ err }, "app pin reconcile failed");
+    }
   })().finally(() => {
     reconcileInFlight = null;
   });

package/src/providers/__tests__/retry-network-error.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import * as retryUtil from "../../util/retry.js";
+
+// Instant sleep so backoff delays don't slow the suite; everything else is
+// the real module.
+mock.module("../../util/retry.js", () => ({
+  ...retryUtil,
+  sleep: async () => {},
+}));
+
+const { RetryProvider } = await import("../retry.js");
+const { ProviderError } = await import("../../util/errors.js");
+
+import type { Message, Provider, ProviderResponse } from "../types.js";
+
+const OK_RESPONSE = {
+  content: [{ type: "text", text: "ok" }],
+  model: "test-model",
+  usage: { inputTokens: 1, outputTokens: 1 },
+} as unknown as ProviderResponse;
+
+const MESSAGES: Message[] = [
+  { role: "user", content: [{ type: "text", text: "hi" }] },
+];
+
+/** Inner provider that throws the queued errors in order, then succeeds. */
+function flakyProvider(errors: unknown[]): {
+  provider: Provider;
+  calls: () => number;
+} {
+  let calls = 0;
+  const queue = [...errors];
+  const provider: Provider = {
+    name: "openai-compatible",
+    sendMessage: async () => {
+      calls += 1;
+      const next = queue.shift();
+      if (next !== undefined) {
+        throw next;
+      }
+      return OK_RESPONSE;
+    },
+  };
+  return { provider, calls: () => calls };
+}
+
+describe("RetryProvider network_error handling", () => {
+  test("retries a transport failure stamped with reason network_error", async () => {
+    const { provider, calls } = flakyProvider([
+      new ProviderError(
+        "OpenAI-compatible API error (unknown status): Connection error.",
+        "openai-compatible",
+        undefined,
+        { reason: "network_error" },
+      ),
+    ]);
+    const result = await new RetryProvider(provider).sendMessage(MESSAGES);
+    expect(result).toBe(OK_RESPONSE);
+    expect(calls()).toBe(2);
+  });
+
+  test("still does not retry a statusless reason-less abort-shaped error", async () => {
+    // OpenAI catch-sites do not distinguish inner stream deadlines from
+    // transport aborts, so their "Request was aborted." must stay
+    // non-retryable (see RETRYABLE_TRANSPORT_ABORT_PATTERNS).
+    const abortShaped = () =>
+      new ProviderError(
+        "OpenAI API error (unknown status): Request was aborted.",
+        "openai",
+        undefined,
+      );
+    const { provider, calls } = flakyProvider([
+      abortShaped(),
+      abortShaped(),
+      abortShaped(),
+      abortShaped(),
+    ]);
+    await expect(
+      new RetryProvider(provider).sendMessage(MESSAGES),
+    ).rejects.toThrow("Request was aborted");
+    expect(calls()).toBe(1);
+  });
+});

package/src/providers/connection-resolution.ts

@@ -41,7 +41,10 @@ import {
   describeSubscriptionModelIncompatibility,
   isConnectionCompatibleWithModel,
 } from "./connection-model-compat.js";
-import { VALID_CONNECTION_PROVIDERS } from "./inference/auth.js";
+import {
+  ROUTING_IDENTITY_PROVIDERS,
+  VALID_CONNECTION_PROVIDERS,
+} from "./inference/auth.js";
 import {
   canonicalVellumConnection,
   getConnection,
@@ -193,6 +196,25 @@ export function resolveEntryProviderKind(
   return entryName ? connectionProviderKind(entryName, model) : null;
 }
 
+/**
+ * The catalog provider whose model limits judge a profile's (provider,
+ * model) pair: routing identities translate to their concrete upstream
+ * (chatgpt serves the OpenAI catalog; a vellum profile's bare native model
+ * names its managed owner), and an entry-name label resolves to its row's
+ * dispatchable kind. Null when no upstream is derivable (the pair stays
+ * unjudged). Shared by the profile-route budget validation and profile
+ * materialization so the two cannot drift.
+ */
+export function catalogProviderForProfile(
+  provider: string,
+  model: string,
+): string | null {
+  if (ROUTING_IDENTITY_PROVIDERS.has(provider)) {
+    return provider === "chatgpt" ? "openai" : getManagedUpstream(model);
+  }
+  return resolveEntryProviderKind(provider, model) ?? provider;
+}
+
 /**
  * Resolve a Provider through a named `provider_connection`.
  *

package/src/providers/content-blocks.ts

@@ -16,6 +16,15 @@ export function hasVisibleText(content: ReadonlyArray<ContentBlock>): boolean {
   );
 }
 
+/** Whether `content` carries nothing a provider can serialize: no blocks, or only blank text. */
+export function isEffectivelyEmptyContent(
+  content: ReadonlyArray<ContentBlock>,
+): boolean {
+  return content.every(
+    (block) => block.type === "text" && block.text.trim().length === 0,
+  );
+}
+
 /** Whether `content` carries at least one tool call. */
 export function hasToolUse(content: ReadonlyArray<ContentBlock>): boolean {
   return content.some((block) => block.type === "tool_use");

package/src/providers/fetch-provider-catalog.ts

@@ -45,6 +45,14 @@ export interface FetchProviderCatalogEntry {
   /** Privacy-policy URL surfaced in marketing data-sharing docs.
    *  BYOK providers only. */
   readonly privacyPolicyUrl?: string;
+  /**
+   * When true, settings UIs show an optional API Base field. Empty /
+   * omitted base uses {@link defaultApiBase}.
+   */
+  readonly supportsApiBase?: boolean;
+  /** Cloud default origin when `supportsApiBase` is true and the user
+   *  leaves API Base empty. */
+  readonly defaultApiBase?: string;
 }
 
 export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
@@ -65,6 +73,17 @@ export const FETCH_PROVIDER_CATALOG: readonly FetchProviderCatalogEntry[] = [
     secretKey: "firecrawl",
     privacyPolicyUrl: "https://www.firecrawl.dev/privacy-policy",
   },
+  {
+    id: "fastcrw",
+    displayName: "fastCRW",
+    kind: "byok",
+    apiKeyPrefix: "crw_live_...",
+    envVar: "FASTCRW_API_KEY",
+    secretKey: "fastcrw",
+    privacyPolicyUrl: "https://fastcrw.com/privacy",
+    supportsApiBase: true,
+    defaultApiBase: "https://api.fastcrw.com",
+  },
 ];
 
 /** Provider ids accepted by the web-fetch config schema. */

package/src/providers/gemini/client.ts

@@ -720,15 +720,23 @@ export class GeminiProvider implements Provider {
         model,
         role,
       );
-      if (parts.length > 0) {
-        result.push({ role, parts });
+      // Gemini keeps functionResponse parts separate from other parts. Tool
+      // result media follows the function response before any remaining text.
+      const functionResponseParts = parts.filter(
+        (part) => part.functionResponse !== undefined,
+      );
+      const otherParts = parts.filter(
+        (part) => part.functionResponse === undefined,
+      );
+      if (functionResponseParts.length > 0) {
+        result.push({ role, parts: functionResponseParts });
       }
-      // Gemini requires that a Content with functionResponse parts must not
-      // contain non-functionResponse parts. Emit tool-result images in a
-      // separate user Content entry.
       if (toolResultMediaParts.length > 0) {
         result.push({ role: "user", parts: toolResultMediaParts });
       }
+      if (otherParts.length > 0) {
+        result.push({ role, parts: otherParts });
+      }
     }
 
     return result;

package/src/providers/inference/__tests__/endpoint-probe.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+
+import { testInferenceConnection } from "../endpoint-probe.js";
+
+// Keyless auth so the probe never touches the vault; the fetch stub records
+// the request instead of dialing out.
+const CONNECTION = {
+  provider: "openai-compatible",
+  auth: { type: "none" } as const,
+  baseUrl: "https://integrate.api.nvidia.com",
+  models: [{ id: "meta/llama-3.1-8b-instruct" }],
+};
+
+function stubFetch(status: number, calls: { url: string; body: unknown }[]) {
+  return (async (url: RequestInfo | URL, init?: RequestInit) => {
+    calls.push({
+      url: String(url),
+      body: JSON.parse(String(init?.body)),
+    });
+    return new Response(status < 400 ? "{}" : "404 page not found", { status });
+  }) as typeof fetch;
+}
+
+describe("testInferenceConnection", () => {
+  test("reports ok:false with a base-path hint on 404", async () => {
+    const calls: { url: string; body: unknown }[] = [];
+    const result = await testInferenceConnection(
+      CONNECTION,
+      stubFetch(404, calls),
+    );
+
+    expect(result).toMatchObject({
+      ok: false,
+      status: 404,
+      resolved_url: "https://integrate.api.nvidia.com/chat/completions",
+      error_class: "http_error",
+    });
+    expect(result?.hint).toContain("/v1");
+    expect(calls[0].body).toMatchObject({
+      model: "meta/llama-3.1-8b-instruct",
+      max_tokens: 1,
+    });
+  });
+
+  test("reports ok:true on 200 from a correct base URL", async () => {
+    const calls: { url: string; body: unknown }[] = [];
+    const result = await testInferenceConnection(
+      { ...CONNECTION, baseUrl: "https://integrate.api.nvidia.com/v1" },
+      stubFetch(200, calls),
+    );
+
+    expect(result).toMatchObject({
+      ok: true,
+      status: 200,
+      resolved_url: "https://integrate.api.nvidia.com/v1/chat/completions",
+    });
+    expect(result?.hint).toBeUndefined();
+  });
+
+  test("hints at the credential on 401", async () => {
+    const result = await testInferenceConnection(
+      CONNECTION,
+      stubFetch(401, []),
+    );
+    expect(result).toMatchObject({ ok: false, status: 401 });
+    expect(result?.hint).toContain("API key");
+  });
+
+  test("reports a network error_class when the endpoint is unreachable", async () => {
+    const failingFetch = (async () => {
+      throw new Error("connection refused");
+    }) as unknown as typeof fetch;
+    const result = await testInferenceConnection(CONNECTION, failingFetch);
+    expect(result).toMatchObject({ ok: false, error_class: "network" });
+    expect(result?.hint).toContain("connection refused");
+  });
+
+  test("skips when there is no base URL or no model to probe with", async () => {
+    const neverFetch = (async () => {
+      throw new Error("should not be called");
+    }) as unknown as typeof fetch;
+    expect(
+      await testInferenceConnection(
+        { ...CONNECTION, baseUrl: null },
+        neverFetch,
+      ),
+    ).toBeNull();
+    expect(
+      await testInferenceConnection({ ...CONNECTION, models: [] }, neverFetch),
+    ).toBeNull();
+  });
+});

package/src/providers/inference/__tests__/profile-config-validation.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+
+import { validateInferenceProfileConfig } from "../../../api/constants/profile-config-validation.js";
+
+describe("validateInferenceProfileConfig", () => {
+  test("rejects an output budget that consumes the whole context window", () => {
+    const issue = validateInferenceProfileConfig({
+      maxTokens: 300000,
+      modelContextWindowTokens: 300000,
+    });
+    expect(issue?.field).toBe("maxTokens");
+    expect(issue?.message).toContain("context window");
+  });
+
+  test("passes an output budget that leaves input room", () => {
+    expect(
+      validateInferenceProfileConfig({
+        maxTokens: 8000,
+        modelContextWindowTokens: 300000,
+      }),
+    ).toBeNull();
+  });
+
+  test("rejects an output budget over the model's output cap", () => {
+    const issue = validateInferenceProfileConfig({
+      maxTokens: 100000,
+      modelMaxOutputTokens: 64000,
+      modelContextWindowTokens: 200000,
+    });
+    expect(issue?.message).toContain("maximum output");
+  });
+
+  test("silent when either side of the judgment is unknown", () => {
+    expect(validateInferenceProfileConfig({ maxTokens: 300000 })).toBeNull();
+    expect(
+      validateInferenceProfileConfig({ modelContextWindowTokens: 300000 }),
+    ).toBeNull();
+  });
+});