@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/api/events/disk-pressure-status-changed.ts

@@ -0,0 +1,61 @@
+/**
+ * `disk_pressure_status_changed` SSE event.
+ *
+ * Global broadcast pushed when the daemon's disk-pressure snapshot
+ * changes. Mirrors the REST `GET /disk-pressure` status shape so the
+ * client's monitor can apply stream updates and polled fetches through
+ * the same code path. Carries no `conversationId` — it is workspace-wide.
+ *
+ * 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 DiskPressureStateSchema = z.enum([
+  "disabled",
+  "ok",
+  "warning",
+  "critical",
+  "unknown",
+]);
+
+export type DiskPressureState = z.infer<typeof DiskPressureStateSchema>;
+
+export const DiskPressureBlockedCapabilitySchema = z.enum([
+  "agent-turns",
+  "background-work",
+  "remote-ingress",
+]);
+
+export type DiskPressureBlockedCapability = z.infer<
+  typeof DiskPressureBlockedCapabilitySchema
+>;
+
+export const DiskPressureStatusSchema = z.object({
+  enabled: z.boolean(),
+  state: DiskPressureStateSchema,
+  locked: z.boolean(),
+  acknowledged: z.boolean(),
+  overrideActive: z.boolean(),
+  effectivelyLocked: z.boolean(),
+  lockId: z.string().nullable(),
+  usagePercent: z.number().nullable(),
+  thresholdPercent: z.number(),
+  path: z.string().nullable(),
+  lastCheckedAt: z.string().nullable(),
+  blockedCapabilities: z.array(DiskPressureBlockedCapabilitySchema),
+  error: z.string().nullable(),
+});
+
+export type DiskPressureStatus = z.infer<typeof DiskPressureStatusSchema>;
+
+export const DiskPressureStatusChangedEventSchema = z.object({
+  type: z.literal("disk_pressure_status_changed"),
+  status: DiskPressureStatusSchema,
+});
+
+export type DiskPressureStatusChangedEvent = z.infer<
+  typeof DiskPressureStatusChangedEventSchema
+>;

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

@@ -13,35 +13,31 @@
 
 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();
+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(),
+});
 
-export const DocumentCommentCreatedEventSchema = z
-  .object({
-    type: z.literal("document_comment_created"),
-    conversationId: z.string(),
-    surfaceId: z.string(),
-    comment: DocumentCommentSchema,
-  })
-  .strict();
+export const DocumentCommentCreatedEventSchema = z.object({
+  type: z.literal("document_comment_created"),
+  conversationId: z.string(),
+  surfaceId: z.string(),
+  comment: DocumentCommentSchema,
+});
 
 export type DocumentCommentCreatedEvent = z.infer<
   typeof DocumentCommentCreatedEventSchema

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

@@ -10,14 +10,12 @@
 
 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 const DocumentCommentDeletedEventSchema = z.object({
+  type: z.literal("document_comment_deleted"),
+  conversationId: z.string(),
+  surfaceId: z.string(),
+  commentId: z.string(),
+});
 
 export type DocumentCommentDeletedEvent = z.infer<
   typeof DocumentCommentDeletedEventSchema

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

@@ -11,14 +11,12 @@
 
 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 const DocumentCommentReopenedEventSchema = z.object({
+  type: z.literal("document_comment_reopened"),
+  conversationId: z.string(),
+  surfaceId: z.string(),
+  commentId: z.string(),
+});
 
 export type DocumentCommentReopenedEvent = z.infer<
   typeof DocumentCommentReopenedEventSchema

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

@@ -11,16 +11,14 @@
 
 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 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(),
+});
 
 export type DocumentCommentResolvedEvent = z.infer<
   typeof DocumentCommentResolvedEventSchema

package/src/api/events/document-editor-update.ts

@@ -0,0 +1,27 @@
+/**
+ * `document_editor_update` SSE event.
+ *
+ * Emitted by the document tool to push new markdown into the client's
+ * built-in rich-text editor for an open document surface. Used in place
+ * of `document_editor_show` when the surface is already open, so the
+ * client replaces content in place instead of reopening (which would
+ * clobber unsaved edits).
+ *
+ * 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 DocumentEditorUpdateEventSchema = z.object({
+  type: z.literal("document_editor_update"),
+  conversationId: z.string(),
+  surfaceId: z.string(),
+  markdown: z.string(),
+  mode: z.string(),
+});
+
+export type DocumentEditorUpdateEvent = z.infer<
+  typeof DocumentEditorUpdateEventSchema
+>;

package/src/api/events/error.ts

@@ -0,0 +1,32 @@
+/**
+ * `error` SSE event.
+ *
+ * Terminal error for an assistant turn — emitted when generation fails
+ * before a `message_complete`. Carries a human-readable `message` plus
+ * optional machine-readable classification (`code`, `errorCategory`)
+ * the client uses to pick contextual recovery UI, and `requestId` /
+ * `conversationId` correlation ids.
+ *
+ * `message` is required: the daemon's emit sites always populate it.
+ * `category` is a coarse contextual hint (e.g. `secret_blocked` →
+ * "Send Anyway"); `errorCategory` is the finer machine-readable
+ * classification used by billing/credit recovery banners.
+ *
+ * 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 ErrorEventSchema = z.object({
+  type: z.literal("error"),
+  message: z.string(),
+  code: z.string().optional(),
+  category: z.string().optional(),
+  errorCategory: z.string().optional(),
+  requestId: z.string().optional(),
+  conversationId: z.string().optional(),
+});
+
+export type ErrorEvent = z.infer<typeof ErrorEventSchema>;

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

@@ -12,12 +12,10 @@
 
 import { z } from "zod";
 
-export const GenerationCancelledEventSchema = z
-  .object({
-    type: z.literal("generation_cancelled"),
-    conversationId: z.string().optional(),
-  })
-  .strict();
+export const GenerationCancelledEventSchema = z.object({
+  type: z.literal("generation_cancelled"),
+  conversationId: z.string().optional(),
+});
 
 export type GenerationCancelledEvent = z.infer<
   typeof GenerationCancelledEventSchema

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

@@ -20,21 +20,19 @@ import { z } from "zod";
 
 import { AssistantOutboundAttachmentSchema } from "./assistant-outbound-attachment.js";
 
-export const GenerationHandoffEventSchema = z
-  .object({
-    type: z.literal("generation_handoff"),
-    conversationId: z.string().optional(),
-    /** Daemon request id of the just-finished turn — correlates with
-     *  the request id surfaced by the inbound user message. */
-    requestId: z.string().optional(),
-    /** Depth of the pending-message queue at handoff time. */
-    queuedCount: z.number(),
-    /** Database row id of the just-finished assistant turn. */
-    messageId: z.string().optional(),
-    attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
-    attachmentWarnings: z.array(z.string()).optional(),
-  })
-  .strict();
+export const GenerationHandoffEventSchema = z.object({
+  type: z.literal("generation_handoff"),
+  conversationId: z.string().optional(),
+  /** Daemon request id of the just-finished turn — correlates with
+   *  the request id surfaced by the inbound user message. */
+  requestId: z.string().optional(),
+  /** Depth of the pending-message queue at handoff time. */
+  queuedCount: z.number(),
+  /** Database row id of the just-finished assistant turn. */
+  messageId: z.string().optional(),
+  attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
+  attachmentWarnings: z.array(z.string()).optional(),
+});
 
 export type GenerationHandoffEvent = z.infer<
   typeof GenerationHandoffEventSchema

