@vellumai/assistant 0.5.0 → 0.5.2

package/src/__tests__/config-schema-cmd.test.ts

@@ -117,32 +117,60 @@ describe("getSchemaAtPath", () => {
       "memory.segmentation",
     );
     expect(result).not.toBeNull();
-    // Unwrap to check it has targetTokens and overlapTokens
-    let schema: any = result;
-    while (schema && !schema.shape) {
-      const inner = schema._zod?.def?.innerType;
-      if (!inner) break;
-      schema = inner;
-    }
-    expect(schema.shape).toBeDefined();
-    expect(schema.shape.targetTokens).toBeDefined();
-    expect(schema.shape.overlapTokens).toBeDefined();
+    // Verify we can produce JSON Schema with the expected properties
+    const jsonSchema = z.toJSONSchema(result!, {
+      unrepresentable: "any",
+      io: "input",
+    }) as Record<string, unknown>;
+    const properties = jsonSchema.properties as Record<string, unknown>;
+    expect(properties).toBeDefined();
+    expect(properties.targetTokens).toBeDefined();
+    expect(properties.overlapTokens).toBeDefined();
   });
 
   test("navigates through .default() wrappers (calls → object schema)", () => {
     const result = getSchemaAtPath(AssistantConfigSchema, "calls");
     expect(result).not.toBeNull();
-    // Unwrap to check it has shape (it's a ZodDefault wrapping ZodObject)
-    let schema: any = result;
-    while (schema && !schema.shape) {
-      const inner = schema._zod?.def?.innerType;
-      if (!inner) break;
-      schema = inner;
-    }
-    expect(schema.shape).toBeDefined();
-    expect(schema.shape.enabled).toBeDefined();
-    expect(schema.shape.voice).toBeDefined();
-    expect(schema.shape.safety).toBeDefined();
+    // Verify we can produce JSON Schema with the expected properties
+    const jsonSchema = z.toJSONSchema(result!, {
+      unrepresentable: "any",
+      io: "input",
+    }) as Record<string, unknown>;
+    const properties = jsonSchema.properties as Record<string, unknown>;
+    expect(properties).toBeDefined();
+    expect(properties.enabled).toBeDefined();
+    expect(properties.voice).toBeDefined();
+    expect(properties.safety).toBeDefined();
+  });
+
+  test("navigates through .transform() wrappers (ingress → object schema)", () => {
+    const result = getSchemaAtPath(AssistantConfigSchema, "ingress");
+    expect(result).not.toBeNull();
+    // ingress uses .transform() which creates a pipe — getSchemaAtPath
+    // must unwrap through the pipe to reach the input object shape
+    const jsonSchema = z.toJSONSchema(result!, {
+      unrepresentable: "any",
+      io: "input",
+    }) as Record<string, unknown>;
+    const properties = jsonSchema.properties as Record<string, unknown>;
+    expect(properties).toBeDefined();
+    expect(properties.enabled).toBeDefined();
+    expect(properties.webhook).toBeDefined();
+    expect(properties.rateLimit).toBeDefined();
+  });
+
+  test("navigates nested path through .transform() wrapper (ingress.webhook)", () => {
+    const result = getSchemaAtPath(AssistantConfigSchema, "ingress.webhook");
+    expect(result).not.toBeNull();
+    const jsonSchema = z.toJSONSchema(result!, {
+      unrepresentable: "any",
+      io: "input",
+    }) as Record<string, unknown>;
+    const properties = jsonSchema.properties as Record<string, unknown>;
+    expect(properties).toBeDefined();
+    expect(properties.secret).toBeDefined();
+    expect(properties.timeoutMs).toBeDefined();
+    expect(properties.maxRetries).toBeDefined();
   });
 
   test("returns null for non-existent top-level path", () => {
@@ -170,6 +198,7 @@ describe("z.toJSONSchema integration", () => {
   test("full schema produces valid JSON Schema with type object and properties", () => {
     const jsonSchema = z.toJSONSchema(AssistantConfigSchema, {
       unrepresentable: "any",
+      io: "input",
     }) as Record<string, unknown>;
     expect(jsonSchema.type).toBe("object");
     const properties = jsonSchema.properties as Record<string, unknown>;
@@ -184,11 +213,27 @@ describe("z.toJSONSchema integration", () => {
     expect(properties.sandbox).toBeDefined();
   });
 
+  test("full schema emits real properties for transformed fields (ingress)", () => {
+    const jsonSchema = z.toJSONSchema(AssistantConfigSchema, {
+      unrepresentable: "any",
+      io: "input",
+    }) as Record<string, unknown>;
+    const properties = jsonSchema.properties as Record<string, unknown>;
+    const ingress = properties.ingress as Record<string, unknown>;
+    // Without io: "input", transforms produce empty {} — verify we get real content
+    expect(ingress.properties).toBeDefined();
+    const ingressProps = ingress.properties as Record<string, unknown>;
+    expect(ingressProps.enabled).toBeDefined();
+    expect(ingressProps.webhook).toBeDefined();
+    expect(ingressProps.rateLimit).toBeDefined();
+  });
+
   test("sub-schema at calls produces JSON Schema with expected properties", () => {
     const callsSchema = getSchemaAtPath(AssistantConfigSchema, "calls");
     expect(callsSchema).not.toBeNull();
     const jsonSchema = z.toJSONSchema(callsSchema!, {
       unrepresentable: "any",
+      io: "input",
     }) as Record<string, unknown>;
     const properties = jsonSchema.properties as
       | Record<string, unknown>
@@ -204,6 +249,7 @@ describe("z.toJSONSchema integration", () => {
     expect(maxTokensSchema).not.toBeNull();
     const jsonSchema = z.toJSONSchema(maxTokensSchema!, {
       unrepresentable: "any",
+      io: "input",
     }) as Record<string, unknown>;
     expect(jsonSchema.type).toBe("integer");
   });
@@ -216,6 +262,7 @@ describe("z.toJSONSchema integration", () => {
     expect(segSchema).not.toBeNull();
     const jsonSchema = z.toJSONSchema(segSchema!, {
       unrepresentable: "any",
+      io: "input",
     }) as Record<string, unknown>;
     expect(jsonSchema.type).toBe("object");
     const properties = jsonSchema.properties as

package/src/__tests__/config-schema.test.ts

@@ -186,7 +186,7 @@ describe("AssistantConfigSchema", () => {
       enabled: true,
       enqueueIntervalMs: 6 * 60 * 60 * 1000,
       supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
-      conversationRetentionDays: 90,
+      conversationRetentionDays: 0,
     });
   });
 

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -62,12 +62,13 @@ mock.module("../config/loader.js", () => ({
 // ── Overflow recovery mocks ──────────────────────────────────────────
 
 // Token estimator — controllable per-test via mockEstimateTokens.
-// Can be a number (constant) or a function for dynamic behavior.
-let mockEstimateTokens: number | (() => number) = 1000;
+// Can be a number (constant), a no-arg function, or a function that
+// receives the messages array for dynamic behavior based on content.
+let mockEstimateTokens: number | ((msgs?: Message[]) => number) = 1000;
 mock.module("../context/token-estimator.js", () => ({
-  estimatePromptTokens: () =>
+  estimatePromptTokens: (msgs: Message[]) =>
     typeof mockEstimateTokens === "function"
-      ? mockEstimateTokens()
+      ? mockEstimateTokens(msgs)
       : mockEstimateTokens,
 }));
 
@@ -208,8 +209,9 @@ mock.module("../daemon/conversation-memory.js", () => ({
   }),
 }));
 
+let mockApplyRuntimeInjections: (msgs: Message[]) => Message[] = (msgs) => msgs;
 mock.module("../daemon/conversation-runtime-assembly.js", () => ({
-  applyRuntimeInjections: (msgs: Message[]) => msgs,
+  applyRuntimeInjections: (msgs: Message[]) => mockApplyRuntimeInjections(msgs),
   stripInjectedContext: (msgs: Message[]) => msgs,
 }));
 
@@ -327,6 +329,7 @@ mock.module("../agent/message-types.js", () => ({
 
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
 }));
 
 // ── Imports (after mocks) ────────────────────────────────────────────
@@ -520,6 +523,7 @@ beforeEach(() => {
   mockReducerStepFn = null;
   mockOverflowAction = "fail_gracefully";
   mockApprovalResult = { approved: false };
+  mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.mockClear();
 });
 
@@ -1929,4 +1933,144 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // Agent loop: 1 initial + 3 mid-loop re-entries + 2 convergence re-runs = 6 calls
     expect(agentLoopCallCount).toBe(6);
   });
+
+  // ── Test 8 ────────────────────────────────────────────────────────
+  // BUG: The preflight overflow reducer's budget check uses
+  // step.estimatedTokens (computed on bare ctx.messages) without
+  // accounting for tokens added by applyRuntimeInjections(). This
+  // causes the reducer to stop early when the bare estimate is under
+  // budget, even though post-injection tokens exceed it — leading to
+  // a wasted provider round-trip that gets rejected.
+  //
+  // After fix: the budget check re-estimates on runMessages (with
+  // injections) so the reducer continues to the next tier.
+  test("preflight reducer continues when post-injection tokens exceed budget", async () => {
+    const events: ServerMessage[] = [];
+
+    // Injections add an extra message, bumping the token count.
+    const injectionMessage: Message = {
+      role: "user" as const,
+      content: [
+        {
+          type: "text" as const,
+          text: "injected context " + "x".repeat(500),
+        },
+      ],
+    };
+    mockApplyRuntimeInjections = (msgs) => [...msgs, injectionMessage];
+
+    // Budget = 200_000 * 0.95 = 190_000
+    // The estimator returns different values based on whether the
+    // injection message is present:
+    //   - bare history (no injection msg) → 195_000 (triggers preflight)
+    //   - after tier 1 bare → 185_000 (under budget, would stop early without fix)
+    //   - after tier 1 with injection → 195_000 (still over budget)
+    //   - after tier 2 bare → 170_000
+    //   - after tier 2 with injection → 175_000 (under budget, reducer stops)
+    let reducerCallCount = 0;
+    mockEstimateTokens = (msgs?: Message[]) => {
+      const hasInjection = msgs?.some(
+        (m) =>
+          m.role === "user" &&
+          Array.isArray(m.content) &&
+          m.content.some(
+            (b: { type: string; text?: string }) =>
+              b.type === "text" &&
+              typeof b.text === "string" &&
+              b.text.startsWith("injected context"),
+          ),
+      );
+      if (reducerCallCount === 0) {
+        // Before any reduction: preflight check on runMessages (with injection)
+        return 195_000;
+      }
+      if (reducerCallCount === 1) {
+        // After tier 1
+        return hasInjection ? 195_000 : 185_000;
+      }
+      // After tier 2
+      return hasInjection ? 175_000 : 170_000;
+    };
+
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCallCount++;
+      const tier =
+        reducerCallCount === 1 ? "forced_compaction" : "tool_result_truncation";
+      return {
+        messages: msgs,
+        tier,
+        state: {
+          appliedTiers:
+            reducerCallCount === 1
+              ? ["forced_compaction"]
+              : ["forced_compaction", "tool_result_truncation"],
+          injectionMode: "full" as const,
+          exhausted: reducerCallCount >= 2,
+        },
+        // Bare-history estimate (what the reducer sees on ctx.messages)
+        estimatedTokens: reducerCallCount === 1 ? 185_000 : 170_000,
+        compactionResult: {
+          compacted: true,
+          messages: msgs,
+          compactedPersistedMessages: 5,
+          summaryText: "Summary",
+          previousEstimatedInputTokens: 195_000,
+          estimatedInputTokens: reducerCallCount === 1 ? 185_000 : 170_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 10,
+          summaryCalls: 1,
+          summaryInputTokens: 500,
+          summaryOutputTokens: 200,
+          summaryModel: "mock-model",
+        },
+      };
+    };
+
+    const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+      onEvent({
+        type: "message_complete",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "done" }],
+        },
+      });
+      onEvent({
+        type: "usage",
+        inputTokens: 170_000,
+        outputTokens: 200,
+        model: "test-model",
+        providerDurationMs: 500,
+      });
+      return [
+        ...messages,
+        {
+          role: "assistant" as const,
+          content: [{ type: "text", text: "done" }] as ContentBlock[],
+        },
+      ];
+    };
+
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({ compacted: false }),
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    });
+
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+    // The reducer must be called twice — the first tier's bare estimate
+    // (185k) is under budget (190k), but post-injection tokens (195k)
+    // still exceed it. Without the fix, the reducer would stop after
+    // tier 1 and the provider call would likely fail.
+    expect(reducerCallCount).toBe(2);
+
+    // Should succeed without errors
+    const conversationError = events.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationError).toBeUndefined();
+  });
 });

