@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/workspace/migrations/097-enable-adaptive-thinking-managed-profiles.ts

@@ -23,11 +23,14 @@ import type { WorkspaceMigration } from "./types.js";
 //   - Are source: "user" (user-created profiles are untouched)
 //   - Have a non-managed, non-absent source (unknown origin)
 //   - Resolve to a non-Anthropic provider (adaptive thinking is
-//     Anthropic-specific). A profile with no explicit provider inherits
-//     llm.default.provider, so the check falls back to that — with a
-//     completely absent llm.default.provider treated as Anthropic, matching
-//     migration 052's own `?? "anthropic"` default. This keeps the legacy
-//     non-Anthropic empty `{}` shells seeded by migration 052 off the repair.
+//     Anthropic-specific). Effective provider is the profile's explicit
+//     `provider`; otherwise the provider implied by a known Claude `model`
+//     (mirroring the resolver's withImpliedProviderForKnownModel); otherwise
+//     llm.default.provider — with a completely absent llm.default.provider
+//     treated as Anthropic, matching migration 052's own `?? "anthropic"`
+//     default. This keeps the legacy non-Anthropic empty `{}` shells seeded by
+//     migration 052 off the repair while still patching profiles that pin a
+//     known Claude model under a non-Anthropic default.
 //
 // Note: the live startup path re-runs the same repair after the platform
 // overlay merge — see assistant/src/workspace/adaptive-thinking-repair.ts.
@@ -61,8 +64,9 @@ export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration
       const profiles = readObject(llm.profiles);
       if (profiles === null) return;
 
-      // Profiles without an explicit provider inherit llm.default.provider at
-      // resolution time; an absent llm.default.provider resolves to Anthropic.
+      // Profiles without an explicit provider and without a model-implied
+      // provider inherit llm.default.provider at resolution time; an absent
+      // llm.default.provider resolves to Anthropic.
       const defaultBlock = readObject(llm.default);
       const defaultProvider =
         typeof defaultBlock?.provider === "string"
@@ -79,17 +83,19 @@ export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration
         // Legacy profiles created before the `source` metadata field was
         // introduced have source=undefined. Treat these as managed when the
         // profile name is one of the canonical managed names (which
-        // TARGET_PROFILES already guarantees) and the effective provider —
-        // explicit, or inherited from llm.default — is Anthropic. Explicit
-        // `source: "user"` profiles are always skipped.
+        // TARGET_PROFILES already guarantees) and the effective provider is
+        // Anthropic. Effective provider is the explicit `provider`, else the
+        // provider implied by a known Claude `model`, else the inherited
+        // llm.default.provider. Explicit `source: "user"` profiles are always
+        // skipped.
         if (profile.source === "user") continue;
         if (profile.source !== undefined && profile.source !== "managed") {
           continue;
         }
-        const effectiveProvider =
-          typeof profile.provider === "string"
-            ? profile.provider
-            : defaultProvider;
+        const effectiveProvider = resolveEffectiveProvider(
+          profile,
+          defaultProvider,
+        );
         if (effectiveProvider !== "anthropic") continue;
 
         // Skip if thinking is already enabled.
@@ -112,6 +118,27 @@ export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration
     },
   };
 
