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

package/src/api/events/question-request.ts

@@ -0,0 +1,67 @@
+/**
+ * `question_request` SSE event.
+ *
+ * Server → client prompt asking the user one or a small batch (≤5) of
+ * clarifying questions during a turn. Emitted by the question
+ * prompter when the LLM calls `ask_question` (or its batched
+ * equivalent).
+ *
+ * Resolved by a paired `interaction_resolved` event (`kind:
+ * "question"`, `state: "answered" | "cancelled" | "superseded"`) once
+ * the user submits answers, the daemon times out, or a newer user
+ * message supersedes the pending request.
+ *
+ * Wire-compat:
+ *
+ *  - `questions[]` is the canonical batched shape new clients should
+ *    consume. The whole batch is one card lifecycle on the client:
+ *    one render, one state machine, one response submission. `id` on
+ *    each entry is daemon-assigned (`q1`, `q2`, …) so the client has
+ *    a stable handle to post the user's answer against.
+ *
+ *  - The flat `question` / `description` / `options` /
+ *    `freeTextPlaceholder` fields mirror `questions[0]` for older
+ *    clients that key off the flat shape. Daemon callers that don't
+ *    supply a batch get a one-element `questions` array synthesized
+ *    from the flat fields, so both shapes are populated on every
+ *    broadcast. Once all clients consume `questions[]`, the flat
+ *    fields can be dropped (separate cleanup).
+ *
+ * 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 QuestionOptionSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+});
+
+export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
+
+export const QuestionEntrySchema = z.object({
+  id: z.string(),
+  question: z.string(),
+  description: z.string().optional(),
+  options: z.array(QuestionOptionSchema),
+  freeTextPlaceholder: z.string().optional(),
+});
+
+export type QuestionEntry = z.infer<typeof QuestionEntrySchema>;
+
+export const QuestionRequestEventSchema = z.object({
+  type: z.literal("question_request"),
+  requestId: z.string(),
+  questions: z.array(QuestionEntrySchema),
+  question: z.string(),
+  description: z.string().optional(),
+  options: z.array(QuestionOptionSchema),
+  freeTextPlaceholder: z.string().optional(),
+  conversationId: z.string().optional(),
+  toolUseId: z.string().optional(),
+});
+
+export type QuestionRequestEvent = z.infer<typeof QuestionRequestEventSchema>;

package/src/api/events/relationship-state-updated.ts

@@ -13,12 +13,10 @@
 
 import { z } from "zod";
 
-export const RelationshipStateUpdatedEventSchema = z
-  .object({
-    type: z.literal("relationship_state_updated"),
-    updatedAt: z.string(),
-  })
-  .strict();
+export const RelationshipStateUpdatedEventSchema = z.object({
+  type: z.literal("relationship_state_updated"),
+  updatedAt: z.string(),
+});
 
 export type RelationshipStateUpdatedEvent = z.infer<
   typeof RelationshipStateUpdatedEventSchema

package/src/api/events/secret-request.ts

@@ -0,0 +1,42 @@
+/**
+ * `secret_request` SSE event.
+ *
+ * Server → client prompt asking the user to supply a credential value
+ * (API key, password, etc.). Emitted by the credential prompter when
+ * a tool call needs a missing secret and the daemon delegates
+ * collection to the active client.
+ *
+ * Resolved by a paired `interaction_resolved` event (`kind: "secret"`,
+ * `state: "answered" | "cancelled"`) once the client posts the secret
+ * back via the credential-store route or cancels.
+ *
+ * `service`, `field`, and `label` are required because the prompter
+ * always supplies them — they identify which credential the daemon is
+ * asking for and how to label the input. Optional fields are scope
+ * hints (`allowedTools`, `allowedDomains`), display affordances
+ * (`description`, `placeholder`), and the `allowOneTimeSend` override
+ * used by clients that support a "send without saving" path.
+ *
+ * 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 SecretRequestEventSchema = z.object({
+  type: z.literal("secret_request"),
+  requestId: z.string(),
+  service: z.string(),
+  field: z.string(),
+  label: z.string(),
+  description: z.string().optional(),
+  placeholder: z.string().optional(),
+  conversationId: z.string().optional(),
+  purpose: z.string().optional(),
+  allowedTools: z.array(z.string()).optional(),
+  allowedDomains: z.array(z.string()).optional(),
+  allowOneTimeSend: z.boolean().optional(),
+});
+
+export type SecretRequestEvent = z.infer<typeof SecretRequestEventSchema>;

package/src/api/events/subagent-event.ts

@@ -0,0 +1,79 @@
+/**
+ * `subagent_event` SSE event.
+ *
+ * Server → client envelope wrapping any inner `ServerMessage`
+ * emitted by a subagent's conversation. The daemon's subagent
+ * manager rebroadcasts the subagent's own stream through the
+ * parent conversation's `sendToClient`, tagged with the subagent's
+ * id and the parent's `conversationId`. Clients use this envelope
+ * to route inner events to the appropriate inline subagent surface.
+ *
+ * The inner `event` is opaque on the wire — it is itself a fully
+ * structured `ServerMessage` (any member of the canonical event
+ * union) and re-validating it here would duplicate work and
+ * tightly couple subagent canonicalization to every other event
+ * schema. Clients re-parse `event` through the same event parser
+ * they use for top-level stream events. The canonical contract
+ * requires only that `event.type` exists.
+ *
+ * `conversationId` IS present on this event — unlike `spawned` /
+ * `status_changed`, the daemon explicitly stamps it with the
+ * parent conversation id at the envelope layer
+ * (`subagent/manager.ts: wrappedSendToClient`).
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+/**
+ * Inner event payload wrapped by `subagent_event`. Modeled as a
+ * passthrough envelope keyed on `type` plus a curated set of
+ * convenience fields that client surfaces (timeline, status badge,
+ * inline cards) read directly without re-parsing the inner event
+ * through the top-level event parser.
+ *
+ * The full canonical shape of any inner event is whatever the
+ * top-level `AssistantEventSchema` says it is for that `type`;
+ * extra fields pass through untouched. The fields below are not
+ * required by the wire contract — they are hints for downstream
+ * clients to avoid drilling into discriminated unions for common
+ * read paths.
+ */
+export const SubagentInnerEventSchema = z
+  .object({
+    type: z.string(),
+    content: z.string().optional(),
+    /** `assistant_text_delta` events carry text in `text`, not `content`. */
+    text: z.string().optional(),
+    /** `tool_result` events carry output in `result`, not `content`. */
+    result: z.string().optional(),
+    /** `tool_use_start` events carry a JSON object with tool arguments. */
+    input: z.record(z.string(), z.unknown()).optional(),
+    toolName: z.string().optional(),
+    isError: z.boolean().optional(),
+    /**
+     * Tool-use block ID for client-side correlation. Present on
+     * `tool_use_start` and `tool_result` envelopes; used to pair a
+     * result with its originating call when a subagent emits parallel
+     * calls to the same tool (e.g. two `bash` calls) which `toolName`
+     * alone cannot disambiguate.
+     */
+    toolUseId: z.string().optional(),
+  })
+  .passthrough();
+
+export type SubagentInnerEvent = z.infer<typeof SubagentInnerEventSchema>;
+
+export const SubagentEventEventSchema = z
+  .object({
+    type: z.literal("subagent_event"),
+    conversationId: z.string(),
+    subagentId: z.string(),
+    event: SubagentInnerEventSchema,
+  })
+  .strict();
+
+export type SubagentEventEvent = z.infer<typeof SubagentEventEventSchema>;