package/src/api/events/home-feed-updated.ts

@@ -0,0 +1,26 @@
+/**
+ * `home_feed_updated` SSE event.
+ *
+ * Emitted after a successful write to the home feed journal — clients
+ * invalidate their cached feed view and refetch. Skipped when the
+ * underlying write fails.
+ *
+ * Global event (no `conversationId`): the home feed is per-user, not
+ * per-conversation, and the daemon fans this out across every active
+ * client of the user.
+ *
+ * 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 HomeFeedUpdatedEventSchema = z.object({
+  type: z.literal("home_feed_updated"),
+  /** ISO-8601 timestamp of when the feed was written. */
+  updatedAt: z.string(),
+  /** Count of items with `status === "new"` after this write. */
+  newItemCount: z.number(),
+});
+
+export type HomeFeedUpdatedEvent = z.infer<typeof HomeFeedUpdatedEventSchema>;

package/src/api/events/identity-changed.ts

@@ -0,0 +1,32 @@
+/**
+ * `identity_changed` SSE event.
+ *
+ * Broadcast when `IDENTITY.md` changes on disk. Clients refresh their cached
+ * identity view; the fields here are the new authoritative identity, so a
+ * client could apply them directly without a follow-up GET.
+ *
+ * Global event (no `conversationId`): identity is per-user, not
+ * per-conversation, and the daemon fans this out across every active
+ * client of the user.
+ *
+ * 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 IdentityChangedEventSchema = z.object({
+  type: z.literal("identity_changed"),
+  /** Updated assistant name. */
+  name: z.string(),
+  /** Updated role / job description. */
+  role: z.string(),
+  /** Updated personality description. */
+  personality: z.string(),
+  /** Updated emoji glyph. */
+  emoji: z.string(),
+  /** Updated home / origin description. */
+  home: z.string(),
+});
+
+export type IdentityChangedEvent = z.infer<typeof IdentityChangedEventSchema>;

