@vellumai/assistant 0.11.4-staging.1 → 0.11.4-staging.2

package/src/util/think-tag-stream.ts

@@ -0,0 +1,95 @@
+/**
+ * Shared primitives for streaming think-tag scanning.
+ *
+ * Two consumers parse inline `<think>` spans out of streamed model content
+ * and must not drift apart (single source of truth):
+ *
+ * - `providers/openai/chat-completions-provider.ts` ROUTES the spans to
+ *   `thinking_delta` events (content preserved, case-sensitive `<think>`
+ *   only, matching the models that emit it).
+ * - `tts/reasoning-tag-filter.ts` DROPS the spans from the spoken stream
+ *   (case-insensitive, `<think>` and `<thinking>` variants).
+ *
+ * The state machines stay separate because they do different things with
+ * the reasoning; what they share is the tag scanning below. All scanning is
+ * positionally exact on the ORIGINAL string: case-insensitive mode folds
+ * A-Z per character code and never calls `toLowerCase()` on the haystack,
+ * because Unicode lowercasing can change string length (e.g. dotted capital
+ * I, U+0130, lowers to two code units) and shift every subsequent index.
+ * Tags must be given in lowercase ASCII.
+ */
+
+function foldedCharCode(code: number, caseInsensitive: boolean): number {
+  return caseInsensitive && code >= 65 && code <= 90 ? code + 32 : code;
+}
+
+function tagMatchesAt(
+  haystack: string,
+  start: number,
+  tag: string,
+  caseInsensitive: boolean,
+): boolean {
+  if (start + tag.length > haystack.length) {
+    return false;
+  }
+  for (let k = 0; k < tag.length; k += 1) {
+    if (
+      foldedCharCode(haystack.charCodeAt(start + k), caseInsensitive) !==
+      tag.charCodeAt(k)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * First occurrence of any tag in `haystack`, by original-string index.
+ * When several tags match at the same index the longest wins, so
+ * `<thinking>` is not consumed as `<think>` plus stray text.
+ */
+export function indexOfTag(
+  haystack: string,
+  tags: readonly string[],
+  caseInsensitive: boolean,
+): { index: number; tag: string } | null {
+  for (let i = 0; i < haystack.length; i += 1) {
+    let bestTag: string | null = null;
+    for (const tag of tags) {
+      if (tagMatchesAt(haystack, i, tag, caseInsensitive)) {
+        if (bestTag === null || tag.length > bestTag.length) {
+          bestTag = tag;
+        }
+      }
+    }
+    if (bestTag !== null) {
+      return { index: i, tag: bestTag };
+    }
+  }
+  return null;
+}
+
+/**
+ * Length of the longest suffix of `text` that is a proper prefix of any
+ * listed tag. Streaming scanners hold that many characters back so a tag
+ * split across deltas is not emitted before it can be recognized.
+ */
+export function partialTagSuffix(
+  text: string,
+  tags: readonly string[],
+  caseInsensitive: boolean,
+): number {
+  const longest = Math.max(...tags.map((tag) => tag.length)) - 1;
+  for (let len = Math.min(text.length, longest); len > 0; len -= 1) {
+    const start = text.length - len;
+    for (const tag of tags) {
+      if (
+        len < tag.length &&
+        tagMatchesAt(text, start, tag.slice(0, len), caseInsensitive)
+      ) {
+        return len;
+      }
+    }
+  }
+  return 0;
+}

package/src/workspace/byok-default-profile-ensure.ts

@@ -163,9 +163,10 @@ function foldPersonalEntryName(provider: string): string {
  * 2026-05-05, #29755), and the profile-model migrations (100, 103, 109, 113,
  * 123) deliberately rewrite only the managed default entries (`custom-*` is
  * the user's to manage), so an untouched copy still carries whichever value
- * its hatch-era intent resolved to. Migration 136 is the one exception: it
- * rewrote kimi-k2p5 pins (`custom-*` included) to deepseek-v4-flash in
- * place. A model listed here counts as unedited only when every non-model
+ * its hatch-era intent resolved to. Migrations 136 and 146 are the
+ * exceptions: they rewrite stale Fireworks pins (`custom-*` included) in
+ * place, so their targets are machinery-authored values too. A model listed
+ * here counts as unedited only when every non-model
  * field still matches the template.
  */
 const HISTORICAL_INTENT_MODELS: Record<
@@ -184,6 +185,8 @@ const HISTORICAL_INTENT_MODELS: Record<
       "accounts/fireworks/models/kimi-k2p6",
       // migration 136's in-place rewrite of a kimi-k2p5 pin.
       "accounts/fireworks/models/deepseek-v4-flash",
+      // the ID migration 146 writes over stale deepseek-v4-flash pins.
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
     ],
   },
   "quality-optimized": {
@@ -208,6 +211,8 @@ const HISTORICAL_INTENT_MODELS: Record<
       "accounts/fireworks/models/kimi-k2p5",
       // migration 136's in-place rewrite of a kimi-k2p5 pin.
       "accounts/fireworks/models/deepseek-v4-flash",
+      // the ID migration 146 writes over stale deepseek-v4-flash pins.
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
     ],
   },
   "cost-optimized": {
@@ -221,10 +226,14 @@ const HISTORICAL_INTENT_MODELS: Record<
     ],
     fireworks: [
       // latency intent 2026-05-05 (#29755) to 2026-07-28 (#39446). On live
-      // configs migration 136 rewrote it to deepseek-v4-flash (the current
-      // intent), so this survives only in configs restored from pre-136
-      // backups.
+      // configs migration 136 rewrites it to deepseek-v4-flash, so this
+      // survives only in configs restored from pre-136 backups.
       "accounts/fireworks/models/kimi-k2p5",
+      // latency intent 2026-07-28 (#39446) to the 2026-08-17 dated-ID
+      // repoint; also the ID migration 136 writes. On live configs migration
+      // 146 rewrites it to the dated ID, so this survives only in pre-146
+      // backups.
+      "accounts/fireworks/models/deepseek-v4-flash",
     ],
   },
 };

