@vellumai/assistant 0.4.44 → 0.4.45

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -86,7 +86,7 @@ mock.module("../memory/conversation-crud.js", () => ({
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalIpcTrustContext: () => ({
+  resolveLocalTrustContext: () => ({
     trustClass: "guardian",
     sourceChannel: "vellum",
   }),
@@ -157,6 +157,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => false,
       denyAllPendingConfirmations: () => {},
@@ -167,6 +169,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -228,6 +232,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => false,
       denyAllPendingConfirmations: () => {},
@@ -238,6 +244,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -294,6 +302,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => true,
       denyAllPendingConfirmations: () => {},
@@ -305,6 +315,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: (requestId: string) =>
         requestId === "tool-approval-live",
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -366,6 +378,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => true,
       denyAllPendingConfirmations: () => {},
@@ -376,6 +390,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "tool-req-code-1",
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -433,6 +449,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => true,
       denyAllPendingConfirmations: () => {},
@@ -443,6 +461,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-reject-1",
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {
@@ -494,6 +514,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
       setTurnInterfaceContext: () => {},
+      ensureActorScopedHistory: async () => {},
+      usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
       isProcessing: () => false,
       hasAnyPendingConfirmation: () => true,
       denyAllPendingConfirmations: () => {},
@@ -504,6 +526,8 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-1",
+      setHostBashProxy: () => {},
+      setHostFileProxy: () => {},
     } as unknown as import("../daemon/session.js").Session;
 
     const req = new Request("http://localhost/v1/messages", {

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -0,0 +1,381 @@
+/**
+ * Tests for slash command interception in the POST /v1/messages handler.
+ *
+ * Validates that:
+ * - Built-in slash commands (/status, /model, /commands) are intercepted and
+ *   do NOT trigger the agent loop.
+ * - Skill slash commands are rewritten and forwarded to the agent loop with
+ *   preactivated skill IDs.
+ * - Regular messages pass through to the agent loop unchanged.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+import type { SlashResolution } from "../daemon/session-slash.js";
+
+const resolveSlashMock = mock(
+  (_content: string, _context?: unknown): SlashResolution => ({
+    kind: "passthrough",
+    content: _content,
+  }),
+);
+
+mock.module("../daemon/session-slash.js", () => ({
+  resolveSlash: resolveSlashMock,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "claude-opus-4-6",
+    provider: "anthropic",
+    apiKeys: { anthropic: "test-key" },
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    secretDetection: { enabled: false },
+    contextWindow: { maxInputTokens: 200000 },
+  }),
+}));
+
+const addMessageMock = mock(
+  async (
+    _conversationId: string,
+    role: string,
+    _content?: string,
+    _metadata?: Record<string, unknown>,
+  ) => ({
+    id: role === "user" ? "persisted-user-id" : "persisted-assistant-id",
+  }),
+);
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../memory/conversation-key-store.js", () => ({
+  getOrCreateConversation: () => ({ conversationId: "conv-slash-test" }),
+  getConversationByKey: () => null,
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: () => [],
+}));
+
+mock.module("../runtime/guardian-reply-router.js", () => ({
+  routeGuardianReply: async () => ({
+    consumed: false,
+    decisionApplied: false,
+    type: "not_consumed",
+  }),
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  createCanonicalGuardianRequest: () => ({
+    id: "canonical-id",
+    requestCode: "ABC123",
+  }),
+  generateCanonicalRequestCode: () => "ABC123",
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: async () => undefined,
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata?: Record<string, unknown>,
+  ) => addMessageMock(conversationId, role, content, metadata),
+  getMessages: () => [],
+  provenanceFromTrustContext: (ctx: unknown) =>
+    ctx
+      ? { provenanceTrustClass: (ctx as Record<string, unknown>).trustClass }
+      : { provenanceTrustClass: "unknown" },
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../daemon/session-process.js", () => ({
+  buildModelInfoEvent: () => ({
+    type: "model_info",
+    model: "claude-opus-4-6",
+    provider: "anthropic",
+    configuredProviders: ["anthropic", "ollama"],
+  }),
+  isModelSlashCommand: (content: string) => {
+    const trimmed = content.trim();
+    return (
+      trimmed === "/model" ||
+      trimmed === "/models" ||
+      trimmed.startsWith("/model ")
+    );
+  },
+}));
+
+mock.module("../runtime/local-actor-identity.js", () => ({
+  resolveLocalTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+}));
+
+mock.module("../runtime/trust-context-resolver.js", () => ({
+  resolveTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+  withSourceChannel: (sourceChannel: unknown, ctx: unknown) => ({
+    ...(ctx as Record<string, unknown>),
+    sourceChannel,
+  }),
+}));
+
+import type { AuthContext } from "../runtime/auth/types.js";
+import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+
+const testAuthContext: AuthContext = {
+  subject: "actor:self:test-guardian",
+  principalType: "actor",
+  assistantId: "self",
+  actorPrincipalId: "test-guardian",
+  scopeProfile: "actor_client_v1",
+  scopes: new Set([
+    "chat.read",
+    "chat.write",
+    "approval.read",
+    "approval.write",
+    "settings.read",
+    "settings.write",
+    "attachments.read",
+    "attachments.write",
+    "calls.read",
+    "calls.write",
+    "feature_flags.read",
+    "feature_flags.write",
+  ]),
+  policyEpoch: 1,
+};
+
+function makeSession() {
+  const persistUserMessage = mock(
+    async (_content: string, _attachments: unknown[], _requestId?: string) =>
+      "persisted-user-id",
+  );
+  const runAgentLoop = mock(
+    async (
+      _content: string,
+      _messageId: string,
+      _onEvent: unknown,
+      _options?: unknown,
+    ) => undefined,
+  );
+  const setPreactivatedSkillIds = mock((_ids: string[] | undefined) => {});
+  const events: unknown[] = [];
+  const messages: unknown[] = [];
+  const session = {
+    setTrustContext: () => {},
+    updateClient: (_fn: unknown, _b: boolean) => {},
+    emitConfirmationStateChanged: () => {},
+    emitActivityState: () => {},
+    setTurnChannelContext: () => {},
+    setTurnInterfaceContext: () => {},
+    ensureActorScopedHistory: async () => {},
+    isProcessing: () => false,
+    hasAnyPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
+    persistUserMessage,
+    runAgentLoop,
+    setPreactivatedSkillIds,
+    drainQueue: async () => {},
+    getMessages: () => messages,
+    assistantId: "self",
+    trustContext: undefined,
+    hasPendingConfirmation: () => false,
+    setHostBashProxy: () => {},
+    setHostFileProxy: () => {},
+    usageStats: {
+      inputTokens: 1000,
+      outputTokens: 500,
+      estimatedCost: 0.05,
+    },
+  } as unknown as import("../daemon/session.js").Session;
+  return {
+    session,
+    persistUserMessage,
+    runAgentLoop,
+    setPreactivatedSkillIds,
+    events,
+    messages,
+  };
+}
+
+function makeRequest(content: string) {
+  return new Request("http://localhost/v1/messages", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      conversationKey: "slash-test-key",
+      content,
+      sourceChannel: "vellum",
+      interface: "macos",
+    }),
+  });
+}
+
+function makeDeps(session: import("../daemon/session.js").Session) {
+  return {
+    sendMessageDeps: {
+      getOrCreateSession: async () => session,
+      assistantEventHub: { publish: async () => {} } as any,
+      resolveAttachments: () => [],
+    },
+  };
+}
+
+describe("handleSendMessage slash command interception", () => {
+  beforeEach(() => {
+    resolveSlashMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("intercepts built-in slash commands (unknown kind) without calling agent loop", async () => {
+    resolveSlashMock.mockReturnValue({
+      kind: "unknown",
+      message: "Session Status\n\nContext: 5%",
+    });
+
+    const { session, persistUserMessage, runAgentLoop } = makeSession();
+    const res = await handleSendMessage(
+      makeRequest("/status"),
+      makeDeps(session),
+      testAuthContext,
+    );
+
+    expect(res.status).toBe(202);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      messageId?: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBe("persisted-user-id");
+
+    // Slash command was resolved
+    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
+    expect(resolveSlashMock.mock.calls[0][0]).toBe("/status");
+
+    // User + assistant messages persisted, but agent loop NOT called
+    expect(addMessageMock).toHaveBeenCalledTimes(2);
+    const roles = addMessageMock.mock.calls.map((c) => c[1]);
+    expect(roles).toEqual(["user", "assistant"]);
+    expect(persistUserMessage).not.toHaveBeenCalled();
+    expect(runAgentLoop).not.toHaveBeenCalled();
+  });
+
+  test("rewrites skill slash commands and calls agent loop with rewritten content", async () => {
+    resolveSlashMock.mockReturnValue({
+      kind: "rewritten",
+      content: "[SKILL INVOCATION] Run the weather skill",
+      skillId: "weather",
+    });
+
+    const {
+      session,
+      persistUserMessage,
+      runAgentLoop,
+      setPreactivatedSkillIds,
+    } = makeSession();
+    const res = await handleSendMessage(
+      makeRequest("/weather San Diego"),
+      makeDeps(session),
+      testAuthContext,
+    );
+
+    expect(res.status).toBe(202);
+
+    // Slash command was resolved
+    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
+
+    // Skill IDs preactivated
+    expect(setPreactivatedSkillIds).toHaveBeenCalledWith(["weather"]);
+
+    // Agent loop called with rewritten content
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+    const loopContent = runAgentLoop.mock.calls[0][0];
+    expect(loopContent).toBe("[SKILL INVOCATION] Run the weather skill");
+
+    // addMessage NOT called (agent loop handles persistence)
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+
+  test("passes regular messages through to agent loop unchanged", async () => {
+    resolveSlashMock.mockReturnValue({
+      kind: "passthrough",
+      content: "hello there",
+    });
+
+    const {
+      session,
+      persistUserMessage,
+      runAgentLoop,
+      setPreactivatedSkillIds,
+    } = makeSession();
+    const res = await handleSendMessage(
+      makeRequest("hello there"),
+      makeDeps(session),
+      testAuthContext,
+    );
+
+    expect(res.status).toBe(202);
+
+    // Slash command was resolved but passed through
+    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
+
+    // No skill preactivation
+    expect(setPreactivatedSkillIds).not.toHaveBeenCalled();
+
+    // Agent loop called with original content
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+    const loopContent = runAgentLoop.mock.calls[0][0];
+    expect(loopContent).toBe("hello there");
+  });
+
+  test("passes SlashContext with session usage stats", async () => {
+    resolveSlashMock.mockReturnValue({
+      kind: "passthrough",
+      content: "test",
+    });
+
+    const { session } = makeSession();
+    await handleSendMessage(
+      makeRequest("test"),
+      makeDeps(session),
+      testAuthContext,
+    );
+
+    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
+    const context = resolveSlashMock.mock.calls[0][1] as Record<
+      string,
+      unknown
+    >;
+    expect(context).toMatchObject({
+      inputTokens: 1000,
+      outputTokens: 500,
+      estimatedCost: 0.05,
+      model: "claude-opus-4-6",
+      provider: "anthropic",
+      maxInputTokens: 200000,
+    });
+  });
+});

package/src/__tests__/conversation-store.test.ts

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/conversation-unread-route.test.ts

@@ -13,7 +13,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -85,7 +84,7 @@ describe("POST /v1/conversations/unread", () => {
   test("registers the unread route with chat.write policy", () => {
     expect(getPolicy("conversations/unread")).toEqual({
       requiredScopes: ["chat.write"],
-      allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "ipc"],
+      allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "local"],
     });
   });
 

package/src/__tests__/credential-security-invariants.test.ts

@@ -231,7 +231,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/ride-shotgun-handler.ts", // learn session cookie persistence
       "daemon/session-messaging.ts", // credential storage during session messaging
       "runtime/routes/settings-routes.ts", // settings routes OAuth credential lookup (client_id/client_secret/access tokens)
-      "twitter/platform-proxy-client.ts", // managed Twitter proxy auth token lookup
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));
@@ -316,13 +315,13 @@ describe("Invariant 3: secrets never logged in plaintext", () => {
         );
       });
     } else if (tc.component === "ipc_decode") {
-      // PR 24 — IPC decode log hygiene: the TS daemon's IPC parser must
+      // PR 24 — message decode log hygiene: the TS daemon's message parser must
       // not log raw message content that could contain secrets.
       // Logging metadata (line length, error type) is acceptable; logging
       // the raw line, trimmed content, or error.message is not.
       test(`${tc.label}`, () => {
         const thisDir = dirname(fileURLToPath(import.meta.url));
-        const ipcSrc = readFileSync(
+        const protocolSrc = readFileSync(
           resolve(thisDir, "../daemon/message-protocol.ts"),
           "utf-8",
         );
@@ -333,11 +332,11 @@ describe("Invariant 3: secrets never logged in plaintext", () => {
         // helper calls like formatErr(err)) don't terminate the match
         // early — avoiding false negatives — while still scoping each
         // pattern to a single line (no cross-statement matching).
-        expect(ipcSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*trimmed[^.]/);
-        expect(ipcSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*line[^L]/);
-        expect(ipcSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*data\b/);
-        expect(ipcSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*buffer\b/);
-        expect(ipcSrc).not.toMatch(/\blog\.\w+\([^\n]*err\.message\b/);
+        expect(protocolSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*trimmed[^.]/);
+        expect(protocolSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*line[^L]/);
+        expect(protocolSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*data\b/);
+        expect(protocolSrc).not.toMatch(/\blog\.\w+\([^\n]*[{,]\s*buffer\b/);
+        expect(protocolSrc).not.toMatch(/\blog\.\w+\([^\n]*err\.message\b/);
       });
     } else {
       // PR 25 — secret prompter log hygiene: verify the prompter source