@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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/question-request.ts

@@ -48,6 +48,7 @@ export const QuestionEntrySchema = z.object({
   description: z.string().optional(),
   options: z.array(QuestionOptionSchema),
   freeTextPlaceholder: z.string().optional(),
+  presentation: z.literal("virtual_desktop").optional(),
 });
 
 export type QuestionEntry = z.infer<typeof QuestionEntrySchema>;

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

@@ -1,5 +1,11 @@
 import { z } from "zod";
 
+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";
 import { AcpSessionErrorEventSchema } from "./events/acp-session-error.js";
@@ -34,6 +40,7 @@ import { ConversationErrorEventSchema } from "./events/conversation-error.js";
 import { ConversationInferenceProfileUpdatedEventSchema } from "./events/conversation-inference-profile-updated.js";
 import { ConversationNoticeEventSchema } from "./events/conversation-notice.js";
 import { ConversationTitleUpdatedEventSchema } from "./events/conversation-title-updated.js";
+import { DesktopActivityChangedEventSchema } from "./events/desktop-activity-changed.js";
 import { DiskPressureStatusChangedEventSchema } from "./events/disk-pressure-status-changed.js";
 import { DocumentCommentCreatedEventSchema } from "./events/document-comment-created.js";
 import { DocumentCommentDeletedEventSchema } from "./events/document-comment-deleted.js";
@@ -44,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";
@@ -342,6 +348,10 @@ export {
   type ConversationTitleUpdatedEvent,
   ConversationTitleUpdatedEventSchema,
 } from "./events/conversation-title-updated.js";