package/src/api/events/subagent-spawned.ts

@@ -0,0 +1,40 @@
+/**
+ * `subagent_spawned` SSE event.
+ *
+ * Server → client notification that a new subagent has been spawned
+ * by the parent conversation. Carries identity (`subagentId`),
+ * scoping (`parentConversationId`), human-readable display fields
+ * (`label`, `objective`), and optional spawn-context (`isFork`,
+ * `parentToolUseId` for tool-use anchoring).
+ *
+ * NOTE: no `conversationId` field. Subagent lifecycle events route
+ * to the parent conversation's SSE stream via the parent's
+ * `sendToClient` closure (`parentSendToClient`), not via the
+ * conversation-scoped seq stamping path. The parent conversation is
+ * identified explicitly by `parentConversationId`.
+ *
+ * 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 SubagentSpawnedEventSchema = z
+  .object({
+    type: z.literal("subagent_spawned"),
+    subagentId: z.string(),
+    parentConversationId: z.string(),
+    label: z.string(),
+    objective: z.string(),
+    isFork: z.boolean().optional(),
+    /**
+     * Tool-use id of the `skill_execute` call that spawned this subagent.
+     * Lets the client anchor the inline subagent card to the exact spawn
+     * tool call, independent of the (reconcile-volatile) parent message id.
+     */
+    parentToolUseId: z.string().optional(),
+  })
+  .strict();
+
+export type SubagentSpawnedEvent = z.infer<typeof SubagentSpawnedEventSchema>;

