@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/__tests__/workspace-tool-loader.test.ts

@@ -26,7 +26,7 @@
  *   and skipped (no silent provider-safe rewrite — operator must rename).
  * - Multiple workspace tools register in a single batch.
  */
-import { mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
@@ -42,10 +42,7 @@ import {
   registerTool,
 } from "../tools/registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
-import {
-  __resetWorkspaceToolCacheForTesting,
-  loadWorkspaceTools,
-} from "../tools/workspace-tools/loader.js";
+import { loadWorkspaceTools } from "../tools/workspace-tools/loader.js";
 
 // Per-test counter so each writeTool() call lands in a unique tempdir,
 // defeating bun's per-URL ESM cache between tests. Without this, a
@@ -90,23 +87,6 @@ function writeRemovedSentinel(name: string): void {
   writeFileSync(join(toolsDir, `${name}.removed`), "");
 }
 
-/** Delete `<workspaceDir>/tools/<name><ext>` (defaults to `.ts`). */
-function removeToolFile(name: string, ext = ".ts"): void {
-  rmSync(join(currentWorkspaceDir, "tools", `${name}${ext}`), { force: true });
-}
-
-/**
- * Overwrite an existing tool file and bump its mtime into the future so the
- * reconcile's mtime gate re-imports it even when the rewrite lands within
- * the same millisecond as the original write.
- */
-function rewriteTool(name: string, body: string, ext = ".ts"): void {
-  const path = join(currentWorkspaceDir, "tools", `${name}${ext}`);
-  writeFileSync(path, body);
-  const future = new Date(Date.now() + 5000);
-  utimesSync(path, future, future);
-}
-
 function makeFakeCoreTool(name: string): Tool {
   return {
     name,
@@ -114,9 +94,6 @@ function makeFakeCoreTool(name: string): Tool {
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
     executionTarget: "sandbox",
-    // Match the finalized shape the registry stores (defaults filled), so
-    // `getCoreToolOverride(name)` toEqual comparisons hold after registration.
-    exclusive: false,
     input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,
@@ -156,7 +133,6 @@ export default {
 describe("workspace tool loader", () => {
   beforeEach(() => {
     __clearRegistryForTesting();
-    __resetWorkspaceToolCacheForTesting();
     freshWorkspace();
   });
 
@@ -340,173 +316,4 @@ export default 42;
     const names = getWorkspaceToolNames().sort();
     expect(names).toEqual(["alpha", "beta", "gamma"]);
   });
-
-  // ── Reconcile-on-read behavior ─────────────────────────────────────────
-  //
-  // loadWorkspaceTools() is idempotent and re-derives registry state from
-  // disk on every call. These cases cover the deltas a repeat call applies,
-  // which is what replaces the old filesystem watcher.
-
-  test("repeat call with no disk changes is a no-op (does not throw or duplicate)", async () => {
-    writeTool("stable_tool", WELL_FORMED_BODY);
-
-    await loadWorkspaceTools();
-    // A second reconcile must not throw on the already-registered name —
-    // the mtime cache recognizes the unchanged file and skips re-import.
-    await loadWorkspaceTools();
-
-    expect(getTool("stable_tool")).toBeDefined();
-    expect(getWorkspaceToolNames()).toEqual(["stable_tool"]);
-  });
-
-  test("a file added after the first reconcile registers on the next", async () => {
-    writeTool("first", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-    expect(getWorkspaceToolNames()).toEqual(["first"]);
-
-    writeTool("second", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-
-    expect(getWorkspaceToolNames().sort()).toEqual(["first", "second"]);
-  });
-
-  test("a changed file is re-imported on the next reconcile", async () => {
-    writeTool("mutable", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-    expect(getTool("mutable")?.description).toBe("from workspace");
-
-    rewriteTool(
-      "mutable",
-      `
-export default {
-  description: "edited in place",
-  defaultRiskLevel: "low",
-  input_schema: { type: "object", properties: {}, required: [] },
-  async execute() {
-    return { content: "edited", isError: false };
-  },
-};
-`,
-    );
-    await loadWorkspaceTools();
-
-    expect(getTool("mutable")?.description).toBe("edited in place");
-  });
-
-  test("a deleted net-new tool file is unregistered on the next reconcile", async () => {
-    writeTool("ephemeral", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-    expect(getTool("ephemeral")).toBeDefined();
-
-    removeToolFile("ephemeral");
-    await loadWorkspaceTools();
-
-    expect(getTool("ephemeral")).toBeUndefined();
-    expect(getWorkspaceToolNames()).toEqual([]);
-  });
-
-  test("deleting an override file restores the stashed core tool", async () => {
-    const core = makeFakeCoreTool("restore_me");
-    registerTool(core);
-    writeTool("restore_me", WELL_FORMED_BODY);
-
-    await loadWorkspaceTools();
-    expect(getToolOwner("restore_me")?.kind).toBe("workspace");
-
-    removeToolFile("restore_me");
-    await loadWorkspaceTools();
-
-    expect(getToolOwner("restore_me")).toBeUndefined();
-    expect(getTool("restore_me")).toEqual(core);
-    expect(getCoreToolOverride("restore_me")).toBeUndefined();
-  });
-
-  test("deleting a .removed sentinel restores the stripped core tool", async () => {
-    const core = makeFakeCoreTool("strip_then_restore");
-    registerTool(core);
-    writeRemovedSentinel("strip_then_restore");
-
-    await loadWorkspaceTools();
-    expect(getTool("strip_then_restore")).toBeUndefined();
-    expect(getStrippedCoreToolNames()).toContain("strip_then_restore");
-
-    removeToolFile("strip_then_restore", ".removed");
-    await loadWorkspaceTools();
-
-    expect(getTool("strip_then_restore")).toEqual(core);
-    expect(getStrippedCoreToolNames()).not.toContain("strip_then_restore");
-  });
-
-  test("the registered name is the filename stem, ignoring the file's own name field", async () => {
-    // The default export sets a different `name` — the loader must pin the
-    // registered name to the stem ("stem_wins") so the mtime cache and the
-    // unregister-on-delete path stay keyed by the same name.
-    writeTool(
-      "stem_wins",
-      `
-export default {
-  name: "different_name",
-  description: "name field should be ignored",
-  defaultRiskLevel: "low",
-  input_schema: { type: "object", properties: {}, required: [] },
-  async execute() {
-    return { content: "ok", isError: false };
-  },
-};
-`,
-    );
-
-    await loadWorkspaceTools();
-
-    expect(getTool("stem_wins")).toBeDefined();
-    expect(getTool("different_name")).toBeUndefined();
-    expect(getWorkspaceToolNames()).toEqual(["stem_wins"]);
-
-    // Deleting the file unregisters by stem — no leaked "different_name".
-    removeToolFile("stem_wins");
-    await loadWorkspaceTools();
-    expect(getTool("stem_wins")).toBeUndefined();
-    expect(getTool("different_name")).toBeUndefined();
-  });
-
-  test("per-tool isolation on reconcile: a bad file does not drop a valid edited tool", async () => {
-    writeTool("good_edit", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-    expect(getTool("good_edit")?.description).toBe("from workspace");
-
-    // Add a file that throws at import, and edit the good tool, in the same
-    // reconcile. The broken file must not prevent the edited tool from
-    // re-registering.
-    writeTool("broken_now", `throw new Error("boom at import");`);
-    rewriteTool(
-      "good_edit",
-      `
-export default {
-  description: "edited and still here",
-  defaultRiskLevel: "low",
-  input_schema: { type: "object", properties: {}, required: [] },
-  async execute() {
-    return { content: "ok", isError: false };
-  },
-};
-`,
-    );
-    await loadWorkspaceTools();
-
-    expect(getTool("broken_now")).toBeUndefined();
-    expect(getTool("good_edit")?.description).toBe("edited and still here");
-  });
-
-  test("an edit that breaks an existing tool keeps the prior registration", async () => {
-    writeTool("was_good", WELL_FORMED_BODY);
-    await loadWorkspaceTools();
-    expect(getTool("was_good")?.description).toBe("from workspace");
-
-    // Rewrite the file into something that throws at import. The prior,
-    // working registration must stay in place rather than being torn down.
-    rewriteTool("was_good", `throw new Error("now broken");`);
-    await loadWorkspaceTools();
-
-    expect(getTool("was_good")?.description).toBe("from workspace");
-  });
 });

package/src/__tests__/workspace-tools-watcher-flag.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Tests that the `workspace-tools-watcher` feature flag gates the dynamic
+ * hot-reload watcher in `WorkspaceToolsWatcher.start()`.
+ *
+ * The initial disk scan (`loadWorkspaceTools()`) is unconditional and lives
+ * elsewhere; this suite only covers whether the live `fs.watch` loop mounts.
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
+import { WorkspaceToolsWatcher } from "../daemon/workspace-tools-watcher.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+const FLAG = "workspace-tools-watcher";
+const TEST_BASE_DIR = join(
+  tmpdir(),
+  `vellum-workspace-tools-watcher-flag-test-${process.pid}-${Date.now()}`,
+);
+let caseCounter = 0;
+
+function freshWorkspaceWithToolsDir(): void {
+  caseCounter += 1;
+  const dir = join(TEST_BASE_DIR, `case-${caseCounter}`);
+  mkdirSync(join(dir, "tools"), { recursive: true });
+  process.env.VELLUM_WORKSPACE_DIR = dir;
+}
+
+beforeEach(() => {
+  WorkspaceToolsWatcher.resetForTests();
+  clearFeatureFlagOverridesCache();
+  freshWorkspaceWithToolsDir();
+});
+
+afterEach(() => {
+  WorkspaceToolsWatcher.resetForTests();
+  clearFeatureFlagOverridesCache();
+  delete process.env.VELLUM_WORKSPACE_DIR;
+  rmSync(TEST_BASE_DIR, { recursive: true, force: true });
+});
+
+describe("WorkspaceToolsWatcher feature-flag gate", () => {
+  test("does not mount the watch loop when the flag is off", () => {
+    // GIVEN the workspace tools directory exists
+    // AND the watcher flag is disabled
+    setOverridesForTesting({ [FLAG]: false });
+
+    // WHEN the watcher starts
+    const watcher = WorkspaceToolsWatcher.getInstance();
+    watcher.start();
+
+    // THEN no fs.watch loop is mounted
+    expect(watcher.isWatchingForTests()).toBe(false);
+  });
+
+  test("mounts the watch loop when the flag is on", () => {
+    // GIVEN the workspace tools directory exists
+    // AND the watcher flag is enabled
+    setOverridesForTesting({ [FLAG]: true });
+
+    // WHEN the watcher starts
+    const watcher = WorkspaceToolsWatcher.getInstance();
+    watcher.start();
+
+    // THEN a live fs.watch loop is mounted
+    expect(watcher.isWatchingForTests()).toBe(true);
+  });
+});

package/src/agent/loop.ts

@@ -625,20 +625,6 @@ export type LoopToolExecutor = (
   activityMetadata?: ToolActivityMetadata;
 }>;
 
-/**
- * The benign result returned for a sibling tool call that was deferred because
- * an exclusive tool ran in the same turn. Phrased so the model treats it as a
- * "not run yet" signal — read the exclusive tool's output, then re-issue this
- * call if it is still the right next step.
- */
-function deferredForExclusiveMessage(exclusiveToolName: string): string {
-  return (
-    `(not run: \`${exclusiveToolName}\` was called this turn and runs first, on its own, ` +
-    `so the rest of your tool calls were held back. Read its output, then call this tool ` +
-    `again if it is still the right next step.)`
-  );
-}
-
 export interface AgentLoopConstructorOptions {
   /** LLM provider the loop issues every call through. */
   provider: Provider;
@@ -648,14 +634,6 @@ export interface AgentLoopConstructorOptions {
   tools?: ToolDefinition[];
   toolExecutor?: LoopToolExecutor;
   resolveTools?: (history: Message[]) => ToolDefinition[];
-  /**
-   * Decide whether a tool runs exclusively in its turn (see
-   * {@link ToolDefinition.exclusive}). When it returns true for a tool present
-   * in a multi-call turn, the loop runs only that tool and defers the siblings
-   * un-run. Injected by the conversation wiring, which can read the tool
-   * registry; lightweight loops that omit it never defer.
-   */
-  isExclusiveTool?: (toolName: string) => boolean;
   /**
    * Conversation this loop drives. Scopes the loop-held compaction circuit
    * breaker and is the source of truth the loop's pipeline contexts and
@@ -681,7 +659,6 @@ export class AgentLoop {
   private tools: ToolDefinition[];
   private resolveTools: ((history: Message[]) => ToolDefinition[]) | null;
   private toolExecutor: LoopToolExecutor | null;
-  private isExclusiveTool: ((toolName: string) => boolean) | null;
 
   /**
    * Conversation this loop drives. Source of truth for the `conversationId`
@@ -711,7 +688,6 @@ export class AgentLoop {
       tools,
       toolExecutor,
       resolveTools,
-      isExclusiveTool,
       conversationId,
       resolveConversationDir,
     } = options;
@@ -721,7 +697,6 @@ export class AgentLoop {
     this.tools = tools ?? [];
     this.resolveTools = resolveTools ?? null;
     this.toolExecutor = toolExecutor ?? null;
-    this.isExclusiveTool = isExclusiveTool ?? null;
     this.conversationId = conversationId;
     this.resolveConversationDir = resolveConversationDir ?? null;
     this.compactionCircuit = new CompactionCircuit(this.conversationId);
@@ -1908,39 +1883,8 @@ export class AgentLoop {
           "Tool execution start",
         );
 
-        // When an exclusive tool (e.g. the advisor) is among this turn's calls,
-        // it must run alone: the model should incorporate its output before
-        // acting on anything else. Run only the first exclusive call and defer
-        // the siblings with a benign, un-run result so the model re-issues them
-        // next turn if still needed. Every tool_use still gets a matching
-        // tool_result, so history stays well-formed.
-        const exclusiveBlock = this.isExclusiveTool
-          ? toolUseBlocks.find((block) => this.isExclusiveTool!(block.name))
-          : undefined;
-        const deferSiblings =
-          exclusiveBlock !== undefined && toolUseBlocks.length > 1;
-        if (deferSiblings) {
-          rlog.info(
-            {
-              turn: toolUseTurns,
-              exclusiveTool: exclusiveBlock!.name,
-              deferred: toolUseBlocks
-                .filter((block) => block !== exclusiveBlock)
-                .map((block) => block.name),
-            },
-            "Exclusive tool present — running it alone and deferring sibling tool calls this turn",
-          );
-        }
-
         const toolExecutionPromise = Promise.all(
           toolUseBlocks.map(async (toolUse) => {
-            if (deferSiblings && toolUse !== exclusiveBlock) {
-              const result: Awaited<ReturnType<LoopToolExecutor>> = {
-                content: deferredForExclusiveMessage(exclusiveBlock!.name),
-                isError: false,
-              };
-              return { toolUse, result };
-            }
             const result = await this.toolExecutor!(
               toolUse.name,
               toolUse.input,

package/src/api/index.ts

@@ -11,7 +11,6 @@ import { ConfirmationRequestEventSchema } from "./events/confirmation-request.js
 import { ContactRequestEventSchema } from "./events/contact-request.js";
 import { ConversationErrorEventSchema } from "./events/conversation-error.js";
 import { ConversationListInvalidatedEventSchema } from "./events/conversation-list-invalidated.js";
-import { ConversationNoticeEventSchema } from "./events/conversation-notice.js";
 import { ConversationTitleUpdatedEventSchema } from "./events/conversation-title-updated.js";
 import { DiskPressureStatusChangedEventSchema } from "./events/disk-pressure-status-changed.js";
 import { DocumentCommentCreatedEventSchema } from "./events/document-comment-created.js";
@@ -62,10 +61,6 @@ export {
   CALL_SITE_COMPACTION_AGENT,
   CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE,
 } from "./constants/call-sites.js";
-export {
-  SSE_REPLAY_RING_AGE_LIMIT_MS,
-  SSE_REPLAY_RING_COUNT_LIMIT,
-} from "./constants/sse-replay.js";
 export { DEFAULT_TOOL_EXECUTION_TIMEOUT_SEC } from "./constants/tool-execution.js";
 export {
   type AssistantActivityAnchor,
@@ -139,11 +134,6 @@ export {
   type ConversationListInvalidatedReason,
   ConversationListInvalidatedReasonSchema,
 } from "./events/conversation-list-invalidated.js";
-export {
-  type ConversationNoticeEvent,
-  ConversationNoticeEventSchema,
-  ConversationNoticeSourceSchema,
-} from "./events/conversation-notice.js";
 export {
   type ConversationTitleUpdatedEvent,
   ConversationTitleUpdatedEventSchema,
@@ -440,8 +430,6 @@ export {
   LlmContextResponseSchema,
 } from "./responses/llm-context-response.js";
 export {
-  type LLMCallError,
-  LLMCallErrorSchema,
   type LLMCallSummary,
   LLMCallSummarySchema,
   type LLMContextSection,
@@ -483,12 +471,7 @@ export {
   type WorkflowLeaf,
   WorkflowLeafSchema,
 } from "./responses/workflow-journal.js";
-export {
-  type CardSurfaceData,
-  CardSurfaceDataSchema,
-  type FileUploadSurfaceData,
-  FileUploadSurfaceDataSchema,
-} from "./surfaces.js";
+export { type CardSurfaceData, CardSurfaceDataSchema } from "./surfaces.js";
 
 /**
  * Canonical SSE event schema for the assistant runtime.
@@ -515,7 +498,6 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   ContactRequestEventSchema,
   ConversationErrorEventSchema,
   ConversationListInvalidatedEventSchema,
-  ConversationNoticeEventSchema,
   ConversationTitleUpdatedEventSchema,
   DiskPressureStatusChangedEventSchema,
   DocumentCommentCreatedEventSchema,

package/src/api/responses/llm-request-log-entry.ts

@@ -67,34 +67,6 @@ export const LLMContextSectionSchema = z.object({
 
 export type LLMContextSection = z.infer<typeof LLMContextSectionSchema>;
 
-/**
- * Structured provider/transport error recorded when an LLM call was
- * rejected before producing a response. Mirrors the on-disk
- * `responsePayload.error` shape written by
- * `buildProviderErrorResponsePayload` — the inspector branches on the
- * presence of this field to render a failed call distinctly (failure
- * banner in the Response tab, $0.00 cost in the rail, etc.) instead of
- * the generic "section rendering unavailable" fallback.
- *
- * Every field is optional because the serializer degrades a plain
- * `Error` down to just `{ name, message }`; only the wrapper object is
- * guaranteed.
- */
-export const LLMCallErrorSchema = z.object({
-  name: z.string().nullish(),
-  message: z.string().nullish(),
-  code: z.string().nullish(),
-  provider: z.string().nullish(),
-  statusCode: z.number().nullish(),
-  retryAfterMs: z.number().nullish(),
-  apiErrorCode: z.string().nullish(),
-  apiErrorType: z.string().nullish(),
-  apiErrorParam: z.string().nullish(),
-  requestId: z.string().nullish(),
-});
-
-export type LLMCallError = z.infer<typeof LLMCallErrorSchema>;
-
 /**
  * One LLM request log row.
  *
@@ -116,7 +88,6 @@ export const LLMRequestLogEntrySchema = z.object({
   responseSections: z.array(LLMContextSectionSchema).nullish(),
   agentLoopExitReason: z.string().nullish(),
   callSite: z.string().nullish(),
-  error: LLMCallErrorSchema.nullish(),
 });
 
 export type LLMRequestLogEntry = z.infer<typeof LLMRequestLogEntrySchema>;

package/src/api/responses/subagent-detail.ts

@@ -31,23 +31,6 @@ export const SubagentDetailEventSchema = z.object({
   toolName: z.string().optional(),
   isError: z.boolean().optional(),
   messageId: z.string().optional(),
-  /**
-   * Tool-call id — the `tool_use.id` on a tool-call event and the referencing
-   * `tool_use_id` on its tool-result event, in the daemon's canonical
-   * content-block format. That format is provider-agnostic: every provider
-   * (Anthropic, OpenAI, Gemini, …) normalizes its native tool calls into these
-   * `tool_use`/`tool_result` blocks (see `providers/types.ts`), so this id is
-   * present regardless of which model produced the call. Lets the web client
-   * pair a result with its call and key the nested tool-detail view, so tool
-   * pills on reloaded/history subagents are clickable (not just live ones).
-   */
-  toolUseId: z.string().optional(),
-  /**
-   * Raw tool input object on tool-call events. (`content` also carries a
-   * JSON-stringified copy for back-compat / label derivation.) Surfaced in the
-   * tool-detail view's input section.
-   */
-  input: z.record(z.string(), z.unknown()).optional(),
 });
 
 export type SubagentDetailEvent = z.infer<typeof SubagentDetailEventSchema>;

package/src/api/surfaces.ts

@@ -11,9 +11,9 @@
  * normalizer *supports* — anything the model sends outside these fields is
  * dropped (and logged) there, which is how we learn the shapes to recover.
  *
- * Card and file_upload use canonical schemas; the remaining types are
- * hand-written interfaces in `daemon/message-types/surfaces.ts` pending
- * migration.
+ * Card is the first surface type migrated to a canonical schema; the remaining
+ * types still live as hand-written interfaces in
+ * `daemon/message-types/surfaces.ts` pending migration.
  */
 
 import { z } from "zod";
@@ -31,39 +31,3 @@ export const CardSurfaceDataSchema = z.object({
   templateData: z.record(z.string(), z.unknown()).optional(),
 });
 export type CardSurfaceData = z.infer<typeof CardSurfaceDataSchema>;
-
-/**
- * Accepted MIME-type / extension patterns for a `file_upload` surface.
- *
- * The renderer consumes this as a `string[]` — it calls `.join`/`.some`/
- * `.length` on the value — but the model may emit a single comma-joined string
- * ("image/*, application/pdf") or a bare string. Coercing every shape to a
- * clean `string[]` keeps that array invariant intact: a string is split on
- * commas; array entries are stringified and trimmed; blanks and any non-array
- * value collapse to `undefined` (no restriction).
- */
-const FileUploadAcceptedTypesSchema = z.preprocess((value) => {
-  const items =
-    typeof value === "string"
-      ? value.split(",")
-      : Array.isArray(value)
-        ? value
-        : [];
-  const cleaned = items
-    .map((item) =>
-      typeof item === "string" || typeof item === "number"
-        ? String(item).trim()
-        : "",
-    )
-    .filter((item) => item.length > 0);
-  return cleaned.length > 0 ? cleaned : undefined;
-}, z.array(z.string()).optional());
-
-export const FileUploadSurfaceDataSchema = z.object({
-  prompt: z.coerce.string().optional(),
-  acceptedTypes: FileUploadAcceptedTypesSchema,
-  /** A non-positive or non-numeric value is dropped rather than rejecting the surface. */
-  maxFiles: z.coerce.number().int().positive().optional().catch(undefined),
-  maxSizeBytes: z.coerce.number().positive().optional().catch(undefined),
-});
-export type FileUploadSurfaceData = z.infer<typeof FileUploadSurfaceDataSchema>;

package/src/approvals/guardian-request-resolvers.ts

@@ -36,7 +36,6 @@ import { deliverChannelReply } from "../runtime/gateway-client.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { TC_GRANT_WAIT_MAX_MS } from "../tools/tool-approval-handler.js";
 import { getLogger } from "../util/logger.js";
-import { resolveDeliverCallbackUrlForChannel } from "./guardian-channel-delivery.js";
 
 const log = getLogger("guardian-request-resolvers");
 
@@ -243,6 +242,17 @@ export type ResolverResult =
     }
   | { ok: false; reason: string };
 
+function resolveDeliverCallbackUrlForChannel(channel: string): string | null {
+  switch (channel) {
+    case "telegram":
+    case "whatsapp":
+    case "slack":
+      return `/deliver/${channel}`;
+    default:
+      return null;
+  }
+}
+
 /** Interface that kind-specific resolvers implement. */
 export interface GuardianRequestResolver {
   /** The request kind this resolver handles (matches canonical_guardian_requests.kind). */