@hachej/boring-agent 0.1.34 → 0.1.35

package/README.md

@@ -285,7 +285,7 @@ A: Yes. Use the `CatalogDeps` pattern to build tools that bind to `Workspace` an
 A: It lets the agent programmatically open files, panels, and surfaces in the workbench. The agent calls `exec_ui({ kind: "openFile", params: { path: "src/index.ts" } })` and the panel opens. It's a typed pubsub bus between backend and frontend.
 
 **Q: How does stream resumption work?**  
-A: The server wraps the harness's event stream in a per-turn ring buffer. Disconnected clients reconnect via `GET /api/v1/agent/chat/:sessionId/:turnId?cursor=<n>`. If the turn completed, it replays from `SessionStore`.
+A: The server wraps the harness's event stream in a per-turn ring buffer. Disconnected clients reconnect via `GET /api/v1/agent/pi-chat/:sessionId/events?from=<seq>`; the replay buffer serves missed events.
 
 ---
 

package/dist/{DebugDrawer-PX2PHXJH.js → DebugDrawer-2PUDZ2RL.js}

@@ -1,6 +1,6 @@
 import {
   DebugDrawer
-} from "./chunk-UTUXVT2K.js";
+} from "./chunk-IUJ22EFB.js";
 export {
   DebugDrawer
 };

package/dist/{agentPluginEvents-CF0BGY4D.d.ts → agentPluginEvents-CAMp363h.d.ts}