package/src/api/events/subagent-status-changed.ts

@@ -0,0 +1,65 @@
+/**
+ * `subagent_status_changed` SSE event.
+ *
+ * Server → client notification that a subagent's status has
+ * transitioned. Carries `subagentId`, the new `status`, an optional
+ * `error` message (typically present when transitioning into
+ * `failed`), and an optional rolling `usage` snapshot.
+ *
+ * NOTE: no `conversationId` field. Like `subagent_spawned`, status
+ * transitions route to the parent conversation's SSE stream via
+ * `parentSendToClient` closure, not via conversation-scoped seq
+ * stamping. The subagent is identified by `subagentId`; clients
+ * already know the parent association from the prior `spawned` event.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+/**
+ * Subagent lifecycle status. Mirrors `SubagentStatus` in
+ * `assistant/src/subagent/types.ts`. `aborted` is a terminal state
+ * reached via explicit `subagent_abort` request.
+ */
+export const SubagentStatusSchema = z.enum([
+  "pending",
+  "running",
+  "awaiting_input",
+  "completed",
+  "failed",
+  "aborted",
+]);
+
+export type SubagentStatus = z.infer<typeof SubagentStatusSchema>;
+
+/**
+ * Rolling usage snapshot for a subagent. Field names mirror the
+ * daemon's `UsageStats` interface (`shared.ts`) — in particular,
+ * `estimatedCost` is the canonical wire field, not `totalCost`.
+ */
+export const SubagentUsageStatsSchema = z
+  .object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    estimatedCost: z.number(),
+  })
+  .strict();
+
+export type SubagentUsageStats = z.infer<typeof SubagentUsageStatsSchema>;
+
+export const SubagentStatusChangedEventSchema = z
+  .object({
+    type: z.literal("subagent_status_changed"),
+    subagentId: z.string(),
+    status: SubagentStatusSchema,
+    error: z.string().optional(),
+    usage: SubagentUsageStatsSchema.optional(),
+  })
+  .strict();
+
+export type SubagentStatusChangedEvent = z.infer<
+  typeof SubagentStatusChangedEventSchema
+>;

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