+// Inline, conservative mirror of the resolver's catalog-based provider
+// implication. Migration modules are frozen, self-contained snapshots and must
+// not import the live model catalog. Anthropic's catalog model ids are bare
+// `claude-*` ids (the slash-prefixed `anthropic/claude-*` ids belong to
+// OpenRouter), so a profile pinning a `claude-*` model with no slash counts as
+// Anthropic.
+function resolveEffectiveProvider(
+  profile: Record<string, unknown>,
+  defaultProvider: string,
+): string {
+  if (typeof profile.provider === "string") return profile.provider;
+  if (
+    typeof profile.model === "string" &&
+    profile.model.startsWith("claude-") &&
+    !profile.model.includes("/")
+  ) {
+    return "anthropic";
+  }
+  return defaultProvider;
+}
+
 function readObject(value: unknown): Record<string, unknown> | null {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;

package/src/workspace/migrations/102-preserve-heartbeat-enabled-for-existing-workspaces.ts

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { MigrationRunContext, WorkspaceMigration } from "./types.js";
+
+/**
+ * Preserve heartbeat behavior for existing workspaces after the schema
+ * default for `heartbeat.enabled` flipped from true to false (heartbeats are
+ * now opt-in for new users).
+ *
+ * Most configs never persist `heartbeat.enabled` — they relied on the old
+ * default-on schema behavior, so flipping the default would silently turn
+ * heartbeats off on upgrade. This migration writes an explicit
+ * `enabled: true` for upgrading workspaces that have no persisted value,
+ * keeping their effective behavior unchanged. Workspaces with an explicit
+ * `enabled` value (either way) are a user choice and are left untouched.
+ * Fresh workspaces are skipped so new users start with heartbeats off.
+ */
+export const preserveHeartbeatEnabledForExistingWorkspacesMigration: WorkspaceMigration =
+  {
+    id: "102-preserve-heartbeat-enabled-for-existing-workspaces",
+    description:
+      "Persist heartbeat.enabled=true for existing workspaces now that the default is off",
+    run(workspaceDir: string, ctx?: MigrationRunContext): void {
+      // Fresh workspaces get the new opt-in default. Without a context
+      // (older callers), treat the workspace as existing — writing
+      // enabled=true reproduces the legacy default and never disables
+      // heartbeats for anyone.
+      if (ctx?.isNewWorkspace) return;
+
+      const configPath = join(workspaceDir, "config.json");
+
+      // Existing workspaces may have no config.json at all (schema defaults
+      // are applied in memory at load time); create one so the legacy
+      // default-on behavior survives the flip.
+      let config: Record<string, unknown> = {};
+      if (existsSync(configPath)) {
+        try {
+          const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+          if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+          config = raw as Record<string, unknown>;
+        } catch {
+          return;
+        }
+      }
+
+      if (config.heartbeat === undefined) {
+        config.heartbeat = {};
+      }
+      const heartbeat = config.heartbeat;
+      if (
+        !heartbeat ||
+        typeof heartbeat !== "object" ||
+        Array.isArray(heartbeat)
+      ) {
+        return;
+      }
+
+      const heartbeatConfig = heartbeat as Record<string, unknown>;
+      if ("enabled" in heartbeatConfig) return;
+
+      heartbeatConfig.enabled = true;
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    },
+    down(_workspaceDir: string): void {
+      // Forward-only: cannot distinguish users who explicitly enabled
+      // heartbeats from those opted in by this migration.
+    },
+  };

package/src/workspace/migrations/103-upgrade-quality-profile-to-opus-4-8.ts

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Move the managed quality-optimized profile from Claude Fable 5 to Opus 4.8.
+//
+// The quality-optimized intent maps to claude-opus-4-8, but the intent map is
+// only consulted when a profile is seeded: off-platform installs reseed
+// managed profiles on every boot, while on-platform workspaces keep the
+// profile they were hatched with — the seeder skips existing profiles there,
+// and the hatch overlay is consumed exactly once. A platform workspace holding
+// a Claude Fable 5 quality-optimized profile therefore keeps it until a
+// migration rewrites it.
+//
+// Only the managed quality-optimized profile is touched — the user-owned
+// custom-quality-optimized copy is theirs to manage. Within it, only a profile
+// still on claude-fable-5 is rewritten — matching by model value also covers
+// the OpenRouter-prefixed id. A profile whose model the user changed to
+// anything else is left untouched.
+
+const TARGET_PROFILES = ["quality-optimized"];
+
+const MODEL_UPGRADES: Record<string, string> = {
+  "claude-fable-5": "claude-opus-4-8",
+  "anthropic/claude-fable-5": "anthropic/claude-opus-4.8",
+};
+
+export const upgradeQualityProfileToOpus48Migration: WorkspaceMigration = {
+  id: "103-upgrade-quality-profile-to-opus-4-8",
+  description:
+    "Move the managed quality-optimized profile from Claude Fable 5 to Opus 4.8",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      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;
+
+    const profiles = readObject(llm.profiles);
+    if (profiles === null) return;
+
+    let changed = false;
+
+    for (const name of TARGET_PROFILES) {
+      const profile = readObject(profiles[name]);
+      if (profile === null) continue;
+      if (typeof profile.model !== "string") continue;
+
+      const upgraded = MODEL_UPGRADES[profile.model];
+      if (upgraded === undefined) continue;
+
+      profile.model = upgraded;
+      profiles[name] = profile;
+      changed = true;
+    }
+
+    if (changed) {
+      llm.profiles = profiles;
+      config.llm = llm;
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+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/104-recheck-adaptive-thinking-model-implied-anthropic.ts

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Re-run the adaptive-thinking repair on managed "balanced" and
+// "quality-optimized" profiles, this time honoring the provider implied by a
+// known Claude `model`.
+//
+// Migration 097 patches managed Anthropic profiles to enable adaptive thinking.
+// Its original release classified a source-less profile by
+// `profile.provider ?? llm.default.provider`, so a profile that omits
+// `provider` but pins a known Claude `model` under a non-Anthropic default was
+// treated as non-Anthropic and skipped — even though the resolver implies
+// Anthropic from the model id. 097's frozen copy was later corrected to imply
+// the provider from the model, but workspaces that already ran 097 have it
+// checkpointed as completed, so the corrected logic never re-runs for them.
+// The live startup repair (adaptive-thinking-repair.ts) only runs behind the
+// hatch overlay, which is archived after hatch, so already-hatched platform
+// instances are not covered either.
+//
+// This migration re-applies the corrected repair once for those checkpointed
+// workspaces. It is idempotent: profiles that already have thinking enabled are
+// left untouched, so workspaces that were already patched (or that never had
+// the gap) are no-ops.
+//
+// The migration keeps its own frozen copy of the logic because migration
+// modules are self-contained snapshots and must never be imported by other
+// code.
+
+const ADAPTIVE_THINKING = { enabled: true, streamThinking: true } as const;
+const TARGET_PROFILES = ["balanced", "quality-optimized"] as const;
+
+export const recheckAdaptiveThinkingModelImpliedAnthropicMigration: WorkspaceMigration =
+  {
+    id: "104-recheck-adaptive-thinking-model-implied-anthropic",
+    description:
+      "Re-enable adaptive thinking on managed profiles that imply Anthropic via a known Claude model",
+    run(workspaceDir: string): void {
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) return;
+
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        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;
+
+      const profiles = readObject(llm.profiles);
+      if (profiles === null) return;
+
+      // Profiles without an explicit provider and without a model-implied
+      // provider inherit llm.default.provider at resolution time; an absent
+      // llm.default.provider resolves to Anthropic.
+      const defaultBlock = readObject(llm.default);
+      const defaultProvider =
+        typeof defaultBlock?.provider === "string"
+          ? defaultBlock.provider
+          : "anthropic";
+
+      let changed = false;
+
+      for (const name of TARGET_PROFILES) {
+        const profile = readObject(profiles[name]);
+        if (profile === null) continue;
+
+        // Only patch managed Anthropic profiles. Explicit `source: "user"`
+        // profiles and non-managed, non-absent sources are skipped. Effective
+        // provider is the explicit `provider`, else the provider implied by a
+        // known Claude `model`, else the inherited llm.default.provider.
+        if (profile.source === "user") continue;
+        if (profile.source !== undefined && profile.source !== "managed") {
+          continue;
+        }
+        const effectiveProvider = resolveEffectiveProvider(
+          profile,
+          defaultProvider,
+        );
+        if (effectiveProvider !== "anthropic") continue;
+
+        // Skip if thinking is already enabled.
+        const thinking = readObject(profile.thinking);
+        if (thinking !== null && thinking.enabled === true) continue;
+
+        profile.thinking = { ...ADAPTIVE_THINKING };
+        profiles[name] = profile;
+        changed = true;
+      }
+
+      if (changed) {
+        llm.profiles = profiles;
+        config.llm = llm;
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      }
+    },
+    down(_workspaceDir: string): void {
+      // Forward-only.
+    },
+  };
+
+// Inline, conservative mirror of the resolver's catalog-based provider
+// implication. Migration modules are frozen, self-contained snapshots and must
+// not import the live model catalog. Anthropic's catalog model ids are bare
+// `claude-*` ids (the slash-prefixed `anthropic/claude-*` ids belong to
+// OpenRouter), so a profile pinning a `claude-*` model with no slash counts as
+// Anthropic.
+function resolveEffectiveProvider(
+  profile: Record<string, unknown>,
+  defaultProvider: string,
+): string {
+  if (typeof profile.provider === "string") return profile.provider;
+  if (
+    typeof profile.model === "string" &&
+    profile.model.startsWith("claude-") &&
+    !profile.model.includes("/")
+  ) {
+    return "anthropic";
+  }
+  return defaultProvider;
+}
+
+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

@@ -99,6 +99,9 @@ import { removeStaleUpdatesBulletinFileMigration } from "./098-remove-stale-upda
 import { disableCacheOneShotCallsitesMigration } from "./099-disable-cache-one-shot-callsites.js";
 import { upgradeQualityProfileToFable5Migration } from "./100-upgrade-quality-profile-to-fable-5.js";
 import { upgradeBalancedEconomyToMinimaxM3Migration } from "./101-upgrade-balanced-economy-to-minimax-m3.js";
+import { preserveHeartbeatEnabledForExistingWorkspacesMigration } from "./102-preserve-heartbeat-enabled-for-existing-workspaces.js";
+import { upgradeQualityProfileToOpus48Migration } from "./103-upgrade-quality-profile-to-opus-4-8.js";
+import { recheckAdaptiveThinkingModelImpliedAnthropicMigration } from "./104-recheck-adaptive-thinking-model-implied-anthropic.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -209,4 +212,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   disableCacheOneShotCallsitesMigration,
   upgradeQualityProfileToFable5Migration,
   upgradeBalancedEconomyToMinimaxM3Migration,
+  preserveHeartbeatEnabledForExistingWorkspacesMigration,
+  upgradeQualityProfileToOpus48Migration,
+  recheckAdaptiveThinkingModelImpliedAnthropicMigration,
 ];

package/src/workspace/migrations/runner.ts

@@ -197,7 +197,7 @@ export async function runWorkspaceMigrations(
  * workspace migrations while the assistant is running may cause file conflicts,
  * stale caches, or data corruption.
  *
- * @param workspaceDir  The workspace directory path (e.g., `~/.vellum/workspace`).
+ * @param workspaceDir  The workspace directory path (e.g., `$VELLUM_WORKSPACE_DIR`).
  * @param migrations  The full ordered array of workspace migrations (from `WORKSPACE_MIGRATIONS`).
  * @param targetMigrationId  The migration ID to roll back to (exclusive — all
  *   migrations after this one are reversed).

package/tsconfig.json

@@ -19,5 +19,5 @@
     }
   },
   "include": ["src/**/*", "src/**/*.tsx", "examples/**/*.ts"],