package/src/__tests__/conversation-agent-loop.test.ts

@@ -143,6 +143,14 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
 }));
 
+const syncMessageToDiskMock = mock(() => {});
+const rebuildConversationDiskViewFromDbStateMock = mock(() => {});
+mock.module("../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: syncMessageToDiskMock,
+  rebuildConversationDiskViewFromDbState:
+    rebuildConversationDiskViewFromDbStateMock,
+}));
+
 mock.module("../memory/retriever.js", () => ({
   buildMemoryRecall: async () => ({
     enabled: false,
@@ -213,11 +221,13 @@ mock.module("../daemon/history-repair.js", () => ({
   deepRepairHistory: (msgs: Message[]) => ({ messages: msgs, stats: {} }),
 }));
 
+const consolidateAssistantMessagesMock = mock(() => false);
 mock.module("../daemon/conversation-history.js", () => ({
-  consolidateAssistantMessages: () => {},
+  consolidateAssistantMessages: consolidateAssistantMessagesMock,
 }));
 
 const recordUsageMock = mock(() => {});
+const recordRequestLogMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -306,7 +316,8 @@ mock.module("../agent/message-types.js", () => ({
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
-  recordRequestLog: () => {},
+  recordRequestLog: recordRequestLogMock,
+  backfillMessageIdOnLogs: () => {},
 }));
 
 // ── Imports (after mocks) ────────────────────────────────────────────
@@ -447,6 +458,11 @@ beforeEach(() => {
   mockOverflowAction = "fail_gracefully";
   mockApprovalResult = { approved: false };
   recordUsageMock.mockClear();
+  recordRequestLogMock.mockClear();
+  syncMessageToDiskMock.mockClear();
+  rebuildConversationDiskViewFromDbStateMock.mockClear();
+  consolidateAssistantMessagesMock.mockReset();
+  consolidateAssistantMessagesMock.mockImplementation(() => false);
 });
 
 describe("session-agent-loop", () => {
@@ -590,6 +606,235 @@ describe("session-agent-loop", () => {
     });
   });
 
+  describe("LLM request log persistence", () => {
+    test("record request log prefers the actual provider from failover", async () => {
+      const events: ServerMessage[] = [];
+      const rawRequest = {
+        model: "gpt-4.1",
+        messages: [{ role: "user", content: "Hello" }],
+      };
+      const rawResponse = {
+        model: "gpt-4.1-2026-03-01",
+        choices: [
+          {
+            finish_reason: "stop",
+            message: {
+              role: "assistant",
+              content: "Hi there.",
+            },
+          },
+        ],
+        usage: {
+          prompt_tokens: 12,
+          completion_tokens: 3,
+        },
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Hi there." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 12,
+          outputTokens: 3,
+          model: "gpt-4.1-2026-03-01",
+          actualProvider: "fireworks",
+          providerDurationMs: 45,
+          rawRequest,
+          rawResponse,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "Hi there." }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        provider: {
+          name: "openrouter",
+          sendMessage: async () => ({
+            content: [{ type: "text", text: "title" }],
+            model: "mock",
+            usage: { inputTokens: 0, outputTokens: 0 },
+            stopReason: "end_turn",
+          }),
+        } as unknown as AgentLoopConversationContext["provider"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        undefined,
+        string,
+      ];
+      expect(call).toEqual([
+        "test-conv",
+        JSON.stringify(rawRequest),
+        JSON.stringify(rawResponse),
+        undefined,
+        "fireworks",
+      ]);
+    });
+
+    test("record request log falls back to the runtime provider when no actual provider is supplied", async () => {
+      const rawRequest = {
+        model: "gpt-4.1",
+        messages: [{ role: "user", content: "Hello" }],
+      };
+      const rawResponse = {
+        model: "gpt-4.1-2026-03-01",
+        choices: [
+          {
+            finish_reason: "stop",
+            message: {
+              role: "assistant",
+              content: "Hi there.",
+            },
+          },
+        ],
+      };
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Hi there." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 12,
+          outputTokens: 3,
+          model: "gpt-4.1-2026-03-01",
+          providerDurationMs: 45,
+          rawRequest,
+          rawResponse,
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "Hi there." }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        provider: {
+          name: "openrouter",
+          sendMessage: async () => ({
+            content: [{ type: "text", text: "title" }],
+            model: "mock",
+            usage: { inputTokens: 0, outputTokens: 0 },
+            stopReason: "end_turn",
+          }),
+        } as unknown as AgentLoopConversationContext["provider"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        undefined,
+        string,
+      ];
+      expect(call[4]).toBe("openrouter");
+    });
+  });
+
+  describe("usage accounting", () => {
+    test("records the actual provider for failover-served usage", async () => {
+      const events: ServerMessage[] = [];
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        onEvent({
+          type: "message_complete",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "Hi there." }],
+          },
+        });
+        onEvent({
+          type: "usage",
+          inputTokens: 12,
+          outputTokens: 3,
+          model: "gpt-4.1-2026-03-01",
+          actualProvider: "fireworks",
+          providerDurationMs: 45,
+          rawRequest: {
+            model: "gpt-4.1",
+            messages: [{ role: "user", content: "Hello" }],
+          },
+          rawResponse: {
+            model: "gpt-4.1-2026-03-01",
+            choices: [
+              {
+                finish_reason: "stop",
+                message: {
+                  role: "assistant",
+                  content: "Hi there.",
+                },
+              },
+            ],
+          },
+        });
+        return [
+          ...messages,
+          {
+            role: "assistant" as const,
+            content: [{ type: "text", text: "Hi there." }] as ContentBlock[],
+          },
+        ];
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        provider: {
+          name: "openrouter",
+          sendMessage: async () => ({
+            content: [{ type: "text", text: "title" }],
+            model: "mock",
+            usage: { inputTokens: 0, outputTokens: 0 },
+            stopReason: "end_turn",
+          }),
+        } as unknown as AgentLoopConversationContext["provider"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      const mainAgentCall = recordUsageMock.mock.calls.find(
+        (call) => (call as unknown[])[5] === "main_agent",
+      ) as unknown[] | undefined;
+
+      expect(mainAgentCall).toBeDefined();
+      expect(mainAgentCall?.[0]).toMatchObject({
+        conversationId: "test-conv",
+        providerName: "fireworks",
+      });
+      expect(mainAgentCall?.[1]).toBe(12);
+      expect(mainAgentCall?.[2]).toBe(3);
+      expect(mainAgentCall?.[3]).toBe("gpt-4.1-2026-03-01");
+    });
+  });
+
   describe("context window exhaustion (context-too-large recovery)", () => {
     test("forwards cache-aware compaction usage to recordUsage", async () => {
       const events: ServerMessage[] = [];
@@ -1688,6 +1933,49 @@ describe("session-agent-loop", () => {
 
       expect(drainReason).toBe("loop_complete");
     });
+
+    test("rebuilds disk view after consolidation mutates persisted history", async () => {
+      consolidateAssistantMessagesMock.mockReturnValue(true);
+
+      const ctx = makeCtx({
+        agentLoopRun: async (
+          messages: Message[],
+          onEvent: (event: AgentEvent) => void,
+        ) => {
+          onEvent({
+            type: "message_complete",
+            message: {
+              role: "assistant",
+              content: [{ type: "text", text: "done" }],
+            },
+          });
+          onEvent({
+            type: "usage",
+            inputTokens: 10,
+            outputTokens: 5,
+            model: "test",
+            providerDurationMs: 50,
+          });
+          return [
+            ...messages,
+            {
+              role: "assistant" as const,
+              content: [{ type: "text", text: "done" }] as ContentBlock[],
+            },
+          ];
+        },
+      });
+
+      await runAgentLoopImpl(ctx, "hi", "msg-consolidate", () => {});
+
+      expect(consolidateAssistantMessagesMock).toHaveBeenCalledWith(
+        "test-conv",
+        "msg-consolidate",
+      );
+      expect(rebuildConversationDiskViewFromDbStateMock).toHaveBeenCalledWith(
+        "test-conv",
+      );
+    });
   });
 
   describe("stale pending surface cleanup", () => {