package/src/api/events/interaction-resolved.ts

@@ -0,0 +1,50 @@
+/**
+ * `interaction_resolved` SSE event.
+ *
+ * Broadcast when a pending interaction (confirmation, secret, question,
+ * host-proxy request) transitions to a resolved state. Clients use this
+ * to drop attention / processing indicators without polling.
+ *
+ * `state` is the lifecycle outcome:
+ *  - `approved` / `rejected` — user-facing confirmation outcome
+ *  - `answered` — question / secret responded to
+ *  - `cancelled` — runtime-side termination (timeout, abort, dispose,
+ *    prompter shutdown)
+ *  - `superseded` — invalidated by a newer event (auto-deny on enqueue,
+ *    fresh user message arriving while a confirmation was outstanding).
+ *
+ * `kind` is the interaction category (`"confirmation"`, `"secret"`,
+ * `"question"`, `"host_bash"`, …) — kept loose (`string`) on the wire
+ * because the daemon emits it directly from the pending-interaction
+ * map without enum narrowing. Web-side narrowing happens at the
+ * attention-tracking allowlist boundary.
+ *
+ * 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 InteractionResolutionStateSchema = z.enum([
+  "approved",
+  "rejected",
+  "answered",
+  "cancelled",
+  "superseded",
+]);
+
+export type InteractionResolutionState = z.infer<
+  typeof InteractionResolutionStateSchema
+>;
+
+export const InteractionResolvedEventSchema = z.object({
+  type: z.literal("interaction_resolved"),
+  requestId: z.string(),
+  conversationId: z.string(),
+  state: InteractionResolutionStateSchema,
+  kind: z.string(),
+});
+
+export type InteractionResolvedEvent = z.infer<
+  typeof InteractionResolvedEventSchema
+>;

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

@@ -26,17 +26,15 @@ import { z } from "zod";
 
 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(),
-    source: z.enum(["main", "aux"]).optional(),
-    attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
-    /** Soft warnings produced while resolving attachments (e.g. format
-     *  conversions, size truncations). Display-only — not blocking. */
-    attachmentWarnings: z.array(z.string()).optional(),
-  })
-  .strict();
+export const MessageCompleteEventSchema = z.object({
+  type: z.literal("message_complete"),
+  messageId: z.string().optional(),
+  conversationId: z.string().optional(),
+  source: z.enum(["main", "aux"]).optional(),
+  attachments: z.array(AssistantOutboundAttachmentSchema).optional(),
+  /** Soft warnings produced while resolving attachments (e.g. format
+   *  conversions, size truncations). Display-only — not blocking. */
+  attachmentWarnings: z.array(z.string()).optional(),
+});
 
 export type MessageCompleteEvent = z.infer<typeof MessageCompleteEventSchema>;

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