package/src/workspace/migrations/146-repair-retired-fireworks-deepseek-flash-model-id.ts

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Repair the retired undated Fireworks DeepSeek V4 Flash model ID in
+ * workspace LLM config.
+ *
+ * Fireworks serves DeepSeek V4 Flash only under the dated official release
+ * ID `accounts/fireworks/models/deepseek-v4-flash-0731`; the undated
+ * `accounts/fireworks/models/deepseek-v4-flash` has no deployment and every
+ * call to it fails with a 404 "Model not found, inaccessible, and/or not
+ * deployed". Existing configs can still pin the undated ID in
+ * `llm.default`, `llm.callSites.*`, and `llm.profiles.*`.
+ *
+ * Repair those leaves only on an exact stale match, replacing with the
+ * dated ID.
+ *
+ * Provider guard: the stale ID belongs to the `fireworks` provider and also
+ * appears in managed profiles stamped `provider: "vellum"` (which route
+ * Fireworks-account model IDs through the managed proxy). Under the entries
+ * model (migration 145) `provider` can also hold a `provider_connections`
+ * entry name whose row kind drives dispatch. A fragment is repaired when
+ * its `provider` is `"fireworks"`, `"vellum"`, absent, or an entry name
+ * whose row kind is one of those: every fireworks-kind route serves the
+ * dated ID and only the dated ID. Any other provider is left untouched: an
+ * `openai-compatible` endpoint may legitimately serve a model by the stale
+ * name.
+ */
+export const repairRetiredFireworksDeepseekFlashModelIdMigration: WorkspaceMigration =
+  {
+    id: "146-repair-retired-fireworks-deepseek-flash-model-id",
+    description:
+      "Repair retired Fireworks accounts/fireworks/models/deepseek-v4-flash model ID in workspace LLM config",
+    run(workspaceDir: string): void {
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) {
+        return;
+      }
+
+      // Read outside the parse catch: a transient filesystem error (EIO,
+      // EACCES) must reach the runner so the migration retries, while
+      // malformed JSON is a permanent state this migration cannot repair.
+      const rawText = readFileSync(configPath, "utf-8");
+
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(rawText);
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          return;
+        }
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+
+      const llm = readObject(config.llm);
+      if (llm === null) {
+        return;
+      }
+
+      // Entry rows load lazily: only a stale fragment whose provider is
+      // neither a repairable vendor nor absent needs them. An unreadable DB
+      // then fails the run (retried next boot) rather than checkpointing a
+      // pass that skips entry-bound profiles.
+      let rows: Map<string, string> | null | undefined;
+      const isRepairableProvider = (provider: unknown): boolean => {
+        if (provider === undefined) {
+          return true;
+        }
+        if (typeof provider !== "string") {
+          return false;
+        }
+        if (REPAIRABLE_PROVIDERS.has(provider)) {
+          return true;
+        }
+        if (rows === undefined) {
+          rows = readConnectionRows(workspaceDir);
+        }
+        if (rows === null) {
+          throw new Error(
+            "provider_connections is not readable; retrying the model-ID repair on the next run",
+          );
+        }
+        const kind = rows.get(provider);
+        return kind !== undefined && REPAIRABLE_PROVIDERS.has(kind);
+      };
+
+      let changed = false;
+
+      changed =
+        repairFragment(readObject(llm.default), isRepairableProvider) ||
+        changed;
+
+      const callSites = readObject(llm.callSites);
+      if (callSites !== null) {
+        for (const rawConfig of Object.values(callSites)) {
+          changed =
+            repairFragment(readObject(rawConfig), isRepairableProvider) ||
+            changed;
+        }
+      }
+
+      const profiles = readObject(llm.profiles);
+      if (profiles !== null) {
+        for (const rawProfile of Object.values(profiles)) {
+          changed =
+            repairFragment(readObject(rawProfile), isRepairableProvider) ||
+            changed;
+        }
+      }
+
+      if (!changed) {
+        return;
+      }
+
+      // Write-then-rename so an interrupted write cannot leave config.json
+      // truncated: a torn in-place write would parse as invalid JSON on the
+      // retry, which the catch above treats as "nothing to do", letting the
+      // runner checkpoint the migration as completed against a corrupt file.
+      const tmpPath = `${configPath}.migration-146.tmp`;
+      writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
+      renameSync(tmpPath, configPath);
+    },
+    // The exact-match rewrite is idempotent, so a transient failure (full
+    // disk, I/O error) is safe to retry on later startups.
+    retryFailedCheckpoint: true,
+    down(_workspaceDir: string): void {
+      // Forward-only: reintroducing the retired model ID would break
+      // Fireworks calls.
+    },
+  };
+
+// ---------------------------------------------------------------------------
+// Helpers: self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const STALE_MODEL_ID = "accounts/fireworks/models/deepseek-v4-flash";
+const REPLACEMENT_MODEL_ID = "accounts/fireworks/models/deepseek-v4-flash-0731";
+const REPAIRABLE_PROVIDERS = new Set(["fireworks", "vellum"]);
+
+function repairFragment(
+  fragment: Record<string, unknown> | null,
+  isRepairableProvider: (provider: unknown) => boolean,
+): boolean {
+  if (fragment === null) {
+    return false;
+  }
+  if (fragment.model !== STALE_MODEL_ID) {
+    return false;
+  }
+  if (!isRepairableProvider(fragment.provider)) {
+    return false;
+  }
+  fragment.model = REPLACEMENT_MODEL_ID;
+  return true;
+}
+
+/**
+ * Connection name -> provider kind, or null when the DB or table is not
+ * readable. The caller fails the run on null: entry-name providers must be
+ * judged against real rows, never guessed. An absent DB file is a real
+ * state (no rows, so every entry name is dangling and stays untouched).
+ */
+function readConnectionRows(workspaceDir: string): Map<string, string> | null {
+  const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(dbPath)) {
+    return new Map();
+  }
+  let db: Database;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    return null;
+  }
+  try {
+    const rows = db
+      .query(`SELECT name, provider FROM provider_connections`)
+      .all() as Array<{ name: string; provider: string }>;
+    return new Map(rows.map((r) => [r.name, r.provider]));
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}

package/src/workspace/migrations/registry.ts

@@ -143,6 +143,7 @@ import { consolidateVoiceFrontDoorMigration } from "./142-consolidate-voice-fron
 import { repairDeprecatedCodexModelIdMigration } from "./143-repair-deprecated-codex-model-id.js";
 import { convertStrandedSubscriptionOpenaiProfilesMigration } from "./144-convert-stranded-subscription-openai-profiles.js";
 import { collapseProfileBindingsToEntriesMigration } from "./145-collapse-profile-bindings-to-entries.js";
+import { repairRetiredFireworksDeepseekFlashModelIdMigration } from "./146-repair-retired-fireworks-deepseek-flash-model-id.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -301,4 +302,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   repairDeprecatedCodexModelIdMigration,
   convertStrandedSubscriptionOpenaiProfilesMigration,
   collapseProfileBindingsToEntriesMigration,
+  repairRetiredFireworksDeepseekFlashModelIdMigration,
 ];