@hachej/boring-agent 0.1.111 → 0.2.0

package/dist/chunk-7XAOVFSN.js

@@ -1,28 +0,0 @@
-// src/shared/session.ts
-var SAFE_NATIVE_SESSION_ID = /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*$/;
-function compareSessionOrder(left, right) {
-  return right[0] - left[0] || compareSessionIdentity(left[1], right[1]) || compareSessionIdentity(left[2], right[2]);
-}
-function compareSessionIdentity(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-
-// src/shared/telemetry.ts
-var noopTelemetry = {
-  capture() {
-  }
-};
-function safeCapture(telemetry, event) {
-  try {
-    void Promise.resolve(telemetry.capture(event)).catch(() => {
-    });
-  } catch {
-  }
-}
-
-export {
-  SAFE_NATIVE_SESSION_ID,
-  compareSessionOrder,
-  noopTelemetry,
-  safeCapture
-};

package/dist/chunk-KJIEMSQP.js

@@ -1,198 +0,0 @@
-// src/shared/error-codes.ts
-import { z } from "zod";
-var ErrorCode = z.enum([
-  // Auth / config
-  "UNAUTHORIZED",
-  "MISSING_API_KEY",
-  "INVALID_API_KEY",
-  "OIDC_REFRESH_FAILED",
-  "VERCEL_AUTH_FAILED",
-  "BLAXEL_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_HOST_SCOPE_VIOLATION",
-  // Agent runtime / provisioning
-  "AGENT_RUNTIME_NOT_READY",
-  "AGENT_BINDING_DISPOSED",
-  "AGENT_CONTROL_RECEIPT_INVALID",
-  "AGENT_FLEET_PLUGIN_UNKNOWN",
-  "AGENT_FLEET_CONFIG_BINDING_UNKNOWN",
-  "AGENT_FLEET_MODEL_POLICY_UNCOMPILED",
-  "AGENT_FLEET_SEAT_PERSONA_INVALID",
-  "AGENT_FLEET_SEAT_SKILL_DIGEST_MISMATCH",
-  "AGENT_FLEET_SEAT_INSTRUCTIONS_PATH_UNPUBLISHABLE",
-  "AGENT_FLEET_CONFIG_FILE_INVALID",
-  "AGENT_DEFINITION_ID_CONFLICT",
-  "AGENT_DEFINITION_UNSEATED",
-  "RUNTIME_PROVISIONING_FAILED",
-  "RUNTIME_PROVISIONING_LOCKED",
-  // Sandbox / exec
-  "BWRAP_UNAVAILABLE",
-  "BWRAP_TIMEOUT",
-  "OUTPUT_TRUNCATED",
-  "SANDBOX_NOT_READY",
-  "SANDBOX_EXPIRED",
-  "VERCEL_API_ERROR",
-  "BLAXEL_API_ERROR",
-  "BLAXEL_CONFIG_DRIFT",
-  "BLAXEL_RUNTIME_UNQUALIFIED",
-  "BLAXEL_VOLUME_BUSY",
-  "REMOTE_WORKER_CONFIG_INVALID",
-  "REMOTE_WORKER_PROTOCOL_MISMATCH",
-  "REMOTE_WORKER_UNAUTHENTICATED",
-  "REMOTE_WORKER_UNAVAILABLE",
-  "REMOTE_WORKER_UNQUALIFIED",
-  "REMOTE_WORKER_REQUEST_INVALID",
-  "REMOTE_WORKER_RESPONSE_INVALID",
-  "REMOTE_WORKER_CAPABILITY_EXPIRED",
-  "REMOTE_WORKER_CAPABILITY_REPLAY",
-  "REMOTE_WORKER_CAPABILITY_NONCE_STORE_EXHAUSTED",
-  "REMOTE_WORKER_AUTHORIZED_WORKSPACE_REQUIRED",
-  "REMOTE_WORKER_BINDING_RECEIPT_INVALID",
-  "REMOTE_WORKER_SANDBOX_WORKSPACE_MISMATCH",
-  "REMOTE_WORKER_SANDBOX_NOT_FOUND",
-  "REMOTE_WORKER_SANDBOX_EXPIRED",
-  "REMOTE_WORKER_SANDBOX_DISPOSED",
-  "REMOTE_WORKER_CREATE_CONCURRENCY_EXHAUSTED",
-  "REMOTE_WORKER_EXEC_CONCURRENCY_EXHAUSTED",
-  "REMOTE_WORKER_IDEMPOTENCY_CONFLICT",
-  "REMOTE_WORKER_EXEC_IN_PROGRESS",
-  "REMOTE_WORKER_SECRET_INVOCATION_NOT_REPLAYABLE",
-  "REMOTE_WORKER_OUTCOME_UNKNOWN",
-  "REMOTE_WORKER_INCOMPLETE_CLEANUP",
-  "REMOTE_WORKER_DOCKER_COMMAND_FAILED",
-  "REMOTE_WORKER_PATH_UNSAFE",
-  "REMOTE_WORKER_ALREADY_EXISTS",
-  "REMOTE_WORKER_PATH_PRIMITIVE_UNAVAILABLE",
-  "REMOTE_WORKER_QUOTA_EXCEEDED",
-  "REMOTE_WORKER_SECRET_REFERENCE_REJECTED",
-  "REMOTE_WORKER_EXEC_ABORTED",
-  "REMOTE_WORKER_OUTPUT_LIMIT",
-  "REMOTE_WORKER_TIMEOUT",
-  "REMOTE_WORKER_STREAM_CLOSED",
-  "CIRCUIT_OPEN",
-  "ABORTED",
-  // Billing / metering
-  "PAYMENT_REQUIRED",
-  "MODEL_BUDGET_EXCEEDED",
-  "MODEL_CONTEXT_WINDOW_EXCEEDED",
-  "METERING_UNSUPPORTED_COMMAND",
-  // Session / bridge
-  "SESSION_NOT_FOUND",
-  "SESSION_LOCKED",
-  "SESSION_TRANSCRIPT_UNREADABLE",
-  "STREAM_BUFFER_EVICTED",
-  "CURSOR_OUT_OF_RANGE",
-  "BRIDGE_COMMAND_INVALID",
-  // Tool
-  "TOOL_NOT_FOUND",
-  "TOOL_INVALID_INPUT",
-  "TOOL_EXECUTION_ERROR",
-  "AUTHORED_AGENT_ID_INVALID",
-  "AUTHORED_AGENT_TYPE_MISMATCH",
-  "AUTHORED_AGENT_REFERENCE_UNSUPPORTED",
-  "AUTHORED_AGENT_TOOL_COLLISION",
-  "MCP_AGENT_ARTIFACT_INVALID",
-  "MCP_AGENT_ARTIFACT_TOO_LARGE",
-  "MCP_AGENT_ARTIFACT_UNAVAILABLE",
-  "AGENT_MCP_GRANT_REF_UNGRANTED",
-  "AGENT_MCP_GRANT_TOOL_NOT_ALLOWED",
-  "AGENT_MCP_GRANT_RECORD_MALFORMED",
-  "AGENT_MCP_GRANT_CONNECTOR_UNKNOWN",
-  "AGENT_MCP_GRANT_TOOL_NAME_INVALID",
-  // 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",
-  // Skill resources
-  "SKILL_DISCOVERY_FAILED",
-  "PACKAGE_RESOURCE_INVALID",
-  "PACKAGE_RESOURCE_CONFLICT",
-  "RUNTIME_FILESYSTEM_BINDING_DUPLICATE",
-  "RUNTIME_READONLY_FILESYSTEM_POLICY_INVALID",
-  // Lane W same-workspace share deep-link (AR1-003)
-  "AR1_SHARE_NOT_FOUND",
-  "AR1_SHARE_TOMBSTONED",
-  // Event stream durability / external channels
-  "EVENT_STORE_OPEN_FAILED",
-  "DURABLE_STREAM_UNAVAILABLE",
-  "CHANNEL_DURABLE_STREAM_REQUIRED",
-  "CHANNEL_INBOUND_ACCEPTED",
-  "CHANNEL_UNKNOWN_BINDING",
-  "CHANNEL_INBOUND_PARKED",
-  "CHANNEL_OUTBOUND_PARKED",
-  "CHANNEL_TURN_STALLED",
-  "CHANNEL_BINDING_BUSY",
-  "CHANNEL_BINDING_REVOKED",
-  "SESSION_CREATE_TIMEOUT",
-  // Internal
-  "ERR_NOT_IMPLEMENTED_UNTIL_T1",
-  "INTERNAL_ERROR"
-]);
-var ERROR_CODES = ErrorCode.options;
-var AgentDefinitionErrorCode = z.enum([
-  "AGENT_DEFINITION_INVALID",
-  "AGENT_DEFINITION_UNSUPPORTED_FIELD",
-  "AUTHORED_AGENT_REFERENCE_UNSUPPORTED"
-]);
-var AgentDeploymentErrorCode = z.enum([
-  "AGENT_DEPLOYMENT_INVALID",
-  "AGENT_DEPLOYMENT_UNSUPPORTED_FIELD"
-]);
-var AgentConsumptionErrorCode = z.enum([
-  "AGENT_CONSUMPTION_INVALID_TRANSITION",
-  "AGENT_CONSUMPTION_CYCLE_DETECTED",
-  "AGENT_CONSUMPTION_DEPTH_EXCEEDED",
-  "AGENT_CONSUMPTION_SCHEMA_MISMATCH",
-  "AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED"
-]);
-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());
-
-export {
-  ErrorCode,
-  ERROR_CODES,
-  AgentDefinitionErrorCode,
-  AgentDeploymentErrorCode,
-  AgentConsumptionErrorCode,
-  ApiErrorPayloadSchema,
-  ApiErrorResponseSchema,
-  ErrorLogFieldsSchema
-};

