@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/agent/loop.ts

@@ -1,4 +1,7 @@
 import type { AnsweredQuestion } from "../api/events/question-answered.js";
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { SEND_USER_MESSAGE_TOOL_NAME } from "../config/send-user-message-constants.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
@@ -11,7 +14,6 @@ import {
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
 import { spoolAndStubOversizedToolResults } from "../context/tool-result-spool.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import { parseActualTokensFromError } from "../daemon/parse-actual-tokens-from-error.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import type {
@@ -443,25 +445,26 @@ export type AgentEvent =
       /**
        * Emitted when the provider call throws — i.e. the provider
        * rejected the request before returning a usable response. Carries
-       * the loop-level raw request we attempted to send (messages, tools,
-       * system prompt, provider-agnostic config) plus the thrown error.
+       * the wire request we attempted to send plus the thrown error.
        * Consumers (`handleProviderError` in the daemon handlers, the
        * `onEvent` in `agent-wake`) persist these as `llm_request_logs`
        * rows so failed calls are queryable in the LLM inspector instead
        * of only surfacing in pino logs.
        *
-       * `rawRequest` is the loop-level abstract shape rather than the
-       * provider-specific payload (which the provider builds internally
-       * and never returns when it throws). `actualProvider` echoes the
-       * `ProviderError.provider` tag when available so the persisted row
-       * has the same `provider` column value as a successful `usage` row.
+       * `rawRequest` is `ProviderError.rawRequest` when the throw carried
+       * an inspectable SDK/wire payload (including extra body fields such
+       * as `directions`). The loop does not invent a substitute snapshot
+       * of messages/tools/systemPrompt; a missing payload stays missing.
+       * `actualProvider` echoes `ProviderError.provider` so a routed
+       * invocation (e.g. Vellum via a Fireworks default wrapper) is
+       * attributed to the transport that actually ran.
        *
        * Re-thrown by the inner LLM-call try/catch after emission so the
        * outer agent-loop catch still handles abort, the existing `error`
        * event, and the loop break.
        */
       type: "provider_error";
-      rawRequest: unknown;
+      rawRequest?: unknown;
       error: Error;
       actualProvider?: string;
     }
@@ -663,6 +666,18 @@ type AgentLoopContextWindowResolver = () => {
   overflowRecovery: { enabled: boolean; safetyMarginRatio: number };
 };
 
+/** Final request surface after the pre-model hook has settled. */
+export interface PreparedModelCall {
+  callSite?: LLMCallSite;
+  overrideProfile?: string;
+  forceOverrideProfile: boolean;
+  /** Present when the finalized route opts out of prompt caching. */
+  disableCache?: true;
+  signal?: AbortSignal;
+  systemPrompt: string | null;
+  tools: ToolDefinition[];
+}
+
 interface AgentLoopRunOptionsBase {
   /** Input history the run starts from; the loop appends its output onto a copy. */
   messages: Message[];
@@ -690,7 +705,10 @@ interface AgentLoopRunOptionsBase {
   onCheckpoint?: (
     checkpoint: CheckpointInfo,
   ) => CheckpointDecision | Promise<CheckpointDecision>;
+  /** Semantic call site exposed to hooks, events, and loop behavior. */
   callSite?: LLMCallSite;
+  /** Provider-resolution call site when it differs from turn semantics. */
+  inferenceCallSite?: LLMCallSite;
   /**
    * Route this run's user-facing text through the `send_user_message` tool
    * instead of streamed assistant text. The daemon sets it for main-agent runs
@@ -740,6 +758,8 @@ interface AgentLoopRunOptionsBase {
    */
   forceOverrideProfile?: boolean;
   resolveOverrideProfile?: () => string | undefined;
+  /** Observe a finalized model request without delaying provider dispatch. */
+  onModelCallPrepared?: (prepared: PreparedModelCall) => void;
   /**
    * When `true`, the loop owns turn-start and mid-loop compaction. The pre-call
    * budget gate runs before the very first provider call — subsuming the
@@ -1429,18 +1449,21 @@ export class AgentLoop {
       requestId,
       onCheckpoint,
       callSite,
+      inferenceCallSite,
       suppressAssistantText = false,
       supportsDynamicUi = true,
       trust,
       overrideProfile,
       forceOverrideProfile = false,
       resolveOverrideProfile,
+      onModelCallPrepared,
       compactInPlace = false,
       isNonInteractive = false,
       model: runModel,
       latencyTracker,
       injectionLedgerResets,
     } = options;
+    const providerCallSite = inferenceCallSite ?? callSite;
     // Snapshot the system prompt once per run. The instance field is mutable
     // (the conversation may update it between turns), but a single run must
     // use one consistent prompt — an aborted run left detached after the
@@ -1886,7 +1909,7 @@ export class AgentLoop {
         // unexecutable client tool. The advisor consult's `advisorProfile` can
         // route `subagentSpawn` to a provider/model whose native-search support
         // differs from the construction-time default, so the gate resolves the
-        // routed target (callSite + overrideProfile) via
+        // routed target (providerCallSite + overrideProfile) via
         // `supportsNativeWebSearchFor` rather than the static
         // `this.provider.supportsNativeWebSearch` snapshot; providers without
         // the routing-aware probe fall back to the static flag. This is a SERVER
@@ -1898,7 +1921,7 @@ export class AgentLoop {
           .supportsNativeWebSearchFor
           ? this.provider.supportsNativeWebSearchFor(
               buildNativeWebSearchProbeOptions(
-                callSite,
+                providerCallSite,
                 resolveEffectiveOverrideProfile(),
                 forceOverrideProfile,
                 this.conversationId,
@@ -1917,11 +1940,11 @@ export class AgentLoop {
         //   1. Per-run explicit (`runModel`)
         //   2. Call-site resolved values (filled by
         //      `RetryProvider.normalizeSendMessageOptions` from
-        //      `resolveCallSiteConfig(callSite, llm)`)
+        //      `resolveCallSiteConfig(providerCallSite, llm)`)
         //   3. Conversation defaults (`this.config.*`, from the resolved
         //      default call-site config)
         //
-        // When `callSite` is present we deliberately leave
+        // When `providerCallSite` is present we deliberately leave
         // `max_tokens`/`thinking`/`effort`/`speed` *unset* in `providerConfig`
         // so the normalizer can fill them from the call-site resolution. The
         // normalizer only writes these fields when they're undefined; if we
@@ -1929,10 +1952,10 @@ export class AgentLoop {
         // for these knobs is silently ignored.
         //
         // `toolChoice` and `cacheTtl` are not part of the call-site schema, so
-        // they always come from `this.config` regardless of `callSite`.
+        // they always come from `this.config` regardless of `providerCallSite`.
         const providerConfig: Record<string, unknown> = {};
 
-        if (!callSite) {
+        if (!providerCallSite) {
           providerConfig.max_tokens = this.config.maxTokens;
         }
 
@@ -1940,7 +1963,7 @@ export class AgentLoop {
           providerConfig.model = runModel;
         }
 
-        if (!callSite) {
+        if (!providerCallSite) {
           const thinking = normalizeThinkingConfigForWire(this.config.thinking);
           if (thinking !== undefined) {
             providerConfig.thinking = thinking;
@@ -1979,9 +2002,9 @@ export class AgentLoop {
         // defaults when absent).
         // User-initiated conversation turns default to `mainAgent` in the
         // agent loop's caller; other invocation contexts (heartbeat, filing,
-        // analyze, etc.) pass their own `callSite`.
-        if (callSite) {
-          providerConfig.callSite = callSite;
+        // analyze, etc.) pass their own provider-resolution site.
+        if (providerCallSite) {
+          providerConfig.callSite = providerCallSite;
           providerConfig.usageTracking = "manual";
           // Per-conversation seed for deterministic `mix`-profile expansion.
           // Sourced from the loop's own conversation id so every LLM call in a
@@ -2009,7 +2032,7 @@ 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.
+        // profile correct, matching how the provider call site is plumbed.
         const effectiveOverrideProfile = resolveEffectiveOverrideProfile();
         if (effectiveOverrideProfile) {
           providerConfig.overrideProfile = effectiveOverrideProfile;
@@ -2233,6 +2256,49 @@ export class AgentLoop {
           );
         }
 
+        if (onModelCallPrepared && !signal?.aborted) {
+          const preparedOverrideProfile =
+            typeof providerConfig.overrideProfile === "string" &&
+            providerConfig.overrideProfile.length > 0
+              ? providerConfig.overrideProfile
+              : undefined;
+          try {
+            const preparedForceOverrideProfile =
+              providerConfig.forceOverrideProfile === true;
+            const disableCache =
+              providerCallSite !== undefined &&
+              resolveCallSiteConfig(providerCallSite, getConfig().llm, {
+                ...(preparedOverrideProfile !== undefined
+                  ? { overrideProfile: preparedOverrideProfile }
+                  : {}),
+                ...(preparedForceOverrideProfile
+                  ? { forceOverrideProfile: true }
+                  : {}),
+                ...(this.conversationId !== undefined
+                  ? { selectionSeed: this.conversationId }
+                  : {}),
+              }).disableCache === true;
+            onModelCallPrepared({
+              ...(providerCallSite !== undefined
+                ? { callSite: providerCallSite }
+                : {}),
+              ...(preparedOverrideProfile !== undefined
+                ? { overrideProfile: preparedOverrideProfile }
+                : {}),
+              forceOverrideProfile: preparedForceOverrideProfile,
+              ...(disableCache ? { disableCache: true as const } : {}),
+              ...(signal !== undefined ? { signal } : {}),
+              systemPrompt: providerOptions.systemPrompt ?? null,
+              tools: currentTools,
+            });
+          } catch (preparedError) {
+            rlog.warn(
+              { err: preparedError },
+              "Prepared model-call observer failed; continuing with provider dispatch",
+            );
+          }
+        }
+
         // 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
@@ -2250,10 +2316,10 @@ export class AgentLoop {
         // turn body (tool execution, plugin pipelines, checkpoints), so
         // recording there would risk mis-attributing tool/plugin throws as
         // provider rejections. On provider failure we emit `provider_error`
-        // with the loop-level raw request so consumers can persist it as an
-        // `llm_request_logs` row, then re-throw so the existing outer catch
-        // continues to handle abort sync, the `error` event, and the loop
-        // break unchanged.
+        // with the inspectable wire request from the throw (when present)
+        // so consumers can persist it as an `llm_request_logs` row, then
+        // re-throw so the existing outer catch continues to handle abort
+        // sync, the `error` event, and the loop break unchanged.
         // Latency: the request is about to leave for the provider. The span
         // from here to the first streamed token is time-to-first-token.
         latencyTracker?.mark("request_sent");
@@ -2276,26 +2342,18 @@ export class AgentLoop {
               llmCallError instanceof Error
                 ? llmCallError
                 : new Error(String(llmCallError));
-            // Strip non-serializable / runtime-only fields from `options`
-            // before snapshotting. `onEvent` is a closure with side effects
-            // and `signal` is an AbortSignal — neither is meaningful in a
-            // persisted log row, and `JSON.stringify` would silently drop or
-            // misrepresent both.
-            const rawRequest = {
-              provider: this.provider.name,
-              messages: sanitizedHistory,
-              tools: providerOptions.tools,
-              systemPrompt: providerOptions.systemPrompt,
-              config: providerOptions.config,
-            };
+            const invocationProvider =
+              errInstance instanceof ProviderError
+                ? errInstance.provider
+                : this.provider.name;
             onEvent({
               type: "provider_error",
-              rawRequest,
+              ...(errInstance instanceof ProviderError &&
+              errInstance.rawRequest !== undefined
+                ? { rawRequest: errInstance.rawRequest }
+                : {}),
               error: errInstance,
-              actualProvider:
-                errInstance instanceof ProviderError
-                  ? errInstance.provider
-                  : this.provider.name,
+              actualProvider: invocationProvider,
             });
           }
           providerCallError = llmCallError;

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

@@ -20,10 +20,13 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
+
 export const AssistantTurnStartEventSchema = z.object({
   type: z.literal("assistant_turn_start"),
   messageId: z.string(),
   conversationId: z.string().optional(),
+  modeSession: ModeSessionSchema.optional(),
 });
 
 export type AssistantTurnStartEvent = z.infer<

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

@@ -18,6 +18,7 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
 import { AssistantOutboundAttachmentSchema } from "./assistant-outbound-attachment.js";
 
 export const GenerationHandoffEventSchema = z.object({
@@ -30,6 +31,7 @@ export const GenerationHandoffEventSchema = z.object({
   queuedCount: z.number(),
   /** Database row id of the just-finished assistant turn. */
   messageId: z.string().optional(),
+  modeSession: ModeSessionSchema.optional(),
   attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
   attachmentWarnings: z.array(z.string()).optional(),
 });

package/src/api/events/message-complete.ts

@@ -24,12 +24,14 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
 import { AssistantOutboundAttachmentSchema } from "./assistant-outbound-attachment.js";
 
 export const MessageCompleteEventSchema = z.object({
   type: z.literal("message_complete"),
   messageId: z.string().optional(),
   conversationId: z.string().optional(),
+  modeSession: ModeSessionSchema.optional(),
   source: z.enum(["main", "aux"]).optional(),
   attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
   /** Soft warnings produced while resolving attachments (e.g. format

package/src/api/events/notification-conversation-created.ts

@@ -2,10 +2,10 @@
  * `notification_conversation_created` SSE event.
  *
  * Server → client broadcast emitted when an incoming notification
- * creates a new vellum conversation. Clients use it to place the
- * conversation in the sidebar (`groupId`, `source`) and decide whether
- * to raise a fallback OS banner (`silent`). `targetGuardianPrincipalId`
- * scopes guardian-sensitive conversations to a bound identity.
+ * creates a new vellum conversation. First-party clients ignore it; the
+ * web client lists it as a no-op. A guardian-sensitive
+ * conversation is announced only to connections authenticated as the
+ * guardian named in `targetGuardianPrincipalId`.
  *
  * Canonical wire-contract source. Daemon code imports the type
  * directly from this file; external consumers import via
@@ -21,27 +21,25 @@ export const NotificationConversationCreatedEventSchema = z.object({
   sourceEventName: z.string(),
   /**
    * When set, this conversation was created for a guardian-sensitive
-   * notification and should only be surfaced by clients bound to this
-   * guardian identity.
+   * notification. The daemon delivers the event only to connections whose
+   * verified principal is this guardian, so every client that receives it
+   * is one it was meant for.
    */
   targetGuardianPrincipalId: z.string().optional(),
   /**
-   * Conversation group identifier propagated from the signal producer.
-   * Clients use this to place the conversation in the correct sidebar
-   * folder (e.g. "system:scheduled" for schedule completion threads).
+   * Conversation group identifier propagated from the signal producer:
+   * the sidebar folder the conversation belongs in (e.g.
+   * "system:scheduled" for schedule completion threads).
    */
   groupId: z.string().optional(),
   /**
-   * Semantic source of the conversation (e.g. "schedule", "reminder").
-   * Allows clients to override the default "notification" source so the
-   * conversation is attributed correctly.
+   * Semantic source of the conversation (e.g. "schedule", "reminder"),
+   * overriding the default "notification" source.
    */
   source: z.string().optional(),
   /**
-   * Mirrors `NotificationIntent.silent`. When true the client must not
-   * post a fallback OS banner for this conversation — the sidebar entry
-   * still appears, but the always-on inbox is the only surfaced channel.
-   * Derived from the originating signal's `attentionHints.urgency`.
+   * Mirrors `NotificationIntent.silent`, which the server sets for
+   * low- and medium-urgency signals. Clients act on the intent's copy.
    */
   silent: z.boolean().optional(),
 });

package/src/api/events/notification-intent.ts

@@ -2,8 +2,10 @@
  * `notification_intent` SSE event.
  *
  * Broadcast when a notification should be displayed. Clients turn it
- * into a local OS / in-app notification, filter guardian-scoped intents
- * to matching devices, and ack delivery back to the daemon.
+ * into a local OS / in-app notification and ack delivery back to the
+ * daemon. A guardian-scoped intent (`targetGuardianPrincipalId` set) is
+ * delivered only to connections whose verified principal is that
+ * guardian, so every client that receives one is meant to show it.
  *
  * `silent` tells the client not to post the intent to the OS
  * notification surface (non-banner side effects still run); the server

package/src/api/events/tool-result.ts

@@ -29,6 +29,7 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
 import {
   AllowlistOptionSchema,
   ConfirmationDiffSchema,
@@ -51,6 +52,8 @@ export const WebSearchProviderIdSchema = z.enum([
   "keenable",
   "firecrawl",
   "fastcrw",
+  "searxng",
+  "tinyfish",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
@@ -59,18 +62,24 @@ export const WebFetchProviderIdSchema = z.enum([
   "default",
   "firecrawl",
   "fastcrw",
+  "tinyfish",
 ]);
 
 export type WebFetchProviderId = z.infer<typeof WebFetchProviderIdSchema>;
 
 export const WebSearchResultItemSchema = z.object({
+  /** 1-indexed. */
   rank: z.number(),
   title: z.string(),
   url: z.string(),
+  /** The lowercased host. */
   domain: z.string(),
   faviconUrl: z.string().optional(),
+  /** Absent for `anthropic-native`, whose content is encrypted. */
   snippet: z.string().optional(),
+  /** A freshness hint; Brave only. */
   age: z.string().optional(),
+  /** Tavily only. */
   score: z.number().optional(),
 });
 
@@ -107,9 +116,84 @@ export const WebFetchMetadataSchema = z.object({
 
 export type WebFetchMetadata = z.infer<typeof WebFetchMetadataSchema>;
 
+/** A place `recall` searches. */
+export const RecallSourceSchema = z.enum([
+  "memory",
+  "conversations",
+  "workspace",
+]);
+
+export type RecallSource = z.infer<typeof RecallSourceSchema>;
+
+/** How hard `recall` searches: more depth, more rounds across the sources. */
+export const RecallDepthSchema = z.enum(["fast", "standard", "deep"]);
+
+export type RecallDepth = z.infer<typeof RecallDepthSchema>;
+
+/** One piece of evidence a `recall` result stands on. */
+export const RecallEvidenceItemSchema = z.object({
+  source: RecallSourceSchema,
+  title: z.string(),
+  /** Where in its source: a memory page, a conversation and when, a file and line. */
+  locator: z.string(),
+  /** The excerpt, collapsed to one line and cut to a few hundred characters. */
+  excerpt: z.string(),
+  timestampMs: z.number().optional(),
+  /**
+   * The workspace-relative file the item was found in, for a workspace file or
+   * a memory page, so a client can open it.
+   */
+  path: z.string().optional(),
+  /** The conversation the item was found in, so a client can open it. */
+  conversationId: z.string().optional(),
+  /** The message in that conversation, so a client can open it there. */
+  messageId: z.string().optional(),
+});
+
+export type RecallEvidenceItem = z.infer<typeof RecallEvidenceItemSchema>;
+
+/** How one source fared: searched, or degraded with the reason. */
+export const RecallSearchedSourceSchema = z.object({
+  source: RecallSourceSchema,
+  status: z.enum(["searched", "degraded"]),
+  evidenceCount: z.number(),
+  error: z.string().optional(),
+});
+
+export type RecallSearchedSource = z.infer<typeof RecallSearchedSourceSchema>;
+
+/**
+ * A `recall` call as structured data: what it searched for and how, the answer
+ * when one was written, the evidence it stands on, and how each source fared.
+ * The same result the tool's text gives the model, for a client to lay out.
+ */
+export const RecallMetadataSchema = z.object({
+  query: z.string(),
+  depth: RecallDepthSchema,
+  sources: z.array(RecallSourceSchema),
+  /**
+   * The answer written from the evidence. Absent when recall fell back to
+   * listing what it found, or found nothing.
+   */
+  answer: z.string().optional(),
+  evidence: z.array(RecallEvidenceItemSchema),
+  searchedSources: z.array(RecallSearchedSourceSchema),
+});
+
+export type RecallMetadata = z.infer<typeof RecallMetadataSchema>;
+
+/** A `remember` call as structured data: the facts it saved, as written. */
+export const RememberMetadataSchema = z.object({
+  facts: z.array(z.string()),
+});
+
+export type RememberMetadata = z.infer<typeof RememberMetadataSchema>;
+
 export const ToolActivityMetadataSchema = z.object({
   webSearch: WebSearchMetadataSchema.optional(),
   webFetch: WebFetchMetadataSchema.optional(),
+  recall: RecallMetadataSchema.optional(),
+  remember: RememberMetadataSchema.optional(),
 });
 
 export type ToolActivityMetadata = z.infer<typeof ToolActivityMetadataSchema>;
@@ -126,6 +210,7 @@ export const ToolResultEventSchema = z.object({
   imageDataList: z.array(z.string()).optional(),
   toolUseId: z.string().optional(),
   messageId: z.string().optional(),
+  modeSession: ModeSessionSchema.optional(),
   riskLevel: z.string().optional(),
   riskReason: z.string().optional(),
   matchedTrustRuleId: z.string().optional(),

package/src/api/events/tool-use-start.ts

@@ -18,6 +18,8 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
+
 export const ToolUseStartEventSchema = z.object({
   type: z.literal("tool_use_start"),
   toolName: z.string(),
@@ -25,6 +27,7 @@ export const ToolUseStartEventSchema = z.object({
   toolUseId: z.string().optional(),
   messageId: z.string().optional(),
   conversationId: z.string().optional(),
+  modeSession: ModeSessionSchema.optional(),
   /**
    * Unix ms when the daemon began executing the tool. Lets clients anchor a
    * live elapsed-time counter to the server clock instead of the moment the

package/src/api/events/user-message-echo.ts

@@ -26,6 +26,8 @@
 
 import { z } from "zod";
 
+import { ModeSessionSchema } from "../mode-session.js";
+
 export const UserMessageEchoEventSchema = z
   .object({
     type: z.literal("user_message_echo"),
@@ -35,6 +37,7 @@ export const UserMessageEchoEventSchema = z
     requestId: z.string().optional(),
     clientMessageId: z.string().optional(),
     cameraFrame: z.literal(true).optional(),
+    modeSession: ModeSessionSchema.optional(),
   })
   .strict();
 

package/src/api/index.ts

@@ -4,6 +4,7 @@ export {
   isComputerUseToolCall,
   resolveComputerUseToolName,
 } from "./computer-use-tool.js";
+export { type RememberInput, RememberInputSchema } from "./remember-tool.js";
 
 import { AcpAuthRequiredEventSchema } from "./events/acp-auth-required.js";
 import { AcpSessionCompletedEventSchema } from "./events/acp-session-completed.js";
@@ -50,7 +51,6 @@ import { DocumentEditorUpdateEventSchema } from "./events/document-editor-update
 import { ErrorEventSchema } from "./events/error.js";
 import { GenerationCancelledEventSchema } from "./events/generation-cancelled.js";
 import { GenerationHandoffEventSchema } from "./events/generation-handoff.js";
-import { HeartbeatAlertEventSchema } from "./events/heartbeat-alert.js";
 import { HeartbeatConversationCreatedEventSchema } from "./events/heartbeat-conversation-created.js";
 import { HomeFeedUpdatedEventSchema } from "./events/home-feed-updated.js";
 import { HookEventSchema } from "./events/hook-event.js";
@@ -395,10 +395,6 @@ export {
   type GenerationHandoffEvent,
   GenerationHandoffEventSchema,
 } from "./events/generation-handoff.js";
-export {
-  type HeartbeatAlertEvent,
-  HeartbeatAlertEventSchema,
-} from "./events/heartbeat-alert.js";
 export {
   type HeartbeatConversationCreatedEvent,
   HeartbeatConversationCreatedEventSchema,
@@ -647,6 +643,18 @@ export {
   ToolOutputChunkSubTypeSchema,
 } from "./events/tool-output-chunk.js";
 export {
+  type RecallDepth,
+  RecallDepthSchema,
+  type RecallEvidenceItem,
+  RecallEvidenceItemSchema,
+  type RecallMetadata,
+  RecallMetadataSchema,
+  type RecallSearchedSource,
+  RecallSearchedSourceSchema,
+  type RecallSource,
+  RecallSourceSchema,
+  type RememberMetadata,
+  RememberMetadataSchema,
   type RiskScopeOption,
   RiskScopeOptionSchema,
   type ToolActivityMetadata,
@@ -734,6 +742,24 @@ export {
   type WorkflowStartedEvent,
   WorkflowStartedEventSchema,
 } from "./events/workflow-started.js";
+export {
+  type ModeSession,
+  type ModeSessionActivity,
+  ModeSessionActivitySchema,
+  type ModeSessionDescriptor,
+  ModeSessionDescriptorSchema,
+  type ModeSessionMode,
+  ModeSessionModeSchema,
+  type ModeSessionRuntimeState,
+  ModeSessionRuntimeStateSchema,
+  ModeSessionSchema,
+  type ModeSessionStatus,
+  ModeSessionStatusSchema,
+  type ModeSessionSummary,
+  ModeSessionSummarySchema,
+  parseModeSession,
+  TolerantModeSessionSchema,
+} from "./mode-session.js";
 export {
   type DictationContext,
   DictationContextSchema,
@@ -1021,7 +1047,6 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   ErrorEventSchema,
   GenerationCancelledEventSchema,
   GenerationHandoffEventSchema,
-  HeartbeatAlertEventSchema,
   HeartbeatConversationCreatedEventSchema,
   HomeFeedUpdatedEventSchema,
   HookEventSchema,