@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Tests that `ToolExecutionResult.activityMetadata` plumbs through to the
+ * emitted `tool_result` server event via `handleToolResult`. The forward path
+ * is: ToolExecutionResult (set by the tool executor) → AgentEvent tool_result
+ * (emitted by the agent loop) → tool_result server message (emitted by
+ * handleToolResult to the SSE sink).
+ *
+ * Mirrors the mocked-dependency pattern used in tool-preview-lifecycle.test.ts
+ * and annotate-risk-options.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleToolResult,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+
+type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function createCollectorDeps(): {
+  deps: EventHandlerDeps;
+  events: ServerMessage[];
+} {
+  const events: ServerMessage[] = [];
+  const deps = {
+    ctx: {
+      conversationId: "conv-meta",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (msg: ServerMessage) => events.push(msg),
+    reqId: "req-meta",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+  return { deps, events };
+}
+
+function primeState(state: EventHandlerState, toolUseId: string): void {
+  state.toolUseIdToName.set(toolUseId, "web_search");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: Date.now() });
+  state.currentTurnToolUseIds.push(toolUseId);
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("tool_result activityMetadata plumbing", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    state = createEventHandlerState();
+  });
+
+  test("forwards activityMetadata to the emitted tool_result event", () => {
+    const { deps, events } = createCollectorDeps();
+    const toolUseId = "toolu_meta_present";
+    primeState(state, toolUseId);
+
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "x",
+        provider: "tavily",
+        resultCount: 0,
+        durationMs: 1,
+        results: [],
+      },
+    };
+
+    handleToolResult(state, deps, {
+      type: "tool_result",
+      toolUseId,
+      content: "",
+      isError: false,
+      activityMetadata,
+    });
+
+    const toolResultEvent = events.find(
+      (e): e is ToolResultEvent => e.type === "tool_result",
+    );
+    expect(toolResultEvent).toBeDefined();
+    expect(toolResultEvent?.activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("omits activityMetadata when the executor did not populate it", () => {
+    const { deps, events } = createCollectorDeps();
+    const toolUseId = "toolu_meta_absent";
+    primeState(state, toolUseId);
+
+    handleToolResult(state, deps, {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+    });
+
+    const toolResultEvent = events.find(
+      (e): e is ToolResultEvent => e.type === "tool_result",
+    );
+    expect(toolResultEvent).toBeDefined();
+    expect(toolResultEvent?.activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/twilio-routes.test.ts

@@ -311,7 +311,7 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 }));
 
 mock.module("../providers/registry.js", () => ({
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 import {

package/src/__tests__/web-fetch.test.ts

@@ -1622,8 +1622,8 @@ describe("web_fetch tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("Extracted text content is very short");
-    expect(result.content).toContain("JavaScript rendering");
+    expect(result.content).toContain("Extracted only");
+    expect(result.content).toContain("JavaScript-rendered");
   });
 
   test("does not suggest browser skill when HTML page has substantial content", async () => {

package/src/__tests__/workspace-git-service.test.ts

@@ -5,6 +5,7 @@ import {
   mkdirSync,
   readFileSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -87,6 +88,58 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("installs branch guard hook that blocks non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+
+      const hookPath = join(testDir, ".githooks", "reference-transaction");
+      expect(existsSync(hookPath)).toBe(true);
+      expect(statSync(hookPath).mode & 0o111).not.toBe(0);
+
+      const hookContent = readFileSync(hookPath, "utf-8");
+      expect(hookContent).toContain(
+        "assistant workspace git branches are disabled",
+      );
+
+      expect(() =>
+        execFileSync("git", ["branch", "apollo/test-branch"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
+    test("branch guard allows deleting old non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      execFileSync(
+        "git",
+        ["-c", "core.hooksPath=/dev/null", "branch", "old-branch"],
+        {
+          cwd: testDir,
+        },
+      );
+
+      execFileSync("git", ["branch", "-D", "old-branch"], { cwd: testDir });
+
+      const branches = execFileSync(
+        "git",
+        ["branch", "--format=%(refname:short)"],
+        {
+          cwd: testDir,
+          encoding: "utf-8",
+        },
+      );
+      expect(branches).not.toContain("old-branch");
+    });
+
     test("multiple ensureInitialized calls are idempotent", async () => {
       const service = new WorkspaceGitService(testDir);
 
@@ -487,7 +540,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo on a feature branch
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -527,7 +580,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo then detach HEAD
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -571,7 +624,7 @@ describe("WorkspaceGitService", () => {
       // This exercises the --discard-changes fallback in ensureOnMainLocked().
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "original content");
@@ -619,7 +672,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo without our gitignore rules
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, ".gitignore"), "node_modules/\n");
@@ -648,7 +701,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo with the OLD broad data/ rule
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       const oldGitignore =
@@ -711,6 +764,36 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("existing repo gets branch guard installed on init", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      writeFileSync(join(testDir, "file.txt"), "content");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+      expect(
+        existsSync(join(testDir, ".githooks", "reference-transaction")),
+      ).toBe(true);
+
+      expect(() =>
+        execFileSync("git", ["branch", "feature-after-init"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
     test("existing repo with correct config is idempotent", async () => {
       // Set up a repo that already has everything configured correctly
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });

package/src/__tests__/workspace-migration-088-deprecate-background-conversation-override.test.ts

@@ -0,0 +1,158 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { deprecateBackgroundConversationOverrideMigration } from "../workspace/migrations/088-deprecate-background-conversation-override.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-088-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function promptSystemDir(): string {
+  return join(workspaceDir, "prompts", "system");
+}
+
+function writeOverride(body: string): string {
+  const dir = promptSystemDir();
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, "08-background-conversation.md");
+  writeFileSync(filePath, body, "utf-8");
+  return filePath;
+}
+
+describe("088-deprecate-background-conversation-override migration", () => {
+  test("has expected id and description", () => {
+    expect(deprecateBackgroundConversationOverrideMigration.id).toBe(
+      "088-deprecate-background-conversation-override",
+    );
+    expect(
+      deprecateBackgroundConversationOverrideMigration.description,
+    ).toContain("08-background-conversation");
+  });
+
+  test("renames the override to .deprecated, preserving body", () => {
+    const body = "## Custom\n\nUser-customized background note.\n";
+    writeOverride(body);
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    const originalPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+
+    expect(existsSync(originalPath)).toBe(false);
+    expect(existsSync(deprecatedPath)).toBe(true);
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe(body);
+  });
+
+  test("no-ops when the override is absent", () => {
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(existsSync(deprecatedPath)).toBe(false);
+  });
+
+  test("does not touch unrelated section overrides", () => {
+    const dir = promptSystemDir();
+    mkdirSync(dir, { recursive: true });
+    const otherPath = join(dir, "07-external-content.md");
+    writeFileSync(otherPath, "## External Content\n\nUntouched.\n", "utf-8");
+    writeOverride("body");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    expect(readFileSync(otherPath, "utf-8")).toContain("Untouched");
+  });
+
+  test("is safe to re-run after the rename has happened", () => {
+    writeOverride("body");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe("body");
+  });
+
+  test("drops the .md and keeps the .deprecated copy when both exist", () => {
+    // A user re-created the override after a prior partial run. The bundled
+    // section is gone, so the .md would render unconditionally — drop it.
+    const dir = promptSystemDir();
+    mkdirSync(dir, { recursive: true });
+    const deprecatedPath = join(
+      dir,
+      "08-background-conversation.md.deprecated",
+    );
+    writeFileSync(deprecatedPath, "preserved.\n", "utf-8");
+    const recreatedPath = writeOverride("re-created body\n");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    expect(existsSync(recreatedPath)).toBe(false);
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe("preserved.\n");
+  });
+
+  test("down() restores the override when only .deprecated exists", () => {
+    writeOverride("body");
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    deprecateBackgroundConversationOverrideMigration.down(workspaceDir);
+
+    const overridePath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(existsSync(overridePath)).toBe(true);
+    expect(existsSync(deprecatedPath)).toBe(false);
+    expect(readFileSync(overridePath, "utf-8")).toBe("body");
+  });
+
+  test("down() is a no-op when only the .md exists", () => {
+    writeOverride("body");
+
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.down(workspaceDir),
+    ).not.toThrow();
+
+    const overridePath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    expect(readFileSync(overridePath, "utf-8")).toBe("body");
+  });
+});

package/src/agent/attachments.ts

@@ -38,6 +38,7 @@ export function attachmentsToContentBlocks(
         filename: attachment.filename,
       },
       extracted_text: attachment.extractedText,
+      ...(attachment.id ? { _attachmentId: attachment.id } : {}),
     } as ContentBlock;
   });
 }

package/src/agent/loop.ts

@@ -7,6 +7,7 @@ import {
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
 import { calculateMaxToolResultChars } from "../context/tool-result-truncation.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import { defaultEmptyResponseTerminal } from "../plugins/defaults/empty-response.js";
 import { defaultToolErrorTerminal } from "../plugins/defaults/tool-error.js";
 import { defaultToolResultTruncateTerminal } from "../plugins/defaults/tool-result-truncate.js";
@@ -68,21 +69,22 @@ export interface CheckpointInfo {
 export type CheckpointDecision = "continue" | "yield";
 
 /**
- * Why an {@link AgentLoop.run} invocation exited its `while (true)` body.
+ * Why an agent turn reached a terminal state.
  *
- * Emitted exactly once per run as part of an {@link AgentEvent} of type
- * `agent_loop_exit`, then persisted onto the **final** `llm_request_logs`
- * row of the run. Rows from intermediate turns keep a NULL
- * `agent_loop_exit_reason`, which is how downstream tooling (and the LLM
- * Context Inspector) distinguishes "loop kept going" from "loop is done".
+ * Emitted as part of an {@link AgentEvent} of type `agent_loop_exit`, then
+ * persisted onto the **final** `llm_request_logs` row of the turn. Rows from
+ * intermediate turns keep a NULL `agent_loop_exit_reason`, which is how
+ * downstream tooling (and the LLM Context Inspector) distinguishes "loop kept
+ * going" from "loop is done".
  *
  * Values are stable wire/DB strings — they are written to SQLite and
  * surfaced over the inspector wire format, so renaming any of them is a
  * breaking change.
  *
- * Cardinality matches the nine `break;`/`throw` sites currently inside the
- * loop body. Keep in sync with `emitExit` call sites in
- * {@link AgentLoop.run}.
+ * Keep in sync with `emitExit` call sites in {@link AgentLoop.run} and the
+ * outer conversation orchestrator paths that terminate after a checkpoint
+ * yield. A checkpoint yield used for budget compaction is intentionally not
+ * a terminal reason — it is a control transfer before re-entering the loop.
  */
 export type AgentLoopExitReason =
   /** `if (signal?.aborted) break;` at the top of the loop. */
@@ -97,8 +99,12 @@ export type AgentLoopExitReason =
   | "aborted_during_tools"
   /** A tool result requested handing back to the user. */
   | "yield_to_user"
-  /** The orchestrator's `onCheckpoint` callback returned `"yield"`. */
-  | "checkpoint_yield"
+  /** The orchestrator yielded at checkpoint to process a queued message. */
+  | "checkpoint_handoff"
+  /** Context-window recovery exhausted and the turn ended with an error. */
+  | "context_too_large"
+  /** User cancellation landed after a non-terminal checkpoint yield. */
+  | "aborted_after_checkpoint"
   /** Signal aborted while the catch handler was synthesizing an error turn. */
   | "aborted_via_error"
   /** Catch-block fallback: an unhandled error broke the loop. */
@@ -142,6 +148,7 @@ export type AgentEvent =
       approvalMode?: string;
       approvalReason?: string;
       riskThreshold?: string;
+      activityMetadata?: ToolActivityMetadata;
     }
   | { type: "tool_use_preview_start"; toolUseId: string; toolName: string }
   | {
@@ -161,6 +168,17 @@ export type AgentEvent =
       toolUseId: string;
       isError: boolean;
       content?: unknown[];
+      /**
+       * Finalized input for the server tool (e.g. the actual web-search
+       * query). Carried through so the daemon can populate accurate activity
+       * metadata; Anthropic streams server-tool input via deltas that aren't
+       * resolved at `server_tool_start` time.
+       */
+      resolvedInput?: Record<string, unknown>;
+      /** Provider-specific error code (e.g. `max_uses_exceeded`). */
+      errorCode?: string;
+      /** Optional human-readable error message from the provider. */
+      errorMessage?: string;
     }
   | { type: "error"; error: Error }
   | {
@@ -210,10 +228,11 @@ export type AgentEvent =
     }
   | {
       /**
-       * Emitted exactly once at the end of {@link AgentLoop.run}, after the
-       * loop body has exited (whether via `break;`, an unhandled error in
-       * the catch block, or the empty-response throw path). Consumers
-       * persist `reason` onto the final `llm_request_logs` row for the run;
+       * Emitted when an agent turn reaches a terminal state. Checkpoint
+       * yields used for orchestration (handoff or budget compaction) are not
+       * emitted by {@link AgentLoop.run}; the outer orchestrator emits a
+       * terminal reason only if that control transfer truly ends the turn.
+       * Consumers persist `reason` onto the final `llm_request_logs` row;
        * intermediate rows keep `agent_loop_exit_reason = NULL`, which is the
        * canonical "loop kept going" signal.
        */
@@ -371,6 +390,7 @@ export type LoopToolExecutor = (
   approvalMode?: string;
   approvalReason?: string;
   riskThreshold?: string;
+  activityMetadata?: ToolActivityMetadata;
 }>;
 
 export class AgentLoop {
@@ -458,6 +478,8 @@ export class AgentLoop {
      */
     overrideProfile?: string,
     effectiveMaxInputTokens?: number,
+    resolveOverrideProfile?: () => string | undefined,
+    resolveEffectiveMaxInputTokens?: () => number | undefined,
   ): Promise<Message[]> {
     const history = [...messages];
     const initialHistoryLength = messages.length;
@@ -580,9 +602,14 @@ export class AgentLoop {
         // `activeProfile` and any call-site named profile. Threading it on
         // every send (rather than once at construction) keeps subagents that
         // share an `AgentLoop` instance but ought to inherit a different
-        // profile correct — and matches how `callSite` is plumbed.
-        if (overrideProfile) {
-          providerConfig.overrideProfile = overrideProfile;
+        // profile correct — and matches how `callSite` is plumbed. The
+        // optional resolver lets a turn observe an explicitly confirmed
+        // profile-session switch before the next model call.
+        const effectiveOverrideProfile = resolveOverrideProfile
+          ? resolveOverrideProfile()
+          : overrideProfile;
+        if (effectiveOverrideProfile) {
+          providerConfig.overrideProfile = effectiveOverrideProfile;
         }
 
         // Rate-limit consecutive LLM calls to prevent spin when tools return instantly
@@ -690,6 +717,13 @@ export class AgentLoop {
                   toolUseId: event.toolUseId,
                   isError: event.isError,
                   ...(event.content ? { content: event.content } : {}),
+                  ...(event.resolvedInput
+                    ? { resolvedInput: event.resolvedInput }
+                    : {}),
+                  ...(event.errorCode ? { errorCode: event.errorCode } : {}),
+                  ...(event.errorMessage
+                    ? { errorMessage: event.errorMessage }
+                    : {}),
                 });
               }
             },
@@ -1079,7 +1113,10 @@ export class AgentLoop {
         // truncation strategy (e.g. a summariser) while the default
         // middleware preserves the historical tail-drop behaviour.
         const contextWindowTokens =
-          effectiveMaxInputTokens ?? this.config.maxInputTokens ?? 180_000;
+          resolveEffectiveMaxInputTokens?.() ??
+          effectiveMaxInputTokens ??
+          this.config.maxInputTokens ??
+          180_000;
         const maxChars = calculateMaxToolResultChars(contextWindowTokens);
         const truncateMiddlewares = getMiddlewaresFor("toolResultTruncate");
 
@@ -1155,6 +1192,7 @@ export class AgentLoop {
             approvalMode: result.approvalMode,
             approvalReason: result.approvalReason,
             riskThreshold: result.riskThreshold,
+            activityMetadata: result.activityMetadata,
           });
         }
 
@@ -1236,7 +1274,6 @@ export class AgentLoop {
             history,
           });
           if (decision === "yield") {
-            await emitExit("checkpoint_yield");
             break;
           }
         }