@@ -1,3 +1,101 @@
+import { b as SessionStore } from './session-BRovhe0D.js';
+
+interface TelemetrySink {
+    capture(event: TelemetryEvent): void | Promise<void>;
+    flush?(): void | Promise<void>;
+}
+interface TelemetryEvent {
+    name: string;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+}
+declare const noopTelemetry: TelemetrySink;
+declare function safeCapture(telemetry: TelemetrySink, event: TelemetryEvent): void;
+
+type JSONSchema = Record<string, unknown>;
+type ToolReadinessRequirement = 'workspace-fs' | 'sandbox-exec' | 'ui-bridge' | 'runtime-dependencies' | `runtime:${string}`;
+interface AgentTool {
+    name: string;
+    description: string;
+    /** Optional one-line prompt entry. Pi-built tools should preserve pi's snippet verbatim. */
+    promptSnippet?: string;
+    readinessRequirements?: ToolReadinessRequirement[];
+    parameters: JSONSchema;
+    execute(params: Record<string, unknown>, ctx: ToolExecContext): Promise<ToolResult>;
+}
+interface ToolExecContext {
+    abortSignal: AbortSignal;
+    toolCallId: string;
+    onUpdate?: (partial: string) => void;
+    /** Agent chat/session id executing this tool, when known. */
+    sessionId?: string;
+}
+interface ToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+    details?: unknown;
+}
+
+interface AgentHarnessFactoryInput {
+    tools: AgentTool[];
+    /** Host/storage cwd used for harness-owned filesystem resources. */
+    cwd: string;
+    /** Agent-visible cwd used by Pi/system prompt/session metadata. */
+    runtimeCwd?: string;
+    systemPromptAppend?: string;
+    sessionNamespace?: string;
+    sessionDir?: string;
+    /**
+     * Optional dynamic system-prompt source. Harness calls it whenever it
+     * builds or rebuilds a session prompt and appends the returned string.
+     * Workspace plugin layer wires this so live-reloaded plugins can contribute
+     * prompt context without a workspace-injected harness extension.
+     */
+    systemPromptDynamic?: () => string | undefined | Promise<string | undefined>;
+    /** Host-provided telemetry sink. Optional and best-effort; harnesses may ignore it. */
+    telemetry?: TelemetrySink;
+}
+type AgentHarnessFactory = (input: AgentHarnessFactoryInput) => AgentHarness | Promise<AgentHarness>;
+interface AgentHarness {
+    readonly id: string;
+    readonly placement: 'server' | 'browser';
+    /** Session lifecycle; may delegate to an underlying runtime (e.g. pi's JSONL). */
+    sessions: SessionStore;
+    /**
+     * Resolved system prompt currently in effect for `sessionId`. Returns
+     * `undefined` when the underlying runtime hasn't yet instantiated a
+     * session (typical pre-first-turn state — pi creates lazily on the first
+     * prompt). Optional so non-pi harnesses can opt out cleanly.
+     */
+    getSystemPrompt?: (sessionId: string) => string | undefined;
+    /** Reload native agent resources/extensions for an existing session. */
+    reloadSession?: (sessionId: string) => Promise<boolean>;
+}
+interface MessageAttachment {
+    filename?: string;
+    mediaType?: string;
+    /** data: URL (base64) or remote URL */
+    url: string;
+}
+interface SendMessageInput {
+    sessionId: string;
+    message: string;
+    thinkingLevel?: 'off' | 'low' | 'medium' | 'high';
+    model?: {
+        provider: string;
+        id: string;
+    };
+    attachments?: MessageAttachment[];
+}
+interface RunContext {
+    abortSignal: AbortSignal;
+    workdir: string;
+    userId?: string;
+}
+
 interface WorkspaceRuntimeContext {
     /** Agent-visible working directory shared by file-tree and shell execution. */
     readonly runtimeCwd: string;
@@ -297,4 +395,4 @@ interface PluginRestartWarning {
     message: string;
 }
 
-export { type Entry as E, type FileSearch as F, type IsolatedCodeInput as I, type PluginRestartWarning as P, type Sandbox as S, type Workspace as W, type ExecOptions as a, type ExecResult as b, type IsolatedCodeOutput as c, type SandboxCapability as d, type SandboxHandleRecord as e, type SandboxHandleStore as f, type Stat as g, WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT as h, type WorkspaceRuntimeContext as i };
+export { type AgentTool as A, type Entry as E, type FileSearch as F, type IsolatedCodeInput as I, type JSONSchema as J, type PluginRestartWarning as P, type RunContext as R, type Sandbox as S, type TelemetryEvent as T, type Workspace as W, type AgentHarness as a, type ExecOptions as b, type ExecResult as c, type IsolatedCodeOutput as d, type SandboxCapability as e, type SandboxHandleRecord as f, type SandboxHandleStore as g, type SendMessageInput as h, type Stat as i, type TelemetrySink as j, type ToolExecContext as k, type ToolResult as l, WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT as m, type WorkspaceRuntimeContext as n, noopTelemetry as o, type AgentHarnessFactory as p, type AgentHarnessFactoryInput as q, safeCapture as s };

package/dist/{chunk-UTUXVT2K.js → chunk-IUJ22EFB.js}

@@ -74,7 +74,7 @@ function CopyButton({ value, label }) {
 function DebugValue({ label, value }) {
   return /* @__PURE__ */ jsxs("div", { className: "rounded-md border border-border/40 bg-muted/20 p-2", children: [
     /* @__PURE__ */ jsxs("div", { className: "mb-1 flex items-center justify-between gap-2", children: [
-      /* @__PURE__ */ jsx("span", { className: "text-[10px] font-medium uppercase tracking-[0.16em] text-muted-foreground/80", children: label }),
+      /* @__PURE__ */ jsx("span", { className: "text-[10px] font-medium uppercase tracking-[0.16em] text-muted-foreground", children: label }),
       /* @__PURE__ */ jsx(CopyButton, { value, label: `Copy ${label}` })
     ] }),
     /* @__PURE__ */ jsx("code", { className: "block break-all font-mono text-[11px] leading-relaxed text-foreground dark:text-zinc-100", children: value })
@@ -86,7 +86,7 @@ function SessionTab({ sessionId }) {
     /* @__PURE__ */ jsx("p", { className: "text-muted-foreground dark:text-zinc-300", children: "This web chat is backed by a pi session. Use the id below from the workspace root to resume the same conversation in a terminal." }),
     /* @__PURE__ */ jsx(DebugValue, { label: "Pi session id", value: sessionId }),
     /* @__PURE__ */ jsx(DebugValue, { label: "Resume command", value: resumeCommand }),
-    /* @__PURE__ */ jsxs("p", { className: "rounded-md border border-border/30 bg-muted/10 p-2 text-[10px] leading-relaxed text-muted-foreground/75 dark:text-zinc-300", children: [
+    /* @__PURE__ */ jsxs("p", { className: "rounded-md border border-border/30 bg-muted/10 p-2 text-[10px] leading-relaxed text-muted-foreground dark:text-zinc-300", children: [
       "Tip: ",
       /* @__PURE__ */ jsx("code", { className: "font-mono text-foreground/80", children: "pi --continue" }),
       " ",
@@ -97,8 +97,11 @@ function SessionTab({ sessionId }) {
 var RETRY_DELAY_MS = 2500;
 var MAX_RETRIES = 20;
 function SystemPromptTab({
+  apiBaseUrl,
+  fetch: fetchImpl,
   sessionId,
-  requestHeaders
+  requestHeaders,
+  storageScope
 }) {
   const [state, setState] = useState({ kind: "loading" });
   const [retryKey, setRetryKey] = useState(0);
@@ -111,8 +114,10 @@ function SystemPromptTab({
     let aborted = false;
     let retryTimer = null;
     setState({ kind: "loading" });
-    const opts = requestHeaders ? { headers: requestHeaders } : void 0;
-    fetch(`/api/v1/agent/sessions/${encodeURIComponent(sessionId)}/system-prompt`, opts).then(async (res) => {
+    const nextFetch = fetchImpl ?? globalThis.fetch.bind(globalThis);
+    nextFetch(agentResourceUrl(apiBaseUrl, `/api/v1/agent/sessions/${encodeURIComponent(sessionId)}/system-prompt`), {
+      headers: scopedHeaders(requestHeaders, storageScope)
+    }).then(async (res) => {
       if (aborted) return;
       if (res.ok) {
         const payload2 = await res.json();
@@ -142,7 +147,7 @@ function SystemPromptTab({
       aborted = true;
       if (retryTimer) clearTimeout(retryTimer);
     };
-  }, [sessionId, requestHeaders, retryKey]);
+  }, [apiBaseUrl, fetchImpl, sessionId, requestHeaders, retryKey, storageScope]);
   return /* @__PURE__ */ jsxs("div", { className: "flex flex-col h-full min-h-0", children: [
     /* @__PURE__ */ jsxs("div", { className: "shrink-0 flex items-center justify-between px-3 pt-2 pb-1 border-b border-border/40", children: [
       /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/80 font-mono", children: state.kind === "ok" ? `${state.text.length.toLocaleString()} chars` : state.kind === "loading" ? "loading\u2026" : state.kind === "empty" ? `waiting for session \xB7 retry ${retryCount.current}/${MAX_RETRIES}` : "error" }),
@@ -265,7 +270,7 @@ var TABS = [
 ];
 var MIN_WIDTH = 280;
 var MAX_WIDTH = 800;
-function DebugDrawer({ sessionId, messages, requestHeaders, width, onWidthChange }) {
+function DebugDrawer({ apiBaseUrl, fetch, sessionId, messages, requestHeaders, storageScope, width, onWidthChange }) {
   const [tab, setTab] = useState("session");
   const onDragStart = useCallback((e) => {
     e.preventDefault();
@@ -310,13 +315,24 @@ function DebugDrawer({ sessionId, messages, requestHeaders, width, onWidthChange
             id
           )) }) }),
           /* @__PURE__ */ jsx(TabsContent, { value: "session", forceMount: true, className: "flex flex-col flex-1 min-h-0 overflow-hidden data-[state=inactive]:hidden", children: /* @__PURE__ */ jsx(SessionTab, { sessionId }) }),
-          /* @__PURE__ */ jsx(TabsContent, { value: "prompt", forceMount: true, className: "flex flex-col flex-1 min-h-0 overflow-hidden data-[state=inactive]:hidden", children: /* @__PURE__ */ jsx(SystemPromptTab, { sessionId, requestHeaders }) }),
+          /* @__PURE__ */ jsx(TabsContent, { value: "prompt", forceMount: true, className: "flex flex-col flex-1 min-h-0 overflow-hidden data-[state=inactive]:hidden", children: /* @__PURE__ */ jsx(SystemPromptTab, { apiBaseUrl, fetch, sessionId, requestHeaders, storageScope }) }),
           /* @__PURE__ */ jsx(TabsContent, { value: "messages", forceMount: true, className: "flex flex-col flex-1 min-h-0 overflow-hidden data-[state=inactive]:hidden", children: /* @__PURE__ */ jsx(MessagesTab, { messages }) })
         ] })
       }
     )
   ] });
 }
+function agentResourceUrl(apiBaseUrl, path) {
+  const base = apiBaseUrl?.replace(/\/$/, "") ?? "";
+  return `${base}${path}`;
+}
+function scopedHeaders(headers, storageScope) {
+  if (!headers && !storageScope) return void 0;
+  const result = { ...headers ?? {} };
+  const hasStorageScope = Object.keys(result).some((key) => key.toLowerCase() === "x-boring-storage-scope");
+  if (storageScope && !hasStorageScope) result["x-boring-storage-scope"] = storageScope;
+  return result;
+}
 
 export {
   cn,

package/dist/chunk-NZN2PRET.js

@@ -0,0 +1,6 @@
+// src/shared/agentPluginEvents.ts
+var WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT = "boring-ui:agent-plugins-reloaded";
+
+export {
+  WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT
+};

package/dist/chunk-VQ7VSSSX.js

@@ -0,0 +1,369 @@
+// src/shared/tool-ui.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isToolUiMetadata(value) {
+  if (!isRecord(value)) return false;
+  return (value.rendererId === void 0 || typeof value.rendererId === "string") && (value.displayGroup === void 0 || typeof value.displayGroup === "string") && (value.icon === void 0 || typeof value.icon === "string");
+}
+function sanitizeToolUiMetadata(value) {
+  if (!isToolUiMetadata(value)) return void 0;
+  const rendererId = value.rendererId?.trim();
+  const displayGroup = value.displayGroup?.trim();
+  const icon = value.icon?.trim();
+  return {
+    ...rendererId ? { rendererId } : {},
+    ...displayGroup ? { displayGroup } : {},
+    ...icon ? { icon } : {},
+    ...value.details !== void 0 ? { details: value.details } : {}
+  };
+}
+function extractToolUiMetadata(output) {
+  if (!isRecord(output)) return void 0;
+  const details = output.details;
+  if (!isRecord(details)) return void 0;
+  return sanitizeToolUiMetadata(details.ui);
+}
+
+// src/shared/error-codes.ts
+import { z } from "zod";
+var ErrorCode = z.enum([
+  // Auth / config
+  "MISSING_API_KEY",
+  "INVALID_API_KEY",
+  "OIDC_REFRESH_FAILED",
+  "VERCEL_AUTH_FAILED",
+  "CONFIG_INVALID",
+  // Workspace / path
+  "PATH_ESCAPE",
+  "PATH_ABSOLUTE",
+  "PATH_NULL_BYTE",
+  "PATH_SYMLINK_ESCAPE",
+  "PATH_NOT_FOUND",
+  "PATH_NOT_WRITABLE",
+  "WORKSPACE_UNINITIALIZED",
+  "WORKSPACE_NOT_READY",
+  // Agent runtime / provisioning
+  "AGENT_RUNTIME_NOT_READY",
+  "RUNTIME_PROVISIONING_FAILED",
+  "RUNTIME_PROVISIONING_LOCKED",
+  // Sandbox / exec
+  "BWRAP_UNAVAILABLE",
+  "BWRAP_TIMEOUT",
+  "OUTPUT_TRUNCATED",
+  "SANDBOX_NOT_READY",
+  "SANDBOX_EXPIRED",
+  "VERCEL_API_ERROR",
+  "CIRCUIT_OPEN",
+  "ABORTED",
+  // Session / bridge
+  "SESSION_NOT_FOUND",
+  "SESSION_LOCKED",
+  "STREAM_BUFFER_EVICTED",
+  "CURSOR_OUT_OF_RANGE",
+  "BRIDGE_COMMAND_INVALID",
+  // Tool
+  "TOOL_NOT_FOUND",
+  "TOOL_INVALID_INPUT",
+  "TOOL_EXECUTION_ERROR",
+  // Plugin
+  "PLUGIN_LOAD_FAILED",
+  "PLUGIN_NAME_COLLISION",
+  "PLUGIN_RUNTIME_REVISION_MISMATCH",
+  "PLUGIN_RUNTIME_PRIVATE_FILE",
+  "PLUGIN_RUNTIME_UNSAFE_IMPORT",
+  "PLUGIN_RUNTIME_TRANSFORM_FAILED",
+  "RUNTIME_PLUGIN_NOT_FOUND",
+  "RUNTIME_PLUGIN_ROUTE_NOT_FOUND",
+  "RUNTIME_PLUGIN_HANDLER_FAILED",
+  "RUNTIME_PLUGIN_LOAD_FAILED",
+  "RUNTIME_PLUGIN_RESPONSE_UNSUPPORTED",
+  // Runtime provisioning
+  "PROVISIONING_LAYOUT_FAILED",
+  "PROVISIONING_SKILLS_FAILED",
+  "PROVISIONING_TEMPLATES_FAILED",
+  "PROVISIONING_NODE_PREFLIGHT_FAILED",
+  "PROVISIONING_NPM_INSTALL_FAILED",
+  "PROVISIONING_UV_BOOTSTRAP_FAILED",
+  "PROVISIONING_UV_INSTALL_FAILED",
+  "PROVISIONING_ARTIFACT_FAILED",
+  // Internal
+  "INTERNAL_ERROR"
+]);
+var ERROR_CODES = ErrorCode.options;
+var ApiErrorPayloadSchema = z.object({
+  code: ErrorCode,
+  message: z.string().min(1),
+  details: z.record(z.unknown()).optional()
+});
+var ApiErrorResponseSchema = z.object({
+  error: ApiErrorPayloadSchema
+});
+var ErrorLogFieldsSchema = z.object({
+  level: z.enum(["warn", "error"]),
+  code: ErrorCode,
+  prefix: z.string().min(1),
+  msg: z.string().min(1)
+}).catchall(z.unknown());
+
+// src/shared/chat/piChatSchemas.ts
+import { z as z2 } from "zod";
+var nonEmptyString = z2.string().min(1);
+var seqNumber = z2.number().int().nonnegative();
+var ShallowPayloadSchema = z2.union([
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null(),
+  z2.array(z2.unknown()),
+  z2.record(z2.unknown())
+]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ToolUiMetadataSchema = z2.object({
+  rendererId: z2.string().optional(),
+  displayGroup: z2.string().optional(),
+  icon: z2.string().optional(),
+  details: z2.unknown().optional()
+});
+function sanitizeToolUiMetadata2(value) {
+  if (!isRecord2(value)) return void 0;
+  const parsed = ToolUiMetadataSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+var OptionalToolUiMetadataSchema = z2.preprocess(
+  (value) => sanitizeToolUiMetadata2(value),
+  ToolUiMetadataSchema.optional()
+);
+var ChatErrorSchema = z2.object({
+  code: ErrorCode,
+  message: nonEmptyString,
+  retryable: z2.boolean().optional(),
+  details: z2.unknown().optional()
+});
+var BoringChatPartSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("text"), id: z2.string().optional(), text: z2.string() }),
+  z2.object({
+    type: z2.literal("reasoning"),
+    id: nonEmptyString,
+    text: z2.string(),
+    state: z2.enum(["streaming", "done"]).optional()
+  }),
+  z2.object({
+    type: z2.literal("tool-call"),
+    id: nonEmptyString,
+    toolName: nonEmptyString,
+    input: z2.unknown().optional(),
+    state: z2.enum(["input-streaming", "input-available", "output-available", "output-error", "aborted"]),
+    output: z2.unknown().optional(),
+    errorText: z2.string().optional(),
+    ui: OptionalToolUiMetadataSchema
+  }),
+  z2.object({
+    type: z2.literal("file"),
+    id: z2.string().optional(),
+    filename: z2.string().optional(),
+    mediaType: z2.string().optional(),
+    url: z2.string().optional()
+  }),
+  z2.object({
+    type: z2.literal("notice"),
+    id: z2.string().optional(),
+    level: z2.enum(["info", "warning", "error"]),
+    text: z2.string()
+  })
+]);
+var BoringChatMessageSchema = z2.object({
+  id: nonEmptyString,
+  role: z2.enum(["user", "assistant", "system"]),
+  status: z2.enum(["pending", "streaming", "done", "aborted", "error"]).optional(),
+  parts: z2.array(BoringChatPartSchema),
+  createdAt: z2.string().optional(),
+  clientNonce: z2.string().optional(),
+  clientSeq: z2.number().int().nonnegative().optional(),
+  piEntryId: z2.string().optional(),
+  turnId: z2.string().optional()
+});
+var QueuedUserMessageSchema = z2.object({
+  id: nonEmptyString,
+  kind: z2.literal("followup"),
+  clientNonce: z2.string().optional(),
+  clientSeq: z2.number().int().nonnegative().optional(),
+  displayText: z2.string(),
+  createdAt: z2.string().optional()
+});
+var PiChatStatusSchema = z2.enum(["idle", "hydrating", "submitted", "streaming", "aborting", "error"]);
+var PiChatSnapshotSchema = z2.object({
+  protocolVersion: z2.literal(1),
+  sessionId: nonEmptyString,
+  seq: seqNumber,
+  status: PiChatStatusSchema,
+  activeTurnId: z2.string().optional(),
+  messages: z2.array(BoringChatMessageSchema),
+  queue: z2.object({ followUps: z2.array(QueuedUserMessageSchema) }),
+  followUpMode: z2.literal("one-at-a-time"),
+  error: ChatErrorSchema.optional()
+});
+var baseEvent = z2.object({ seq: seqNumber });
+var PiChatEventSchema = z2.discriminatedUnion("type", [
+  baseEvent.extend({ type: z2.literal("agent-start"), turnId: nonEmptyString }),
+  baseEvent.extend({ type: z2.literal("agent-end"), turnId: nonEmptyString, status: z2.enum(["ok", "aborted", "error"]) }),
+  baseEvent.extend({
+    type: z2.literal("message-start"),
+    messageId: nonEmptyString,
+    role: z2.enum(["user", "assistant"]),
+    clientNonce: z2.string().optional(),
+    clientSeq: z2.number().int().nonnegative().optional(),
+    createdAt: z2.string().optional(),
+    text: z2.string().optional(),
+    files: z2.array(BoringChatPartSchema).optional()
+  }),
+  baseEvent.extend({
+    type: z2.literal("message-delta"),
+    messageId: nonEmptyString,
+    partId: nonEmptyString,
+    kind: z2.enum(["text", "reasoning"]),
+    delta: z2.string()
+  }),
+  baseEvent.extend({
+    type: z2.literal("message-part-end"),
+    messageId: nonEmptyString,
+    partId: nonEmptyString,
+    kind: z2.enum(["text", "reasoning"]),
+    text: z2.string()
+  }),
+  baseEvent.extend({ type: z2.literal("message-end"), messageId: nonEmptyString, final: BoringChatMessageSchema }),
+  baseEvent.extend({
+    type: z2.literal("tool-call"),
+    messageId: nonEmptyString,
+    toolCallId: nonEmptyString,
+    toolName: nonEmptyString,
+    input: ShallowPayloadSchema,
+    ui: OptionalToolUiMetadataSchema
+  }),
+  baseEvent.extend({
+    type: z2.literal("tool-result"),
+    messageId: nonEmptyString,
+    toolCallId: nonEmptyString,
+    output: ShallowPayloadSchema,
+    isError: z2.boolean().optional(),
+    errorText: z2.string().optional(),
+    ui: OptionalToolUiMetadataSchema
+  }),
+  baseEvent.extend({ type: z2.literal("queue-updated"), queue: z2.object({ followUps: z2.array(QueuedUserMessageSchema) }) }),
+  baseEvent.extend({
+    type: z2.literal("followup-consumed"),
+    clientNonce: z2.string().optional(),
+    clientSeq: z2.number().int().nonnegative().optional(),
+    messageId: nonEmptyString
+  }),
+  baseEvent.extend({ type: z2.literal("file-changed"), path: nonEmptyString, changeType: nonEmptyString }),
+  baseEvent.extend({ type: z2.literal("ui-command"), command: ShallowPayloadSchema, displayOnly: z2.literal(true) }),
+  baseEvent.extend({ type: z2.literal("usage"), usage: ShallowPayloadSchema }),
+  baseEvent.extend({
+    type: z2.literal("auto-retry-start"),
+    attempt: z2.number().int().nonnegative(),
+    maxAttempts: z2.number().int().nonnegative(),
+    delayMs: z2.number().int().nonnegative(),
+    errorMessage: z2.string()
+  }),
+  baseEvent.extend({
+    type: z2.literal("auto-retry-end"),
+    success: z2.boolean(),
+    attempt: z2.number().int().nonnegative(),
+    finalError: z2.string().optional()
+  }),
+  baseEvent.extend({ type: z2.literal("error"), turnId: z2.string().optional(), retryable: z2.boolean().optional(), error: ChatErrorSchema })
+]);
+var PiChatHeartbeatFrameSchema = z2.object({ type: z2.literal("heartbeat"), now: z2.string() });
+var PiChatStreamFrameSchema = z2.union([PiChatEventSchema, PiChatHeartbeatFrameSchema]);
+var ChatModelSelectionSchema = z2.object({
+  provider: nonEmptyString,
+  id: nonEmptyString
+});
+var ThinkingLevelSchema = z2.enum(["off", "low", "medium", "high"]);
+var ChatAttachmentPayloadSchema = z2.object({
+  filename: z2.string().optional(),
+  mediaType: z2.string().optional(),
+  url: nonEmptyString
+});
+var PromptPayloadSchema = z2.object({
+  message: z2.string().min(1).max(1e6),
+  displayMessage: z2.string().min(1).max(1e6).optional(),
+  clientNonce: nonEmptyString.max(128),
+  model: ChatModelSelectionSchema.optional(),
+  thinkingLevel: ThinkingLevelSchema.optional(),
+  attachments: z2.array(ChatAttachmentPayloadSchema).max(20).optional()
+});
+var FollowUpPayloadSchema = z2.object({
+  message: z2.string().min(1).max(1e6),
+  displayMessage: z2.string().min(1).max(1e6).optional(),
+  clientNonce: nonEmptyString.max(128),
+  clientSeq: z2.number().int().nonnegative()
+});
+var QueueClearPayloadSchema = z2.preprocess(
+  (value) => value ?? {},
+  z2.object({
+    clientNonce: nonEmptyString.max(128).optional(),
+    clientSeq: z2.number().int().nonnegative().optional()
+  }).strict()
+);
+var InterruptPayloadSchema = z2.object({}).strict();
+var StopPayloadSchema = z2.object({}).strict();
+var CommandReceiptSchema = z2.object({
+  accepted: z2.literal(true),
+  cursor: seqNumber
+});
+var PromptReceiptSchema = CommandReceiptSchema.extend({
+  clientNonce: nonEmptyString,
+  duplicate: z2.boolean().optional()
+});
+var FollowUpReceiptSchema = CommandReceiptSchema.extend({
+  clientNonce: nonEmptyString,
+  clientSeq: z2.number().int().nonnegative(),
+  queued: z2.literal(true),
+  duplicate: z2.boolean().optional()
+});
+var QueueClearReceiptSchema = CommandReceiptSchema.extend({
+  cleared: z2.number().int().nonnegative()
+});
+var StopReceiptSchema = CommandReceiptSchema.extend({
+  stopped: z2.boolean(),
+  clearedQueue: z2.array(QueuedUserMessageSchema)
+});
+
+export {
+  isToolUiMetadata,
+  sanitizeToolUiMetadata,
+  extractToolUiMetadata,
+  ErrorCode,
+  ERROR_CODES,
+  ApiErrorPayloadSchema,
+  ApiErrorResponseSchema,
+  ErrorLogFieldsSchema,
+  ToolUiMetadataSchema,
+  sanitizeToolUiMetadata2,
+  ChatErrorSchema,
+  BoringChatPartSchema,
+  BoringChatMessageSchema,
+  QueuedUserMessageSchema,
+  PiChatStatusSchema,
+  PiChatSnapshotSchema,
+  PiChatEventSchema,
+  PiChatHeartbeatFrameSchema,
+  PiChatStreamFrameSchema,
+  ChatModelSelectionSchema,
+  ThinkingLevelSchema,
+  ChatAttachmentPayloadSchema,
+  PromptPayloadSchema,
+  FollowUpPayloadSchema,
+  QueueClearPayloadSchema,
+  InterruptPayloadSchema,
+  StopPayloadSchema,
+  CommandReceiptSchema,
+  PromptReceiptSchema,
+  FollowUpReceiptSchema,
+  QueueClearReceiptSchema,
+  StopReceiptSchema
+};