@vellumai/assistant 0.8.4 → 0.8.6

package/src/acp/prepare-agent-env.ts

@@ -0,0 +1,78 @@
+/**
+ * Inject required env vars for an ACP agent and preflight that they're set.
+ *
+ * Called by every code path that hands an `AcpAgentConfig` to
+ * `AcpSessionManager.spawn`. There are TWO such paths today — the HTTP
+ * route `/v1/acp/spawn` (`runtime/routes/acp-routes.ts:spawnSession`) and
+ * the skill tool `acp_spawn` (`tools/acp/spawn.ts:executeAcpSpawn`) — and
+ * before this helper existed the env-injection logic lived inline in the
+ * route only. The skill-tool path bypassed it entirely, so spawns landed
+ * with no `CLAUDE_CODE_OAUTH_TOKEN`, the SDK rejected the first prompt
+ * with "Authentication required", and the subprocess died as a zombie
+ * with no completion notification.
+ *
+ * The fix: have this single helper own injection + preflight, and have
+ * every caller route through it before calling `manager.spawn`.
+ */
+
+import { basename } from "node:path";
+
+import { FailedDependencyError } from "../runtime/routes/errors.js";
+import { credentialKey } from "../security/credential-key.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
+import type { AcpAgentConfig } from "./types.js";
+
+/**
+ * Returns a NEW config with any required credentials merged into `env`.
+ * Does NOT mutate the input. Throws `FailedDependencyError` if a required
+ * credential is missing from both the user-supplied env override and the
+ * secure store.
+ *
+ * Gating is keyed off the resolved agent COMMAND (basename), not the
+ * user-facing agent id, so a custom `acp.agents.my-claude = { command:
+ * "claude-agent-acp", ... }` alias still gets the env it needs.
+ *
+ * For `claude-agent-acp` the only required env var is
+ * `CLAUDE_CODE_OAUTH_TOKEN`. Two provisioning routes converge on it, with
+ * config.json winning over the vault so explicit user overrides
+ * (per-workspace, rotated, etc.) are never silently clobbered:
+ *   1. `acp.agents.<id>.env.CLAUDE_CODE_OAUTH_TOKEN` in `config.json` —
+ *      the user-supplied env override on the resolved agent config.
+ *   2. Secure store via CLI: `assistant credentials set --service acp \
+ *        --field claude_oauth_token <token>` — written to the canonical
+ *      `credential/{service}/{field}` key built by `credentialKey()`,
+ *      used as fallback when (1) is unset.
+ * After resolution, this asserts the token is present (from either route)
+ * before spawning. The "fail-fast" throw is symmetric with the existing
+ * `binary_not_found` preflight in `resolveAcpAgent` and strictly better
+ * than a `warn` + zombie subprocess 10 seconds later.
+ */
+export async function prepareAgentEnv(
+  agentConfig: AcpAgentConfig,
+): Promise<AcpAgentConfig> {
+  // Clone caller's config + env so we never mutate the resolver's cached
+  // agent reference. The local `env` binding sidesteps TS narrowing
+  // limitations on the optional `AcpAgentConfig.env` field.
+  const env: Record<string, string> = { ...(agentConfig.env ?? {}) };
+  const commandBasename = basename(agentConfig.command);
+
+  if (commandBasename === "claude-agent-acp") {
+    if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
+      const claudeToken = await getSecureKeyAsync(
+        credentialKey("acp", "claude_oauth_token"),
+      );
+      if (claudeToken) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = claudeToken;
+      }
+    }
+    if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
+      throw new FailedDependencyError(
+        "claude-agent-acp requires CLAUDE_CODE_OAUTH_TOKEN. " +
+          "Run: assistant credentials set --service acp --field claude_oauth_token <token> " +
+          "(or set it under acp.agents.<id>.env in config.json).",
+      );
+    }
+  }
+
+  return { ...agentConfig, env };
+}

package/src/acp/session-manager.ts