@@ -0,0 +1,21 @@
+/**
+ * `message_dequeued` SSE event.
+ *
+ * Emitted when a previously-queued user message is removed from the
+ * per-conversation request queue because the runtime is about to start
+ * a turn for it. Pairs with the prior `message_queued` for the same
+ * `requestId`. Clients clear the pending indicator.
+ *
+ * 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 MessageDequeuedEventSchema = z.object({
+  type: z.literal("message_dequeued"),
+  conversationId: z.string(),
+  requestId: z.string(),
+});
+
+export type MessageDequeuedEvent = z.infer<typeof MessageDequeuedEventSchema>;

package/src/api/events/message-queued-deleted.ts

@@ -0,0 +1,23 @@
+/**
+ * `message_queued_deleted` SSE event.
+ *
+ * Emitted when a queued user message is discarded before it ever runs
+ * (e.g. the user cancels it from the queue UI). Clients drop the
+ * pending indicator for `requestId`. Distinct from `message_dequeued`,
+ * which signals normal promotion into a running turn.
+ *
+ * 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 MessageQueuedDeletedEventSchema = z.object({
+  type: z.literal("message_queued_deleted"),
+  conversationId: z.string(),
+  requestId: z.string(),
+});
+
+export type MessageQueuedDeletedEvent = z.infer<
+  typeof MessageQueuedDeletedEventSchema
+>;

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

@@ -0,0 +1,22 @@
+/**
+ * `message_queued` SSE event.
+ *
+ * Emitted when a user message is accepted while an assistant turn is
+ * still streaming, and the runtime holds it in the per-conversation
+ * request queue rather than starting a new turn. Clients render a
+ * pending indicator and use `position` to order multiple queued items.
+ *
+ * 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 MessageQueuedEventSchema = z.object({
+  type: z.literal("message_queued"),
+  conversationId: z.string(),
+  requestId: z.string(),
+  position: z.number(),
+});
+
+export type MessageQueuedEvent = z.infer<typeof MessageQueuedEventSchema>;

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

@@ -0,0 +1,29 @@
+/**
+ * `message_request_complete` SSE event.
+ *
+ * Request-level terminal signal for a user message lifecycle: the
+ * runtime has finished handling this `requestId`. Unlike
+ * `message_complete`, this does not imply the active assistant turn
+ * has completed — it is used for paths that consume a request inline
+ * while a separate in-flight turn may still be running.
+ *
+ * `runStillActive` is `true` when an existing turn is still running
+ * after this request is finalized. Clients gate any "request settled"
+ * UX on this flag rather than assuming the turn is done.
+ *
+ * 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 MessageRequestCompleteEventSchema = z.object({
+  type: z.literal("message_request_complete"),
+  conversationId: z.string(),
+  requestId: z.string(),
+  runStillActive: z.boolean().optional(),
+});
+
+export type MessageRequestCompleteEvent = z.infer<
+  typeof MessageRequestCompleteEventSchema
+>;

package/src/api/events/navigate-settings.ts

@@ -0,0 +1,20 @@
+/**
+ * `navigate_settings` SSE event.
+ *
+ * Emitted by the settings navigation tool so the client opens its
+ * settings UI to the named tab. The daemon validates `tab` against the
+ * known settings tabs before emitting; the client maps it to a route.
+ *
+ * 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 NavigateSettingsEventSchema = z.object({
+  type: z.literal("navigate_settings"),
+  tab: z.string(),
+});
+
+export type NavigateSettingsEvent = z.infer<typeof NavigateSettingsEventSchema>;

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

@@ -0,0 +1,33 @@
+/**
+ * `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.
+ *
+ * `silent` tells the client not to post the intent to the OS
+ * notification surface (non-banner side effects still run); the server
+ * sets it from the signal's urgency. `deepLinkMetadata` carries the
+ * navigation target the client routes to on tap.
+ *
+ * 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 NotificationIntentEventSchema = z.object({
+  type: z.literal("notification_intent"),
+  sourceEventName: z.string(),
+  title: z.string(),
+  body: z.string(),
+  deliveryId: z.string().optional(),
+  deepLinkMetadata: z.record(z.string(), z.unknown()).optional(),
+  targetGuardianPrincipalId: z.string().optional(),
+  silent: z.boolean().optional(),
+});
+
+export type NotificationIntentEvent = z.infer<
+  typeof NotificationIntentEventSchema
+>;

package/src/api/events/open-url.ts

@@ -18,13 +18,11 @@
 
 import { z } from "zod";
 
-export const OpenUrlEventSchema = z
-  .object({
-    type: z.literal("open_url"),
-    url: z.string().min(1),
-    title: z.string().optional(),
-    conversationId: z.string().optional(),
-  })
-  .strict();
+export const OpenUrlEventSchema = z.object({
+  type: z.literal("open_url"),
+  url: z.string().min(1),
+  title: z.string().optional(),
+  conversationId: z.string().optional(),
+});
 
 export type OpenUrlEvent = z.infer<typeof OpenUrlEventSchema>;