@hachej/boring-agent 0.1.64 → 0.1.65

package/dist/{agentPluginEvents-Ddn5DQ5E.d.ts → agentPluginEvents-ChUzG2Lh.d.ts}

@@ -1,134 +1,3 @@
-import { d as SessionStore } from './chatSubmitPayload-DHqQL2wD.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;
-    sessionRoot?: 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>;
-    /**
-     * Resource (skill/extension) load diagnostics for an existing session.
-     * Returns `[]` when the session has no live agent session yet. Lets the
-     * /reload route and the `plugin_diagnostics` tool surface silent
-     * skill/extension load failures back to the UI and the agent.
-     */
-    getResourceDiagnostics?: (sessionId: string) => Array<{
-        source: string;
-        message: string;
-        path?: string;
-    }>;
-    /** List slash commands registered in the agent runtime for a given session. */
-    getSlashCommands?: (sessionId: string, ctx: RunContext) => ReadonlyArray<AgentSlashCommandSummary> | Promise<ReadonlyArray<AgentSlashCommandSummary>>;
-    /**
-     * Execute a named slash command registered via `pi.registerCommand` in a
-     * plugin extension. Calls the handler in-process; the handler may dispatch
-     * UI commands (openPanel, notify) through the workspace bridge. Throws if
-     * the command is not found or the handler throws.
-     */
-    executeSlashCommand?: (sessionId: string, name: string, args: string, ctx: RunContext) => Promise<void>;
-}
-interface AgentSlashCommandSummary {
-    name: string;
-    description?: string;
-    source: 'extension' | 'prompt' | 'skill';
-    /**
-     * Name of the originating plugin/package, when derivable from Pi's
-     * sourceInfo (e.g. a `.pi/extensions/<name>` runtime plugin, or an
-     * `npm:`/`git/` package). Surfaced as a tag in the slash-command picker.
-     * Absent for built-in/top-level commands with no package origin.
-     */
-    sourcePlugin?: string;
-}
-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;
@@ -330,8 +199,8 @@ interface Sandbox {
      * The optional `onStdout` / `onStderr` callbacks (when implemented)
      * stream output incrementally as bytes arrive. When omitted,
      * implementations buffer normally and surface output via
-     * `ExecResult.stdout` / `stderr` only. See `Sandbox.exec` streaming
-     * extension under bead [Phase 1.0].
+     * `ExecResult.stdout` / `stderr` only. See the `Sandbox.exec` streaming
+     * extension added in Phase 1.0.
      */
     exec(cmd: string, opts?: ExecOptions): Promise<ExecResult>;
     /**
@@ -478,4 +347,4 @@ interface CommandNotifyPayload {
     command?: string;
 }
 
-export { type AgentTool as A, type CommandNotifyPayload as C, 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, WORKSPACE_COMMAND_NOTIFY_EVENT as n, type WorkspaceRuntimeContext as o, noopTelemetry as p, type ToolReadinessRequirement as q, type WorkspaceChangeEvent as r, safeCapture as s, type AgentHarnessFactory as t, type AgentHarnessFactoryInput as u };
+export { type CommandNotifyPayload as C, 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, WORKSPACE_COMMAND_NOTIFY_EVENT as i, type WorkspaceRuntimeContext as j, type WorkspaceChangeEvent as k };

package/dist/chatSubmitPayload-DwOHyiqR.d.ts

@@ -0,0 +1,22 @@
+type ThinkingLevel = 'off' | 'low' | 'medium' | 'high';
+interface ChatModelSelection {
+    provider: string;
+    id: string;
+}
+interface ChatAttachmentPayload {
+    filename?: string;
+    mediaType?: string;
+    url: string;
+    /** Workspace-relative path when the browser upload endpoint persisted the attachment. */
+    path?: string;
+}
+interface ChatSubmitPayload {
+    message: string;
+    displayMessage?: string;
+    clientNonce: string;
+    model?: ChatModelSelection;
+    thinkingLevel?: ThinkingLevel;
+    attachments?: ChatAttachmentPayload[];
+}
+
+export type { ChatSubmitPayload as C, ThinkingLevel as T, ChatAttachmentPayload as a, ChatModelSelection as b };