package/dist/chunk-KN72XWP7.js

@@ -1,394 +0,0 @@
-import {
-  ErrorCode
-} from "./chunk-KJIEMSQP.js";
-
-// 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/agentPluginEvents.ts
-var WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT = "boring-ui:agent-plugins-reloaded";
-var WORKSPACE_COMMAND_NOTIFY_EVENT = "boring-ui:command-notify";
-
-// src/shared/gateway/errors.ts
-var AgentGatewayErrorCode = {
-  AGENT_TYPE_UNKNOWN: "AGENT_TYPE_UNKNOWN",
-  AGENT_SESSION_NOT_FOUND: "AGENT_SESSION_NOT_FOUND",
-  AGENT_SCOPE_DENIED: "AGENT_SCOPE_DENIED",
-  AGENT_ENTITLEMENT_REQUIRED: "AGENT_ENTITLEMENT_REQUIRED",
-  AGENT_ACCESS_FORBIDDEN: "AGENT_ACCESS_FORBIDDEN",
-  AGENT_ACCESS_POLICY_UNAVAILABLE: "AGENT_ACCESS_POLICY_UNAVAILABLE",
-  AGENT_SESSION_REPLAY_GAP: "AGENT_SESSION_REPLAY_GAP",
-  AGENT_SESSION_CURSOR_AHEAD: "AGENT_SESSION_CURSOR_AHEAD",
-  AGENT_SESSION_CURSOR_EXPIRED: "AGENT_SESSION_CURSOR_EXPIRED",
-  AGENT_SESSION_CURSOR_INVALID: "AGENT_SESSION_CURSOR_INVALID",
-  AGENT_REQUEST_CONFLICT: "AGENT_REQUEST_CONFLICT",
-  AGENT_REQUEST_IN_PROGRESS: "AGENT_REQUEST_IN_PROGRESS",
-  AGENT_REQUEST_OUTCOME_UNKNOWN: "AGENT_REQUEST_OUTCOME_UNKNOWN",
-  AGENT_RUNTIME_RESTART_REQUIRED: "AGENT_RUNTIME_RESTART_REQUIRED",
-  AGENT_COMMAND_INVALID_STATE: "AGENT_COMMAND_INVALID_STATE",
-  AGENT_SHARED_ENVIRONMENT_UNAVAILABLE: "AGENT_SHARED_ENVIRONMENT_UNAVAILABLE",
-  AGENT_GATEWAY_CLOSED: "AGENT_GATEWAY_CLOSED"
-};
-var AGENT_GATEWAY_ERROR_CODES = [
-  AgentGatewayErrorCode.AGENT_TYPE_UNKNOWN,
-  AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND,
-  AgentGatewayErrorCode.AGENT_SCOPE_DENIED,
-  AgentGatewayErrorCode.AGENT_ENTITLEMENT_REQUIRED,
-  AgentGatewayErrorCode.AGENT_ACCESS_FORBIDDEN,
-  AgentGatewayErrorCode.AGENT_ACCESS_POLICY_UNAVAILABLE,
-  AgentGatewayErrorCode.AGENT_SESSION_REPLAY_GAP,
-  AgentGatewayErrorCode.AGENT_SESSION_CURSOR_AHEAD,
-  AgentGatewayErrorCode.AGENT_SESSION_CURSOR_EXPIRED,
-  AgentGatewayErrorCode.AGENT_SESSION_CURSOR_INVALID,
-  AgentGatewayErrorCode.AGENT_REQUEST_CONFLICT,
-  AgentGatewayErrorCode.AGENT_REQUEST_IN_PROGRESS,
-  AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
-  AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED,
-  AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
-  AgentGatewayErrorCode.AGENT_SHARED_ENVIRONMENT_UNAVAILABLE,
-  AgentGatewayErrorCode.AGENT_GATEWAY_CLOSED
-];
-var AgentGatewayError = class extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "AgentGatewayError";
-    this.code = code;
-    this.details = details;
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      ...this.details === void 0 ? {} : { details: this.details }
-    };
-  }
-};
-
-// src/shared/chat/piChatSchemas.ts
-import { z } from "zod";
-var nonEmptyString = z.string().min(1);
-var seqNumber = z.number().int().nonnegative();
-var ShallowPayloadSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null(),
-  z.array(z.unknown()),
-  z.record(z.unknown())
-]);
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var ToolUiMetadataSchema = z.object({
-  rendererId: z.string().optional(),
-  displayGroup: z.string().optional(),
-  icon: z.string().optional(),
-  details: z.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 = z.preprocess(
-  (value) => sanitizeToolUiMetadata2(value),
-  ToolUiMetadataSchema.optional()
-);
-var ChatErrorSchema = z.object({
-  code: ErrorCode,
-  message: nonEmptyString,
-  retryable: z.boolean().optional(),
-  details: z.unknown().optional()
-});
-var BoringChatPartSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("text"), id: z.string().optional(), text: z.string() }),
-  z.object({
-    type: z.literal("reasoning"),
-    id: nonEmptyString,
-    text: z.string(),
-    state: z.enum(["streaming", "done"]).optional()
-  }),
-  z.object({
-    type: z.literal("tool-call"),
-    id: nonEmptyString,
-    toolName: nonEmptyString,
-    input: z.unknown().optional(),
-    state: z.enum(["input-streaming", "input-available", "output-available", "output-error", "aborted"]),
-    output: z.unknown().optional(),
-    errorText: z.string().optional(),
-    ui: OptionalToolUiMetadataSchema
-  }),
-  z.object({
-    type: z.literal("file"),
-    id: z.string().optional(),
-    filename: z.string().optional(),
-    mediaType: z.string().optional(),
-    url: z.string().optional(),
-    path: z.string().optional(),
-    filesystem: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("notice"),
-    id: z.string().optional(),
-    level: z.enum(["info", "warning", "error"]),
-    text: z.string()
-  })
-]);
-var BoringChatMessageSchema = z.object({
-  id: nonEmptyString,
-  role: z.enum(["user", "assistant", "system"]),
-  status: z.enum(["pending", "streaming", "done", "aborted", "error"]).optional(),
-  parts: z.array(BoringChatPartSchema),
-  createdAt: z.string().optional(),
-  clientNonce: z.string().optional(),
-  clientSeq: z.number().int().nonnegative().optional(),
-  piEntryId: z.string().optional(),
-  turnId: z.string().optional()
-});
-var QueuedUserMessageSchema = z.object({
-  id: nonEmptyString,
-  kind: z.literal("followup"),
-  clientNonce: z.string().optional(),
-  clientSeq: z.number().int().nonnegative().optional(),
-  displayText: z.string(),
-  createdAt: z.string().optional()
-});
-var PiChatStatusSchema = z.enum(["idle", "hydrating", "submitted", "streaming", "aborting", "error"]);
-var ChatModelSelectionSchema = z.object({
-  provider: nonEmptyString,
-  id: nonEmptyString
-});
-var PiChatSnapshotSchema = z.object({
-  protocolVersion: z.literal(1),
-  sessionId: nonEmptyString,
-  seq: seqNumber,
-  status: PiChatStatusSchema,
-  activeTurnId: z.string().optional(),
-  currentModel: ChatModelSelectionSchema.optional(),
-  messages: z.array(BoringChatMessageSchema),
-  queue: z.object({ followUps: z.array(QueuedUserMessageSchema) }),
-  followUpMode: z.literal("one-at-a-time"),
-  error: ChatErrorSchema.optional()
-});
-var baseEvent = z.object({ seq: seqNumber });
-var PiChatEventSchema = z.discriminatedUnion("type", [
-  baseEvent.extend({ type: z.literal("agent-start"), turnId: nonEmptyString }),
-  baseEvent.extend({ type: z.literal("model-changed"), currentModel: ChatModelSelectionSchema }),
-  baseEvent.extend({ type: z.literal("agent-end"), turnId: nonEmptyString, status: z.enum(["ok", "aborted", "error"]), willRetry: z.boolean().optional() }),
-  baseEvent.extend({
-    type: z.literal("message-start"),
-    messageId: nonEmptyString,
-    role: z.enum(["user", "assistant"]),
-    clientNonce: z.string().optional(),
-    clientSeq: z.number().int().nonnegative().optional(),
-    createdAt: z.string().optional(),
-    text: z.string().optional(),
-    files: z.array(BoringChatPartSchema).optional()
-  }),
-  baseEvent.extend({
-    type: z.literal("message-delta"),
-    messageId: nonEmptyString,
-    partId: nonEmptyString,
-    kind: z.enum(["text", "reasoning"]),
-    delta: z.string()
-  }),
-  baseEvent.extend({
-    type: z.literal("message-part-end"),
-    messageId: nonEmptyString,
-    partId: nonEmptyString,
-    kind: z.enum(["text", "reasoning"]),
-    text: z.string()
-  }),
-  baseEvent.extend({ type: z.literal("message-end"), messageId: nonEmptyString, final: BoringChatMessageSchema }),
-  baseEvent.extend({
-    type: z.literal("tool-call"),
-    messageId: nonEmptyString,
-    toolCallId: nonEmptyString,
-    toolName: nonEmptyString,
-    input: ShallowPayloadSchema,
-    ui: OptionalToolUiMetadataSchema
-  }),
-  baseEvent.extend({
-    type: z.literal("tool-result"),
-    messageId: nonEmptyString,
-    toolCallId: nonEmptyString,
-    output: ShallowPayloadSchema,
-    isError: z.boolean().optional(),
-    errorText: z.string().optional(),
-    ui: OptionalToolUiMetadataSchema
-  }),
-  baseEvent.extend({ type: z.literal("queue-updated"), queue: z.object({ followUps: z.array(QueuedUserMessageSchema) }) }),
-  baseEvent.extend({
-    type: z.literal("followup-consumed"),
-    clientNonce: z.string().optional(),
-    clientSeq: z.number().int().nonnegative().optional(),
-    messageId: nonEmptyString
-  }),
-  baseEvent.extend({ type: z.literal("file-changed"), path: nonEmptyString, changeType: nonEmptyString, filesystem: nonEmptyString.optional() }),
-  baseEvent.extend({ type: z.literal("ui-command"), command: ShallowPayloadSchema, displayOnly: z.literal(true) }),
-  baseEvent.extend({ type: z.literal("usage"), usage: ShallowPayloadSchema }),
-  baseEvent.extend({
-    type: z.literal("auto-retry-start"),
-    attempt: z.number().int().nonnegative(),
-    maxAttempts: z.number().int().nonnegative(),
-    delayMs: z.number().int().nonnegative(),
-    errorMessage: z.string()
-  }),
-  baseEvent.extend({
-    type: z.literal("auto-retry-end"),
-    success: z.boolean(),
-    attempt: z.number().int().nonnegative(),
-    finalError: z.string().optional()
-  }),
-  baseEvent.extend({ type: z.literal("error"), turnId: z.string().optional(), retryable: z.boolean().optional(), error: ChatErrorSchema })
-]);
-var PiChatHeartbeatFrameSchema = z.object({ type: z.literal("heartbeat"), now: z.string() });
-var PiChatStreamFrameSchema = z.union([PiChatEventSchema, PiChatHeartbeatFrameSchema]);
-var ThinkingLevelSchema = z.enum(["off", "low", "medium", "high"]);
-var ChatAttachmentPayloadSchema = z.object({
-  filename: z.string().optional(),
-  mediaType: z.string().optional(),
-  url: nonEmptyString,
-  path: z.string().optional()
-});
-var PromptPayloadSchema = z.object({
-  message: z.string().min(1).max(1e6),
-  displayMessage: z.string().min(1).max(1e6).optional(),
-  clientNonce: nonEmptyString.max(128),
-  model: ChatModelSelectionSchema.optional(),
-  thinkingLevel: ThinkingLevelSchema.optional(),
-  attachments: z.array(ChatAttachmentPayloadSchema).max(20).optional()
-});
-var FollowUpPayloadSchema = z.object({
-  message: z.string().min(1).max(1e6),
-  displayMessage: z.string().min(1).max(1e6).optional(),
-  clientNonce: nonEmptyString.max(128),
-  clientSeq: z.number().int().nonnegative()
-});
-var QueueClearPayloadSchema = z.preprocess(
-  (value) => value ?? {},
-  z.object({
-    clientNonce: nonEmptyString.max(128).optional(),
-    clientSeq: z.number().int().nonnegative().optional()
-  }).strict()
-);
-var InterruptPayloadSchema = z.object({
-  queueAction: z.enum(["hold", "resume"]).optional()
-}).strict();
-var StopPayloadSchema = z.object({}).strict();
-var CommandReceiptSchema = z.object({
-  accepted: z.literal(true),
-  cursor: seqNumber
-});
-var PromptReceiptSchema = CommandReceiptSchema.extend({
-  clientNonce: nonEmptyString,
-  duplicate: z.boolean().optional()
-});
-var FollowUpReceiptSchema = CommandReceiptSchema.extend({
-  clientNonce: nonEmptyString,
-  clientSeq: z.number().int().nonnegative(),
-  queued: z.literal(true),
-  duplicate: z.boolean().optional()
-});
-var QueueClearReceiptSchema = CommandReceiptSchema.extend({
-  cleared: z.number().int().nonnegative()
-});
-var StopReceiptSchema = CommandReceiptSchema.extend({
-  stopped: z.boolean(),
-  clearedQueue: z.array(QueuedUserMessageSchema)
-});
-
-// src/shared/chat/modelContextError.ts
-var MODEL_CONTEXT_RECOVERY_MESSAGE = "This conversation exceeded the model context window. Compact the conversation and retry, or start a new chat with less context.";
-var CONTEXT_WINDOW_ERROR_PATTERN = /context[_ ]length[_ ]exceeded|exceeds the context window|input exceeds the context window/i;
-function errorMessage(value) {
-  if (value instanceof Error) return value.message;
-  if (typeof value === "string") return value;
-  if (typeof value !== "object" || value === null) return void 0;
-  const record = value;
-  if (typeof record.code === "string" && CONTEXT_WINDOW_ERROR_PATTERN.test(record.code)) return record.code;
-  if (typeof record.message === "string") return record.message;
-  return errorMessage(record.error);
-}
-function isModelContextWindowError(value) {
-  const message = errorMessage(value);
-  return message !== void 0 && CONTEXT_WINDOW_ERROR_PATTERN.test(message);
-}
-function chatErrorFromUnknown(value, fallbackMessage) {
-  if (isModelContextWindowError(value)) {
-    return {
-      code: ErrorCode.enum.MODEL_CONTEXT_WINDOW_EXCEEDED,
-      message: MODEL_CONTEXT_RECOVERY_MESSAGE,
-      retryable: true
-    };
-  }
-  const message = errorMessage(value);
-  return {
-    code: ErrorCode.enum.INTERNAL_ERROR,
-    message: message || fallbackMessage,
-    retryable: false
-  };
-}
-
-export {
-  isToolUiMetadata,
-  sanitizeToolUiMetadata,
-  extractToolUiMetadata,
-  WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT,
-  WORKSPACE_COMMAND_NOTIFY_EVENT,
-  AgentGatewayErrorCode,
-  AGENT_GATEWAY_ERROR_CODES,
-  AgentGatewayError,
-  isModelContextWindowError,
-  chatErrorFromUnknown,
-  ToolUiMetadataSchema,
-  sanitizeToolUiMetadata2,
-  ChatErrorSchema,
-  BoringChatPartSchema,
-  BoringChatMessageSchema,
-  QueuedUserMessageSchema,
-  PiChatStatusSchema,
-  ChatModelSelectionSchema,
-  PiChatSnapshotSchema,
-  PiChatEventSchema,
-  PiChatHeartbeatFrameSchema,
-  PiChatStreamFrameSchema,
-  ThinkingLevelSchema,
-  ChatAttachmentPayloadSchema,
-  PromptPayloadSchema,
-  FollowUpPayloadSchema,
-  QueueClearPayloadSchema,
-  InterruptPayloadSchema,
-  StopPayloadSchema,
-  CommandReceiptSchema,
-  PromptReceiptSchema,
-  FollowUpReceiptSchema,
-  QueueClearReceiptSchema,
-  StopReceiptSchema
-};