@@ -306,7 +306,7 @@ export class AcpSessionManager {
    */
   private teardownSession(acpSessionId: string, entry: SessionEntry): void {
     for (const requestId of entry.clientHandler.pendingRequestIds) {
-      const interaction = pendingInteractions.resolve(requestId);
+      const interaction = pendingInteractions.resolve(requestId, "cancelled");
       if (interaction?.directResolve) {
         interaction.directResolve("deny");
       }
@@ -460,14 +460,13 @@ export class AcpSessionManager {
             current.parentConversationId,
           );
           if (parentConversation) {
-            const enqueueResult = parentConversation.enqueueMessage(
-              notifyMessage,
-              [],
-            );
+            const enqueueResult = parentConversation.enqueueMessage({
+              content: notifyMessage,
+            });
             if (!enqueueResult.queued && !enqueueResult.rejected) {
               parentConversation
-                .persistUserMessage(notifyMessage, [])
-                .then((messageId) =>
+                .persistUserMessage({ content: notifyMessage })
+                .then(({ id: messageId }) =>
                   parentConversation.runAgentLoop(notifyMessage, messageId),
                 )
                 .catch((err) => {

package/src/agent/loop.ts

@@ -103,6 +103,16 @@ export type AgentLoopExitReason =
   | "checkpoint_handoff"
   /** Context-window recovery exhausted and the turn ended with an error. */
   | "context_too_large"
+  /**
+   * Auto-compress rerun (post-emergency-compaction, post-tier reducer)
+   * still yielded at the mid-loop budget checkpoint — the turn silently
+   * terminated with no further recovery layer to re-enter. Pure
+   * observability signal so the silent stall is attributable instead of
+   * leaving `agent_loop_exit_reason` NULL.
+   */
+  | "budget_yield_unrecovered"
+  /** Provider stopped because the configured output-token limit was reached. */
+  | "max_tokens_reached"
   /** User cancellation landed after a non-terminal checkpoint yield. */
   | "aborted_after_checkpoint"
   /** Signal aborted while the catch handler was synthesizing an error turn. */
@@ -111,9 +121,19 @@ export type AgentLoopExitReason =
   | "error";
 
 export type AgentEvent =
+  /**
+   * Emitted once per LLM call inside the loop, immediately before the
+   * `provider.sendMessage` invocation. Carries the optional `callSite` tag so
+   * downstream handlers (the daemon's persistence pipeline) can decide
+   * whether to reserve a row for this call. One `llm_call_started` precedes
+   * every `message_complete` for the same call; multi-call agent turns emit
+   * one pair per call.
+   */
+  | { type: "llm_call_started"; callSite?: LLMCallSite }
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
   | { type: "message_complete"; message: Message }
+  | { type: "max_tokens_reached"; stopReason: string }
   | {
       type: "tool_use";
       id: string;
@@ -248,6 +268,18 @@ const DEFAULT_CONFIG: AgentLoopConfig = {
 
 const MAX_CONSECUTIVE_ERROR_NUDGES = 3;
 const MAX_EMPTY_RESPONSE_RETRIES = 1;
+const MAX_TOKENS_STOP_REASONS = new Set([
+  "length",
+  "max_output_tokens",
+  "max_tokens",
+]);
+
+export function isMaxTokensStopReason(
+  stopReason: string | null | undefined,
+): boolean {
+  if (!stopReason) return false;
+  return MAX_TOKENS_STOP_REASONS.has(stopReason.trim().toLowerCase());
+}
 
 /**
  * Build a minimal {@link TurnContext} for pipeline invocations inside the
@@ -595,6 +627,16 @@ export class AgentLoop {
         if (callSite) {
           providerConfig.callSite = callSite;
           providerConfig.usageTracking = "manual";
+          // Per-conversation seed for deterministic `mix`-profile expansion.
+          // Sourced from the orchestrator-supplied turn context's
+          // conversationId so every LLM call in a conversation resolves the
+          // same mix arm (stable across turns and retries, and across daemon
+          // restarts since the seed is the durable conversation id). Absent
+          // for standalone `AgentLoop` instances (unit tests / no turnContext)
+          // — those fall back to per-call random mix selection.
+          if (turnContext?.conversationId) {
+            providerConfig.selectionSeed = turnContext.conversationId;
+          }
         }
 
         // Per-call inference-profile override. The resolver layers
@@ -743,6 +785,18 @@ export class AgentLoop {
           toolUseTurns,
         );
 
+        // Announce the LLM-call boundary so downstream handlers (the
+        // daemon's persistence pipeline) can reserve an empty assistant row
+        // and stamp the resulting `messageId` onto every streaming event the
+        // call emits. Emit as late as possible — after history stripping,
+        // arg construction, and turn-context resolution — so the gap
+        // between "we said the call started" and the actual provider HTTP
+        // call is minimized. Awaited so the row is created and the
+        // `assistant_turn_start` wire event reaches the client BEFORE the
+        // provider starts streaming deltas — the deltas downstream will
+        // carry the freshly-reserved id.
+        await onEvent({ type: "llm_call_started", callSite });
+
         // Inner try/catch narrows error-recording scope to the provider
         // call itself. The outer agent-loop catch (below) wraps the entire
         // turn body (tool execution, plugin pipelines, checkpoints), so
@@ -854,6 +908,40 @@ export class AgentLoop {
           "LLM call complete",
         );
 
+        if (isMaxTokensStopReason(response.stopReason)) {
+          const safeContent = response.content.filter(
+            (block) =>
+              block.type !== "tool_use" &&
+              block.type !== "server_tool_use" &&
+              block.type !== "web_search_tool_result",
+          );
+          const safeAssistantMessage: Message = {
+            role: "assistant",
+            content: safeContent,
+          };
+          rlog.warn(
+            {
+              turn: toolUseTurns,
+              stopReason: response.stopReason,
+              contentBlocks: response.content.length,
+              safeContentBlocks: safeContent.length,
+              toolUseCount: toolUseBlocks.length,
+            },
+            "LLM response reached output token limit",
+          );
+          history.push(safeAssistantMessage);
+          await onEvent({
+            type: "max_tokens_reached",
+            stopReason: response.stopReason,
+          });
+          await onEvent({
+            type: "message_complete",
+            message: safeAssistantMessage,
+          });
+          await emitExit("max_tokens_reached");
+          break;
+        }
+
         // Detect empty responses: no user-visible text and no tool calls.
         // This can happen when the model fails to produce output after
         // receiving a large tool result. Retry once with a nudge before

package/src/api/README.md

@@ -0,0 +1,127 @@
+# @vellumai/assistant-api
+
+Public API surface for consumers of the assistant runtime — web client, gateway,
+evals, future external clients. This directory is the **source of truth** for
+the wire contracts the assistant exposes: schemas, types, and pure helpers.
+
+Internal assistant code imports the files in this directory via relative paths
+(e.g. `../../api/events/open-url.js`). External consumers import the
+materialized npm-style package `@vellumai/assistant-api`, regenerated into
+`apps/web/node_modules/` by `apps/web/scripts/postinstall.ts`.
+
+## Architecture
+
+A single discriminated-union schema, `AssistantEventSchema`, covers every event
+type whose wire contract is canonical. The web parser (`event-parser.ts`) tries
+this schema first; events not yet covered fall through to a hand-rolled legacy
+switch. The migration goal is to drain the switch — each event moved here
+shrinks the legacy surface and makes wire-shape drift a compile error.
+
+`AssistantEvent` (re-exported alongside the schema) is `z.infer<typeof
+AssistantEventSchema>`. Consumers reference this single type rather than
+re-listing the individual member types: as new events migrate in, they appear
+in `AssistantEvent` automatically.
+
+## Migration recipe
+
+Each batch follows the same shape. Group cohesive event families (lifecycle,
+streaming, document-comment, ui-surface, etc.) rather than migrating events
+one at a time — the per-batch overhead is the same regardless of count.
+
+### 1. Add the canonical schema
+
+One file per event under `./events/`. Each schema is `.strict()` so unknown
+fields surface as `UnknownEvent` rather than silently passing through.
+
+```ts
+// assistant/src/api/events/my-event.ts
+import { z } from "zod";
+
+export const MyEventSchema = z
+  .object({
+    type: z.literal("my_event"),
+    conversationId: z.string(),
+    // …
+  })
+  .strict();
+
+export type MyEvent = z.infer<typeof MyEventSchema>;
+```
+
+Add the type/schema re-export pair to `./index.ts`, alphabetically, and append
+the schema to the `AssistantEventSchema` discriminated union. No other changes
+to the canonical package are needed — `AssistantEvent` picks the new member
+up automatically.
+
+### 2. Adopt the canonical type in daemon code
+
+In `assistant/src/daemon/message-types/<domain>.ts`, delete the local
+`interface MyEvent { … }` declaration and import the canonical `MyEvent`
+type from `../../api/events/my-event.js`. The domain-level
+`_<Domain>ServerMessages` union alias (consumed by `message-protocol.ts`)
+keeps its existing shape — it just references the canonical types now.
+
+### 3. Cut over web consumers
+
+`apps/web/src/domains/chat/api/event-types.ts` no longer needs to list the
+migrated event in its `AssistantEvent` union — `APIAssistantEvent` covers it.
+Drop the per-event member, leaving the union to peel off legacy entries one
+at a time as each event migrates.
+
+Local handler modules (e.g. `document-comment-events.ts`) keep their handler
+functions but import the wire types directly from `@vellumai/assistant-api`.
+Do **not** re-export the canonical types from intermediate modules — consumers
+import them straight from the canonical package.
+
+### 4. Delete the legacy parser cases
+
+Remove the matching `case "my_event":` blocks from
+`apps/web/src/domains/chat/api/event-parser.ts`. Any per-event helper
+(`parseFooBase`, etc.) goes with them.
+
+### 5. Tests
+
+Add parser tests for each migrated event covering:
+
+- happy path with all fields
+- minimal required only
+- missing required field → `UnknownEvent`
+- strict mode rejects an unknown extra field → `UnknownEvent`
+
+For happy-path tests, inline the discriminator literal in both the input and
+the expected object. `const data = { type: "my_event", … }` widens
+`data.type` to `string`, breaking the discriminated-union match when the
+result is compared with `toEqual(data)`.
+
+Handler-level tests in the consuming domain modules typically need no change
+— the canonical types are wire-compatible with the previous local interfaces.
+
+### 6. Local greenlight gate
+
+Run before push, in order:
+
+```bash
+# In apps/web — regenerate the @vellumai/assistant-api bundle
+bun run scripts/postinstall.ts
+
+# Type-check both packages
+( cd assistant && bunx tsc --noEmit )
+( cd apps/web && bunx tsc --noEmit )
+
+# Targeted tests
+( cd apps/web && bun test src/domains/chat/api/event-parser.test.ts )
+
+# Lint + format the touched files
+bunx eslint <files>
+bunx prettier --write <files>
+```
+
+`format:check` is a distinct CI gate from `lint`; format the touched files
+before push.
+
+## Status
+
+The remaining legacy parser cases are tracked in the **Solve Chat SSE**
+workstream (record `282e972a` in `workspace/data/apps/workstream-command-center/records/`).
+Each batch lands as its own PR under the `API Events Canonical Schemas`
+stream.

package/src/api/constants/call-sites.ts

@@ -0,0 +1,27 @@
+/**
+ * Logical call-site identifiers stamped onto every `llm_request_log` row
+ * (column `call_site` — migration 264). The inspector branches on this
+ * value alone to distinguish real LLM calls (`mainAgent`,
+ * `compactionAgent`, …) from synthetic agent-error-message rows.
+ *
+ * The constants below are the wire contract; both backend (when writing
+ * a row) and frontend (when rendering one) must reference the same
+ * literal. Add new call sites here as new emit sites appear.
+ */
+
+/**
+ * Marks a synthetic assistant error-message row — one the agent loop
+ * emitted because something went wrong (budget yield, out of funds, …)
+ * with no underlying LLM call. All such events cause the loop to exit,
+ * so a single generic bucket plus the existing `agent_loop_exit_reason`
+ * column is enough to discriminate which kind of error fired
+ * (`budget_yield_unrecovered`, future out-of-funds, etc.).
+ *
+ * Intentionally *not* a member of the backend's `LLMCallSite` enum:
+ * that enum binds config lookup, not the shape of the `call_site`
+ * column. Compaction-route filters that match
+ * `call_site = 'compactionAgent'` already treat this value as a
+ * non-compaction call, which is the desired floor-lookup behavior.
+ */
+export const CALL_SITE_SYNTHETIC_AGENT_ERROR_MESSAGE =
+  "syntheticAgentErrorMessage";

package/src/api/events/assistant-outbound-attachment.ts

@@ -0,0 +1,51 @@
+/**
+ * Outbound assistant attachment — the wire shape attached to
+ * `message_complete` and `generation_handoff` SSE events when the
+ * assistant turn produced files (sandbox writes, host transfers, tool
+ * blocks that returned binary content).
+ *
+ * Shape is the daemon's emit-time projection of `UserMessageAttachment`
+ * (see `assistant/src/daemon/message-types/shared.ts`): only the fields
+ * built in `conversation-attachments.ts::buildEmittedAttachments` plus
+ * fields the daemon explicitly emits to clients (`filePath` for
+ * recordings, per #9744) make it onto the wire. Daemon-internal fields
+ * not intended for clients (`extractedText`) stay on the daemon side
+ * and do not appear here.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const AssistantOutboundAttachmentSchema = z
+  .object({
+    /** Storage id assigned by the daemon's attachment store; absent on
+     *  in-memory drafts not backed by a stored row. */
+    id: z.string().optional(),
+    filename: z.string(),
+    mimeType: z.string(),
+    /** Base64-encoded file bytes. May be empty when `fileBacked` is
+     *  true and the client should hydrate via the /content endpoint. */
+    data: z.string(),
+    sourceType: z.enum(["sandbox_file", "host_file", "tool_block"]).optional(),
+    /** Original file size in bytes. Present when `data` was omitted to
+     *  keep payloads small. */
+    sizeBytes: z.number().optional(),
+    /** Base64-encoded JPEG thumbnail. Generated server-side for video
+     *  attachments. */
+    thumbnailData: z.string().optional(),
+    /** True when the attachment is stored on disk and clients should
+     *  hydrate via the /content endpoint instead of relying on `data`. */
+    fileBacked: z.boolean().optional(),
+    /** Local on-disk path for file-backed attachments. Used by the
+     *  macOS client to play recordings and render thumbnails directly
+     *  from the local file (see #9744 — eliminates the HTTP fetch +
+     *  ffmpeg dep for video). Web clients ignore this field. */
+    filePath: z.string().optional(),
+  })
+  .strict();
+
+export type AssistantOutboundAttachment = z.infer<
+  typeof AssistantOutboundAttachmentSchema
+>;

package/src/api/events/assistant-text-delta.ts

@@ -0,0 +1,32 @@
+/**
+ * `assistant_text_delta` SSE event.
+ *
+ * Streaming text chunk emitted by the daemon as the model produces
+ * assistant output. Multiple deltas accumulate into a single assistant
+ * message; the matching `message_complete` event marks the turn done.
+ *
+ * `messageId` is the database row id of the assistant message this
+ * delta belongs to — stamped from the pre-allocated turn anchor (see
+ * `reserveMessage` / `AssistantTurnStartEvent`). Absent on streams
+ * produced by older daemons that pre-date the anchor protocol, or on
+ * synthetic deltas (canned greetings, slash-command echoes, live-voice
+ * transcript injections) that don't bind to a row.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const AssistantTextDeltaEventSchema = z
+  .object({
+    type: z.literal("assistant_text_delta"),
+    text: z.string(),
+    messageId: z.string().optional(),
+    conversationId: z.string().optional(),
+  })
+  .strict();
+
+export type AssistantTextDeltaEvent = z.infer<
+  typeof AssistantTextDeltaEventSchema
+>;

package/src/api/events/assistant-turn-start.ts

@@ -0,0 +1,33 @@
+/**
+ * `assistant_turn_start` SSE event.
+ *
+ * Marks the start of an assistant turn — emitted once by the daemon
+ * *before* any `assistant_text_delta`, `tool_use_start`, or
+ * `assistant_thinking_delta` event for that turn. The `messageId` is the
+ * pre-allocated database row id (see `reserveMessage` in
+ * `assistant/src/memory/conversation-crud.ts`) that subsequent streaming
+ * events stamp on their `messageId` field. Clients use this id to
+ * anchor a UI bubble at turn-start instead of waiting for
+ * `message_complete`.
+ *
+ * Types-only addition at introduction — no daemon emit sites yet. The
+ * agent loop will adopt pre-allocation in a follow-up.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const AssistantTurnStartEventSchema = z
+  .object({
+    type: z.literal("assistant_turn_start"),
+    messageId: z.string(),
+    conversationId: z.string().optional(),
+  })
+  .strict();
+
+export type AssistantTurnStartEvent = z.infer<
+  typeof AssistantTurnStartEventSchema
+>;

package/src/api/events/document-comment-created.ts

@@ -0,0 +1,48 @@
+/**
+ * `document_comment_created` SSE event.
+ *
+ * Emitted when a new comment is added to a document surface — either
+ * authored by the user or by the assistant during a tool run. Carries
+ * the full comment payload so the client can render it without a
+ * separate fetch. Subsequent lifecycle transitions (resolve / reopen /
+ * delete) reference the comment by id only.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+const DocumentCommentSchema = z
+  .object({
+    id: z.string(),
+    surfaceId: z.string(),
+    /** Author label — typically `"user"` or `"assistant"`. Wire is permissive `string`; clients narrow at the boundary. */
+    author: z.string(),
+    content: z.string(),
+    /** Character offsets into the rendered document text when the comment is anchored to a selection. */
+    anchorStart: z.number().optional(),
+    anchorEnd: z.number().optional(),
+    /** The selected text the comment was anchored to, for resilience to document edits. */
+    anchorText: z.string().optional(),
+    /** Set when the comment is a reply in a thread. */
+    parentCommentId: z.string().optional(),
+    /** Lifecycle state — `"open"` or `"resolved"`. Wire is permissive `string`; clients narrow at the boundary. */
+    status: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+  })
+  .strict();
+
+export const DocumentCommentCreatedEventSchema = z
+  .object({
+    type: z.literal("document_comment_created"),
+    conversationId: z.string(),
+    surfaceId: z.string(),
+    comment: DocumentCommentSchema,
+  })
+  .strict();
+
+export type DocumentCommentCreatedEvent = z.infer<
+  typeof DocumentCommentCreatedEventSchema
+>;

package/src/api/events/document-comment-deleted.ts

@@ -0,0 +1,24 @@
+/**
+ * `document_comment_deleted` SSE event.
+ *
+ * Emitted when a document comment is removed. The client drops the
+ * comment from local state.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const DocumentCommentDeletedEventSchema = z
+  .object({
+    type: z.literal("document_comment_deleted"),
+    conversationId: z.string(),
+    surfaceId: z.string(),
+    commentId: z.string(),
+  })
+  .strict();
+
+export type DocumentCommentDeletedEvent = z.infer<
+  typeof DocumentCommentDeletedEventSchema
+>;

package/src/api/events/document-comment-reopened.ts

@@ -0,0 +1,25 @@
+/**
+ * `document_comment_reopened` SSE event.
+ *
+ * Emitted when a previously-resolved document comment is reopened.
+ * The client clears the comment's resolved state and transitions it
+ * back to `"open"`.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const DocumentCommentReopenedEventSchema = z
+  .object({
+    type: z.literal("document_comment_reopened"),
+    conversationId: z.string(),
+    surfaceId: z.string(),
+    commentId: z.string(),
+  })
+  .strict();
+
+export type DocumentCommentReopenedEvent = z.infer<
+  typeof DocumentCommentReopenedEventSchema
+>;

package/src/api/events/document-comment-resolved.ts

@@ -0,0 +1,27 @@
+/**
+ * `document_comment_resolved` SSE event.
+ *
+ * Emitted when an existing document comment is marked resolved. The
+ * client transitions the comment's status to `"resolved"` and stamps
+ * `resolvedBy` from the wire value.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const DocumentCommentResolvedEventSchema = z
+  .object({
+    type: z.literal("document_comment_resolved"),
+    conversationId: z.string(),
+    surfaceId: z.string(),
+    commentId: z.string(),
+    /** User or actor label that resolved the comment. */
+    resolvedBy: z.string(),
+  })
+  .strict();
+
+export type DocumentCommentResolvedEvent = z.infer<
+  typeof DocumentCommentResolvedEventSchema
+>;

package/src/api/events/generation-cancelled.ts

@@ -0,0 +1,24 @@
+/**
+ * `generation_cancelled` SSE event.
+ *
+ * Emitted when an assistant turn is cancelled before completion —
+ * user-initiated abort, queue-drain interruption, or daemon-side
+ * lifecycle exit. Terminal event for the turn: no further deltas or
+ * `message_complete` follow.
+ *
+ * Canonical wire-contract source. Daemon code imports the type directly
+ * from this file; external consumers import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const GenerationCancelledEventSchema = z
+  .object({
+    type: z.literal("generation_cancelled"),
+    conversationId: z.string().optional(),
+  })
+  .strict();
+
+export type GenerationCancelledEvent = z.infer<
+  typeof GenerationCancelledEventSchema
+>;