package/dist/chunk-4LXA7OOV.js

@@ -0,0 +1,290 @@
+import {
+  ErrorCode
+} from "./chunk-XZKU7FBV.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/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 PiChatSnapshotSchema = z.object({
+  protocolVersion: z.literal(1),
+  sessionId: nonEmptyString,
+  seq: seqNumber,
+  status: PiChatStatusSchema,
+  activeTurnId: z.string().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("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 }),
+  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 ChatModelSelectionSchema = z.object({
+  provider: nonEmptyString,
+  id: nonEmptyString
+});
+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({}).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)
+});
+
+export {
+  isToolUiMetadata,
+  sanitizeToolUiMetadata,
+  extractToolUiMetadata,
+  ToolUiMetadataSchema,
+  sanitizeToolUiMetadata2,
+  ChatErrorSchema,
+  BoringChatPartSchema,
+  BoringChatMessageSchema,
+  QueuedUserMessageSchema,
+  PiChatStatusSchema,
+  PiChatSnapshotSchema,
+  PiChatEventSchema,
+  PiChatHeartbeatFrameSchema,
+  PiChatStreamFrameSchema,
+  ChatModelSelectionSchema,
+  ThinkingLevelSchema,
+  ChatAttachmentPayloadSchema,
+  PromptPayloadSchema,
+  FollowUpPayloadSchema,
+  QueueClearPayloadSchema,
+  InterruptPayloadSchema,
+  StopPayloadSchema,
+  CommandReceiptSchema,
+  PromptReceiptSchema,
+  FollowUpReceiptSchema,
+  QueueClearReceiptSchema,
+  StopReceiptSchema
+};

package/dist/chunk-AJZHR626.js

@@ -0,0 +1,85 @@
+// src/server/logging.ts
+var SENSITIVE_KEYS = new Set([
+  "apiKey",
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "authorization",
+  "cookie",
+  "oidcToken",
+  "accessToken",
+  "refreshToken",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "VERCEL_OIDC_TOKEN",
+  "VERCEL_TEAM_ID"
+].map((key) => key.toLowerCase()));
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(key.toLowerCase());
+}
+function redactValue(key, value, seen) {
+  if (key && isSensitiveKey(key) && value != null) return "***";
+  if (value == null || typeof value !== "object") return value;
+  if (value instanceof Date) return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = value.map((item) => redactValue(void 0, item, seen));
+    seen.delete(value);
+    return out2;
+  }
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactValue(childKey, childValue, seen);
+  }
+  seen.delete(value);
+  return out;
+}
+function redact(fields) {
+  const out = {};
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (const [k, v] of Object.entries(fields)) {
+    out[k] = redactValue(k, v, seen);
+  }
+  return out;
+}
+function isVerbose() {
+  return typeof process !== "undefined" && process.env?.BORING_AGENT_VERBOSE === "1";
+}
+function createLogger(prefix) {
+  function emit(level, msg, fields) {
+    const entry = {
+      level,
+      prefix,
+      msg,
+      ...fields ? redact(fields) : {},
+      t: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (level === "error") {
+      console.error(JSON.stringify(entry));
+    } else if (level === "warn") {
+      console.warn(JSON.stringify(entry));
+    } else {
+      console.log(JSON.stringify(entry));
+    }
+  }
+  return {
+    debug(msg, fields) {
+      if (isVerbose()) emit("debug", msg, fields);
+    },
+    info(msg, fields) {
+      emit("info", msg, fields);
+    },
+    warn(msg, fields) {
+      emit("warn", msg, fields);
+    },
+    error(msg, fields) {
+      emit("error", msg, fields);
+    }
+  };
+}
+
+export {
+  createLogger
+};

package/dist/chunk-AQBXNPMD.js

@@ -0,0 +1,17 @@
+// src/shared/telemetry.ts
+var noopTelemetry = {
+  capture() {
+  }
+};
+function safeCapture(telemetry, event) {
+  try {
+    void Promise.resolve(telemetry.capture(event)).catch(() => {
+    });
+  } catch {
+  }
+}
+
+export {
+  noopTelemetry,
+  safeCapture
+};