-  "exclude": ["node_modules", "dist", "drizzle"]
+  "exclude": ["node_modules", "dist", "drizzle", "src/config/preloaded-apps"]
 }

package/src/__tests__/guardian-action-copy-generator.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type {
-  GuardianActionMessageContext,
-  GuardianActionMessageScenario,
-} from "../runtime/guardian-action-message-composer.js";
-import {
-  composeGuardianActionMessageGenerative,
-  getGuardianActionFallbackMessage,
-} from "../runtime/guardian-action-message-composer.js";
-import type { GuardianActionCopyGenerator } from "../runtime/http-types.js";
-
-// ---------------------------------------------------------------------------
-// Every scenario must produce a non-empty string
-// ---------------------------------------------------------------------------
-
-const ALL_SCENARIOS: GuardianActionMessageScenario[] = [
-  "caller_timeout_acknowledgment",
-  "caller_timeout_continue",
-  "guardian_late_answer_followup",
-  "guardian_followup_dispatching",
-  "guardian_followup_completed",
-  "guardian_followup_failed",
-  "guardian_followup_declined_ack",
-  "guardian_followup_clarification",
-  "guardian_pending_disambiguation",
-  "guardian_expired_disambiguation",
-  "guardian_followup_disambiguation",
-  "guardian_stale_answered",
-  "guardian_stale_expired",
-  "guardian_stale_followup",
-  "guardian_stale_superseded",
-  "guardian_superseded_remap",
-  "guardian_unknown_code",
-  "guardian_auto_matched",
-  "followup_call_started",
-  "followup_action_failed",
-  "guardian_answer_delivery_failed",
-];
-
-describe("guardian-action-copy-generator", () => {
-  // -----------------------------------------------------------------------
-  // Fallback messages -- every scenario produces non-empty output
-  // -----------------------------------------------------------------------
-
-  describe("getGuardianActionFallbackMessage", () => {
-    for (const scenario of ALL_SCENARIOS) {
-      test(`scenario "${scenario}" produces a non-empty string`, () => {
-        const msg = getGuardianActionFallbackMessage({ scenario });
-        expect(typeof msg).toBe("string");
-        expect(msg.trim().length).toBeGreaterThan(0);
-      });
-    }
-
-    test("caller_timeout_acknowledgment includes guardianIdentifier when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "caller_timeout_acknowledgment",
-        guardianIdentifier: "Dr. Smith",
-      });
-      expect(msg).toContain("Dr. Smith");
-    });
-
-    test("guardian_late_answer_followup includes callerIdentifier when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_late_answer_followup",
-        callerIdentifier: "Alice",
-      });
-      expect(msg).toContain("Alice");
-    });
-
-    test("guardian_followup_dispatching includes followupAction when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_followup_dispatching",
-        followupAction: "send them a text message",
-      });
-      expect(msg).toContain("send them a text message");
-    });
-
-    test("guardian_followup_completed includes followupAction when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_followup_completed",
-        followupAction: "sent the message",
-      });
-      expect(msg).toContain("sent the message");
-    });
-
-    test("guardian_followup_failed includes failureReason when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_followup_failed",
-        failureReason: "The phone number is not valid.",
-      });
-      expect(msg).toContain("The phone number is not valid.");
-    });
-
-    test("guardian_expired_disambiguation includes request codes when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_expired_disambiguation",
-        requestCodes: ["Q1A2B3", "Q9Z8Y7"],
-      });
-      expect(msg).toContain("Q1A2B3");
-      expect(msg).toContain("Q9Z8Y7");
-    });
-
-    test("guardian_followup_disambiguation includes request codes when provided", () => {
-      const msg = getGuardianActionFallbackMessage({
-        scenario: "guardian_followup_disambiguation",
-        requestCodes: ["QFOO12"],
-      });
-      expect(msg).toContain("QFOO12");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // composeGuardianActionMessageGenerative -- layered composition
-  // -----------------------------------------------------------------------
-
-  describe("composeGuardianActionMessageGenerative", () => {
-    test("with no generator returns fallback", async () => {
-      const context: GuardianActionMessageContext = {
-        scenario: "caller_timeout_acknowledgment",
-        guardianIdentifier: "Jane",
-      };
-      const msg = await composeGuardianActionMessageGenerative(context);
-      expect(msg).toBe(getGuardianActionFallbackMessage(context));
-    });
-
-    test("with generator that returns text uses the generated text", async () => {
-      const generatedText = "Custom generated message about the timeout.";
-      const generator: GuardianActionCopyGenerator = async () => generatedText;
-      const context: GuardianActionMessageContext = {
-        scenario: "caller_timeout_acknowledgment",
-      };
-      // In test env, generator is skipped and fallback is returned
-      const msg = await composeGuardianActionMessageGenerative(
-        context,
-        {},
-        generator,
-      );
-      expect(msg).toBe(getGuardianActionFallbackMessage(context));
-    });
-
-    test("with generator that throws returns fallback", async () => {
-      const generator: GuardianActionCopyGenerator = async () => {
-        throw new Error("Provider unavailable");
-      };
-      const context: GuardianActionMessageContext = {
-        scenario: "guardian_followup_failed",
-        failureReason: "Network error",
-      };
-      const msg = await composeGuardianActionMessageGenerative(
-        context,
-        {},
-        generator,
-      );
-      expect(msg).toBe(getGuardianActionFallbackMessage(context));
-    });
-
-    test("with generator that returns null returns fallback", async () => {
-      const generator: GuardianActionCopyGenerator = async () => null;
-      const context: GuardianActionMessageContext = {
-        scenario: "guardian_stale_expired",
-      };
-      const msg = await composeGuardianActionMessageGenerative(
-        context,
-        {},
-        generator,
-      );
-      expect(msg).toBe(getGuardianActionFallbackMessage(context));
-    });
-
-    test("uses custom fallbackText from options when provided", async () => {
-      const context: GuardianActionMessageContext = {
-        scenario: "caller_timeout_continue",
-      };
-      const customFallback = "Custom fallback text for this scenario.";
-      const msg = await composeGuardianActionMessageGenerative(context, {
-        fallbackText: customFallback,
-      });
-      expect(msg).toBe(customFallback);
-    });
-
-    test("skips generation in test environment", async () => {
-      let generatorCalled = false;
-      const generator: GuardianActionCopyGenerator = async () => {
-        generatorCalled = true;
-        return "This should not be returned in test env";
-      };
-      const context: GuardianActionMessageContext = {
-        scenario: "guardian_followup_declined_ack",
-      };
-      const msg = await composeGuardianActionMessageGenerative(
-        context,
-        {},
-        generator,
-      );
-      expect(generatorCalled).toBe(false);
-      expect(msg).toBe(getGuardianActionFallbackMessage(context));
-    });
-  });
-});