@@ -0,0 +1,29 @@
+/**
+ * `sync_changed` SSE event.
+ *
+ * The generic multi-client cache-invalidation contract. The daemon
+ * broadcasts it after a persisted-state write succeeds; `tags` name
+ * which cached resources are now stale (not their new values) so each
+ * client refetches the affected endpoints. This is a global broadcast —
+ * it carries no `conversationId`.
+ *
+ * `originClientId` is the opaque identifier of the client whose mutation
+ * triggered the emission, when known. Consumers may use it to suppress
+ * self-echoes (the originating tab already applied the change
+ * optimistically). It is absent for daemon-internal emissions (agent
+ * loop, FS watcher, schedules).
+ *
+ * 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 SyncChangedEventSchema = z.object({
+  type: z.literal("sync_changed"),
+  tags: z.array(z.string().min(1)).min(1),
+  originClientId: z.string().min(1).optional(),
+});
+
+export type SyncChangedEvent = z.infer<typeof SyncChangedEventSchema>;

package/src/api/events/tool-output-chunk.ts

@@ -0,0 +1,45 @@
+/**
+ * `tool_output_chunk` SSE event.
+ *
+ * Streamed by the daemon's agent loop while a tool runs, carrying
+ * incremental output (e.g. a bash command's stdout). The `subType` and
+ * `subTool*` fields describe nested sub-tool activity for tools that
+ * themselves orchestrate other tools, so clients can render sub-steps
+ * within the parent tool's output.
+ *
+ * `messageId` is the database row id of the assistant message that owns
+ * the parent tool_use block; absent on streams produced by older daemons
+ * that pre-date the anchor protocol. Same semantics as
+ * `AssistantTextDeltaEvent.messageId`.
+ *
+ * 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 ToolOutputChunkSubTypeSchema = z.enum([
+  "tool_start",
+  "tool_complete",
+  "status",
+]);
+
+export type ToolOutputChunkSubType = z.infer<
+  typeof ToolOutputChunkSubTypeSchema
+>;
+
+export const ToolOutputChunkEventSchema = z.object({
+  type: z.literal("tool_output_chunk"),
+  chunk: z.string(),
+  conversationId: z.string().optional(),
+  toolUseId: z.string().optional(),
+  subType: ToolOutputChunkSubTypeSchema.optional(),
+  subToolName: z.string().optional(),
+  subToolInput: z.string().optional(),
+  subToolIsError: z.boolean().optional(),
+  subToolId: z.string().optional(),
+  messageId: z.string().optional(),
+});
+
+export type ToolOutputChunkEvent = z.infer<typeof ToolOutputChunkEventSchema>;

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

@@ -0,0 +1,129 @@
+/**
+ * `tool_result` SSE event.
+ *
+ * Emitted by the daemon's agent loop when a tool invocation finishes —
+ * carries the textual result, optional risk metadata for trust-rule
+ * evaluation, and correlation ids for the conversation, the message,
+ * and the tool_use block.
+ *
+ * The three risk-option arrays are distinct contracts:
+ *  - `riskAllowlistOptions` — Minimatch-glob save-path patterns; what
+ *    the rule editor's "Apply to" radio group persists as a trust
+ *    rule's `pattern`. Mirrors `ConfirmationRequestEvent.allowlistOptions`.
+ *  - `riskScopeOptions` — display-only ladder whose `pattern` is
+ *    regex-flavored and NOT a valid trust rule pattern; clients must
+ *    not feed it into the save path. Shape differs from the canonical
+ *    `ScopeOption` (`{ pattern, label }` vs `{ label, scope }`), so it
+ *    has its own schema here.
+ *  - `riskDirectoryScopeOptions` — directory scope ladder for the rule
+ *    editor modal.
+ *
+ * `activityMetadata` is structured live activity for rich client
+ * rendering (web_search / web_fetch); clients that key off `result`
+ * continue to work unchanged.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+import {
+  AllowlistOptionSchema,
+  ConfirmationDiffSchema,
+  DirectoryScopeOptionSchema,
+} from "./confirmation-request.js";
+
+export const RiskScopeOptionSchema = z.object({
+  pattern: z.string(),
+  label: z.string(),
+});
+
+export type RiskScopeOption = z.infer<typeof RiskScopeOptionSchema>;
+
+export const WebSearchProviderIdSchema = z.enum([
+  "anthropic-native",
+  "brave",
+  "perplexity",
+  "tavily",
+]);
+
+export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
+
+export const WebSearchResultItemSchema = z.object({
+  rank: z.number(),
+  title: z.string(),
+  url: z.string(),
+  domain: z.string(),
+  faviconUrl: z.string().optional(),
+  snippet: z.string().optional(),
+  age: z.string().optional(),
+  score: z.number().optional(),
+});
+
+export type WebSearchResultItem = z.infer<typeof WebSearchResultItemSchema>;
+
+export const WebSearchMetadataSchema = z.object({
+  query: z.string(),
+  provider: WebSearchProviderIdSchema,
+  resultCount: z.number(),
+  durationMs: z.number(),
+  results: z.array(WebSearchResultItemSchema),
+  errorMessage: z.string().optional(),
+});
+
+export type WebSearchMetadata = z.infer<typeof WebSearchMetadataSchema>;
+
+export const WebFetchMetadataSchema = z.object({
+  url: z.string(),
+  finalUrl: z.string(),
+  status: z.number(),
+  contentType: z.string().optional(),
+  byteCount: z.number(),
+  charCount: z.number(),
+  truncated: z.boolean(),
+  title: z.string().optional(),
+  domain: z.string(),
+  faviconUrl: z.string().optional(),
+  redirectCount: z.number(),
+  durationMs: z.number(),
+  errorMessage: z.string().optional(),
+  mayRequireJavaScript: z.boolean().optional(),
+});
+
+export type WebFetchMetadata = z.infer<typeof WebFetchMetadataSchema>;
+
+export const ToolActivityMetadataSchema = z.object({
+  webSearch: WebSearchMetadataSchema.optional(),
+  webFetch: WebFetchMetadataSchema.optional(),
+});
+
+export type ToolActivityMetadata = z.infer<typeof ToolActivityMetadataSchema>;
+
+export const ToolResultEventSchema = z.object({
+  type: z.literal("tool_result"),
+  toolName: z.string(),
+  result: z.string(),
+  isError: z.boolean().optional(),
+  diff: ConfirmationDiffSchema.optional(),
+  status: z.string().optional(),
+  conversationId: z.string().optional(),
+  imageData: z.string().optional(),
+  imageDataList: z.array(z.string()).optional(),
+  toolUseId: z.string().optional(),
+  messageId: z.string().optional(),
+  riskLevel: z.string().optional(),
+  riskReason: z.string().optional(),
+  matchedTrustRuleId: z.string().optional(),
+  isContainerized: z.boolean().optional(),
+  riskScopeOptions: z.array(RiskScopeOptionSchema).optional(),
+  riskAllowlistOptions: z.array(AllowlistOptionSchema).optional(),
+  riskDirectoryScopeOptions: z.array(DirectoryScopeOptionSchema).optional(),
+  approvalMode: z.string().optional(),
+  approvalReason: z.string().optional(),
+  riskThreshold: z.string().optional(),
+  activityMetadata: ToolActivityMetadataSchema.optional(),
+});
+
+export type ToolResultEvent = z.infer<typeof ToolResultEventSchema>;

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

@@ -0,0 +1,32 @@
+/**
+ * `tool_use_preview_start` SSE event.
+ *
+ * Emitted by the daemon's agent loop the moment a tool_use block is
+ * recognized in the model stream, before its input has finished
+ * streaming. Clients use it to render a tool affordance optimistically;
+ * the structured input arrives later via `tool_input_delta` and the
+ * invocation proper via `tool_use_start`.
+ *
+ * `messageId` is the database row id of the assistant message that owns
+ * this tool_use block; absent on streams produced by older daemons that
+ * pre-date the anchor protocol. Same semantics as
+ * `AssistantTextDeltaEvent.messageId`.
+ *
+ * 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 ToolUsePreviewStartEventSchema = z.object({
+  type: z.literal("tool_use_preview_start"),
+  toolUseId: z.string(),
+  toolName: z.string(),
+  conversationId: z.string().optional(),
+  messageId: z.string().optional(),
+});
+
+export type ToolUsePreviewStartEvent = z.infer<
+  typeof ToolUsePreviewStartEventSchema
+>;

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

@@ -18,15 +18,13 @@
 
 import { z } from "zod";
 
-export const ToolUseStartEventSchema = z
-  .object({
-    type: z.literal("tool_use_start"),
-    toolName: z.string(),
-    input: z.record(z.string(), z.unknown()),
-    toolUseId: z.string().optional(),
-    messageId: z.string().optional(),
-    conversationId: z.string().optional(),
-  })
-  .strict();
+export const ToolUseStartEventSchema = z.object({
+  type: z.literal("tool_use_start"),
+  toolName: z.string(),
+  input: z.record(z.string(), z.unknown()),
+  toolUseId: z.string().optional(),
+  messageId: z.string().optional(),
+  conversationId: z.string().optional(),
+});
 
 export type ToolUseStartEvent = z.infer<typeof ToolUseStartEventSchema>;

package/src/api/events/trace-event.ts

@@ -0,0 +1,69 @@
+/**
+ * `trace_event` SSE event.
+ *
+ * Diagnostic timeline event emitted by the daemon's `TraceEmitter` as a
+ * request moves through its lifecycle (received, queued, LLM calls, tool
+ * invocations, completion). Each event carries a monotonic per-conversation
+ * `sequence` so clients can reconstruct order even when timestamps collide,
+ * plus optional structured `attributes` (e.g. token counts, latency, tool
+ * name). The daemon normalizes every attribute value to a primitive, so the
+ * value type is the `string | number | boolean | null` union below.
+ *
+ * `kind` and `status` are strict enums because the daemon emits a fixed,
+ * known set and clients switch on them (icons, metrics, group status).
+ *
+ * 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 TraceEventKindSchema = z.enum([
+  "request_received",
+  "request_queued",
+  "request_dequeued",
+  "llm_call_started",
+  "llm_call_finished",
+  "assistant_message",
+  "tool_started",
+  "tool_permission_requested",
+  "tool_permission_decided",
+  "tool_finished",
+  "tool_failed",
+  "generation_handoff",
+  "message_complete",
+  "generation_cancelled",
+  "request_error",
+  "tool_profiling_summary",
+]);
+
+export type TraceEventKind = z.infer<typeof TraceEventKindSchema>;
+
+export const TraceEventStatusSchema = z.enum([
+  "info",
+  "success",
+  "warning",
+  "error",
+]);
+
+export type TraceEventStatus = z.infer<typeof TraceEventStatusSchema>;
+
+export const TraceEventSchema = z.object({
+  type: z.literal("trace_event"),
+  eventId: z.string(),
+  conversationId: z.string(),
+  requestId: z.string().optional(),
+  timestampMs: z.number(),
+  sequence: z.number(),
+  kind: TraceEventKindSchema,
+  status: TraceEventStatusSchema.optional(),
+  summary: z.string(),
+  attributes: z
+    .record(
+      z.string(),
+      z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    )
+    .optional(),
+});
+
+export type TraceEvent = z.infer<typeof TraceEventSchema>;

package/src/api/events/turn-profile-auto-routed.ts

@@ -0,0 +1,28 @@
+/**
+ * `turn_profile_auto_routed` SSE event.
+ *
+ * Emitted when the query-complexity auto-router selects a non-default
+ * inference profile for the current turn. Clients render a subtle
+ * inline notification (e.g. "Using Quality for this response"). Only
+ * fires when the router picks a profile — not when the user explicitly
+ * pinned one.
+ *
+ * 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 TurnProfileAutoRoutedEventSchema = z.object({
+  type: z.literal("turn_profile_auto_routed"),
+  conversationId: z.string(),
+  /** Profile key (e.g. "quality-optimized"). */
+  profile: z.string(),
+  /** Human-readable label (e.g. "Quality"). */
+  profileLabel: z.string(),
+});
+
+export type TurnProfileAutoRoutedEvent = z.infer<
+  typeof TurnProfileAutoRoutedEventSchema
+>;