+export {
+  type DesktopActivityChangedEvent,
+  DesktopActivityChangedEventSchema,
+} from "./events/desktop-activity-changed.js";
 export {
   type DiskPressureBlockedCapability,
   DiskPressureBlockedCapabilitySchema,
@@ -385,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,
@@ -637,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,
@@ -724,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,
@@ -1000,6 +1036,7 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   ConversationInferenceProfileUpdatedEventSchema,
   ConversationNoticeEventSchema,
   ConversationTitleUpdatedEventSchema,
+  DesktopActivityChangedEventSchema,
   DiskPressureStatusChangedEventSchema,
   DocumentCommentCreatedEventSchema,
   DocumentCommentDeletedEventSchema,
@@ -1010,7 +1047,6 @@ export const AssistantEventSchema = z.discriminatedUnion("type", [
   ErrorEventSchema,
   GenerationCancelledEventSchema,
   GenerationHandoffEventSchema,
-  HeartbeatAlertEventSchema,
   HeartbeatConversationCreatedEventSchema,
   HomeFeedUpdatedEventSchema,
   HookEventSchema,

package/src/api/mode-session.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  ModeSessionSchema,
+  ModeSessionStatusSchema,
+  ModeSessionSummarySchema,
+} from "./mode-session.js";
+
+describe("mode session API schemas", () => {
+  test("accepts canonical membership", () => {
+    expect(
+      ModeSessionSchema.parse({ id: "session-123", mode: "browser" }),
+    ).toEqual({ id: "session-123", mode: "browser" });
+  });
+
+  test("keeps persisted status to the three lifecycle states", () => {
+    expect(ModeSessionStatusSchema.options).toEqual([
+      "active",
+      "completed",
+      "interrupted",
+    ]);
+    expect(ModeSessionStatusSchema.safeParse("waiting").success).toBe(false);
+    expect(ModeSessionStatusSchema.safeParse("draining").success).toBe(false);
+  });
+
+  test("accepts an interrupted summary with unknown end time", () => {
+    const summary = ModeSessionSummarySchema.parse({
+      id: "session-123",
+      conversationId: "conv-123",
+      mode: "computer_use",
+      status: "interrupted",
+      sourceStartedAt: 100,
+      firstIncludedAt: 110,
+      firstIncludedMessageId: "message-123",
+      lastActivityAt: 125,
+      lastOwnedMessageId: "message-456",
+      endedAt: null,
+      endReason: "assistant_restarted",
+      revision: 4,
+    });
+
+    expect(summary.endedAt).toBeNull();
+  });
+
+  test("rejects unknown historic modes and invalid revisions", () => {
+    const base = {
+      id: "session-123",
+      conversationId: "conv-123",
+      status: "active",
+      sourceStartedAt: 100,
+      firstIncludedAt: null,
+      firstIncludedMessageId: null,
+      lastActivityAt: 100,
+      lastOwnedMessageId: null,
+      endedAt: null,
+      endReason: null,
+    };
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        ...base,
+        mode: "unknown_mode",
+        revision: 1,
+      }).success,
+    ).toBe(false);
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        ...base,
+        mode: "ambient",
+        revision: 0,
+      }).success,
+    ).toBe(false);
+  });
+
+  test("enforces status-specific terminal timing", () => {
+    const base = {
+      id: "session-123",
+      conversationId: "conv-123",
+      mode: "browser",
+      sourceStartedAt: 100,
+      firstIncludedAt: null,
+      firstIncludedMessageId: null,
+      lastActivityAt: 125,
+      lastOwnedMessageId: null,
+      revision: 1,
+    };
+
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        ...base,
+        status: "active",
+        endedAt: 150,
+        endReason: "settled",
+      }).success,
+    ).toBe(false);
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        ...base,
+        status: "completed",
+        endedAt: null,
+        endReason: "settled",
+      }).success,
+    ).toBe(false);
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        ...base,
+        status: "completed",
+        endedAt: 120,
+        endReason: "settled",
+      }).success,
+    ).toBe(false);
+  });
+
+  test("keeps display boundary fields paired", () => {
+    expect(
+      ModeSessionSummarySchema.safeParse({
+        id: "session-123",
+        conversationId: "conv-123",
+        mode: "ambient",
+        status: "active",
+        sourceStartedAt: 100,
+        firstIncludedAt: 110,
+        firstIncludedMessageId: null,
+        lastActivityAt: 125,
+        lastOwnedMessageId: null,
+        endedAt: null,
+        endReason: null,
+        revision: 1,
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/api/mode-session.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+
+export const ModeSessionModeSchema = z.enum([
+  "computer_use",
+  "browser",
+  "live_vision",
+  "ambient",
+]);
+export type ModeSessionMode = z.infer<typeof ModeSessionModeSchema>;
+
+/** Whether a stamped row may start the user-visible span for this mode. */
+export function modeSessionRowStartsDisplay(
+  mode: ModeSessionMode,
+  startsDisplayBoundary: boolean,
+): boolean {
+  return mode === "live_vision" || startsDisplayBoundary;
+}
+
+export const ModeSessionStatusSchema = z.enum([
+  "active",
+  "completed",
+  "interrupted",
+]);
+export type ModeSessionStatus = z.infer<typeof ModeSessionStatusSchema>;
+
+/** Immutable ownership stamped onto transcript message metadata. */
+export const ModeSessionSchema = z.object({
+  mode: ModeSessionModeSchema,
+  id: z.string().min(1),
+});
+export type ModeSession = z.infer<typeof ModeSessionSchema>;
+
+export function parseModeSession(value: unknown): ModeSession | undefined {
+  const parsed = ModeSessionSchema.safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+
+/** Historic or caller-authored invalid stamps behave like an absent stamp. */
+export const TolerantModeSessionSchema = z.preprocess(
+  parseModeSession,
+  ModeSessionSchema.optional(),
+);
+
+const MAX_DATE_MS = 8_640_000_000_000_000;
+
+export const ModeSessionActivitySchema = z
+  .object({
+    firstAt: z.number().int().nonnegative().max(MAX_DATE_MS),
+    lastAt: z.number().int().nonnegative().max(MAX_DATE_MS),
+  })
+  .refine((activity) => activity.lastAt >= activity.firstAt, {
+    message: "Mode session activity cannot end before it starts",
+    path: ["lastAt"],
+  });
+export type ModeSessionActivity = z.infer<typeof ModeSessionActivitySchema>;
+
+const ModeSessionSummaryBaseSchema = z.object({
+  id: z.string().min(1),
+  conversationId: z.string().min(1),
+  mode: ModeSessionModeSchema,
+  sourceStartedAt: z.number().int().nonnegative(),
+  firstIncludedAt: z.number().int().nonnegative().nullable(),
+  firstIncludedMessageId: z.string().min(1).nullable(),
+  lastActivityAt: z.number().int().nonnegative(),
+  lastOwnedMessageId: z.string().min(1).nullable(),
+  revision: z.number().int().positive(),
+});
+
+/** Durable lifecycle summary for one conversation-owned presentation run. */
+export const ModeSessionSummarySchema = z
+  .discriminatedUnion("status", [
+    ModeSessionSummaryBaseSchema.extend({
+      status: z.literal("active"),
+      endedAt: z.null(),
+      endReason: z.null(),
+    }),
+    ModeSessionSummaryBaseSchema.extend({
+      status: z.literal("completed"),
+      endedAt: z.number().int().nonnegative(),
+      endReason: z.string().min(1),
+    }),
+    ModeSessionSummaryBaseSchema.extend({
+      status: z.literal("interrupted"),
+      endedAt: z.number().int().nonnegative().nullable(),
+      endReason: z.string().min(1),
+    }),
+  ])
+  .superRefine((summary, ctx) => {
+    if (
+      (summary.firstIncludedAt === null) !==
+      (summary.firstIncludedMessageId === null)
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        message: "First included time and message ID must be set together",
+      });
+    }
+    if (summary.endedAt !== null && summary.endedAt < summary.lastActivityAt) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Mode session end cannot precede its last activity",
+        path: ["endedAt"],
+      });
+    }
+    if (summary.lastActivityAt < summary.sourceStartedAt) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Last activity cannot precede source start",
+        path: ["lastActivityAt"],
+      });
+    }
+    if (
+      summary.firstIncludedAt !== null &&
+      summary.firstIncludedAt > summary.lastActivityAt
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        message: "First included time cannot follow last activity",
+        path: ["firstIncludedAt"],
+      });
+    }
+  });
+export type ModeSessionSummary = z.infer<typeof ModeSessionSummarySchema>;
+
+export const ModeSessionRuntimeStateSchema = z.enum(["waiting", "finishing"]);
+export type ModeSessionRuntimeState = z.infer<
+  typeof ModeSessionRuntimeStateSchema
+>;
+
+/** Durable lifecycle truth plus optional process-local presentation state. */
+export const ModeSessionDescriptorSchema = z
+  .object({
+    summary: ModeSessionSummarySchema,
+    runtimeState: ModeSessionRuntimeStateSchema.optional(),
+  })
+  .superRefine((descriptor, ctx) => {
+    if (
+      descriptor.runtimeState !== undefined &&
+      descriptor.summary.status !== "active"
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Only active mode sessions can expose runtime state",
+        path: ["runtimeState"],
+      });
+    }
+  });
+export type ModeSessionDescriptor = z.infer<typeof ModeSessionDescriptorSchema>;

package/src/api/remember-tool.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+/**
+ * The `remember` tool's input: what the daemon parses a call with, and what a
+ * client reads a recorded call's input with. `content` is one fact or a list
+ * of them. `finish_turn` yields the turn only when it is `true`; any other
+ * value reads as absent. Unknown keys, such as the injected `activity`, pass
+ * through.
+ */
+export const RememberInputSchema = z.looseObject({
+  content: z.union([z.string(), z.array(z.string()).min(1)]),
+  finish_turn: z.boolean().optional().catch(undefined),
+});
+
+export type RememberInput = z.infer<typeof RememberInputSchema>;