@hachej/boring-agent 0.1.63 → 0.1.65

package/dist/harness-DN9KdrT7.d.ts

@@ -0,0 +1,265 @@
+import { S as SessionCtx, P as PiChatEvent, a as SessionStore } from './piChatEvent-B6Lg9ft-.js';
+import { AgentSessionEvent, PromptOptions } from '@mariozechner/pi-coding-agent';
+
+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;
+    /** Authenticated human user executing this tool, when known. */
+    userId?: string;
+    userEmail?: string;
+    userEmailVerified?: boolean;
+    workspaceId?: string;
+    requestId?: string;
+}
+interface ToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+    details?: unknown;
+}
+
+declare const AGENT_NOT_IMPLEMENTED_UNTIL_T1: "ERR_NOT_IMPLEMENTED_UNTIL_T1";
+interface MessageAttachment {
+    filename?: string;
+    mediaType?: string;
+    /** data: URL or remote URL */
+    url: string;
+}
+interface AgentActor {
+    id?: string;
+    name?: string;
+}
+interface AgentMessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+type AgentMessageContent = string | AgentMessagePart[];
+interface AgentSendInput {
+    sessionId?: string;
+    content?: AgentMessageContent;
+    /** @deprecated Use content. Present for the P1 SendMessageInput rename window. */
+    message?: string;
+    attachments?: MessageAttachment[];
+    actor?: AgentActor;
+    ctx?: SessionCtx;
+    originSurface?: string;
+    thinkingLevel?: 'off' | 'low' | 'medium' | 'high';
+    model?: {
+        provider: string;
+        id: string;
+    };
+}
+interface AgentStartReceipt {
+    sessionId: string;
+    startIndex: number;
+}
+interface AgentStreamOptions {
+    startIndex: number;
+    ctx?: SessionCtx;
+}
+interface AgentEvent {
+    v: 1;
+    eventIndex: number;
+    timestamp: number;
+    sessionId: string;
+    chunk: PiChatEvent;
+}
+declare function sessionStreamPath(sessionId: string): string;
+interface AgentResolveInputResponse {
+    approved?: boolean;
+    content?: string;
+    value?: unknown;
+}
+interface AgentRuntimeAdapter {
+    readonly id: string;
+    dispose?(): void | Promise<void>;
+}
+interface AgentReadinessStatus {
+    key: string;
+    ready: boolean;
+    message?: string;
+}
+interface AgentReadiness {
+    requirements: string[];
+    status(): Promise<AgentReadinessStatus[]>;
+}
+interface AgentConfig {
+    harnessFactory?: AgentCoreHarnessFactory;
+    runtime: AgentRuntimeAdapter | 'none';
+    tools?: AgentTool[];
+    readinessRequirements?: string[];
+    sessions?: SessionStore;
+    systemPromptAppend?: string;
+    systemPromptDynamic?: () => string | undefined | Promise<string | undefined>;
+    telemetry?: TelemetrySink;
+    metering?: unknown;
+    sessionStorageRoot?: string;
+    workdir?: string;
+}
+interface Agent {
+    start(input: AgentSendInput): Promise<AgentStartReceipt>;
+    stream(sessionId: string, options: AgentStreamOptions): AsyncIterable<AgentEvent>;
+    send(input: AgentSendInput): AsyncIterable<AgentEvent>;
+    resolveInput(sessionId: string, requestId: string, response: AgentResolveInputResponse): Promise<never>;
+    interrupt(sessionId: string, ctx?: SessionCtx): Promise<unknown>;
+    stop(sessionId: string, ctx?: SessionCtx): Promise<unknown>;
+    sessions: SessionStore;
+    readiness: AgentReadiness;
+    dispose(): Promise<void>;
+}
+declare class AgentNotImplementedError extends Error {
+    readonly code: "ERR_NOT_IMPLEMENTED_UNTIL_T1";
+    constructor(message?: string);
+}
+
+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 AgentCoreSessionSnapshot {
+    state: unknown;
+    messages: readonly unknown[];
+    isStreaming: boolean;
+    isRetrying: boolean;
+    retryAttempt: number;
+    pendingMessageCount: number;
+    steeringMessages: readonly string[];
+    followUpMessages: readonly string[];
+    followUpMode: 'all' | 'one-at-a-time';
+    sessionId: string;
+    sessionName?: string;
+}
+type AgentCorePromptInput = string | {
+    text: string;
+    options?: PromptOptions;
+};
+interface AgentCoreSessionAdapter {
+    readSnapshot(): AgentCoreSessionSnapshot;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+    prompt(input: AgentCorePromptInput): Promise<void>;
+    followUp(text: string, options?: never): Promise<void>;
+    clearFollowUp(options?: never): void;
+    abort(): Promise<void>;
+    abortRetry?: () => void;
+    continueQueuedFollowUp?: () => Promise<void>;
+}
+type AgentCoreHarness = AgentHarness & {
+    getPiSessionAdapter(input: AgentSendInput, ctx: RunContext): Promise<AgentCoreSessionAdapter>;
+    hasPiSession?: (sessionId: string, ctx?: {
+        workspaceId?: string;
+        userId?: string;
+    }) => boolean;
+};
+type AgentCoreHarnessFactory = (input: AgentHarnessFactoryInput) => AgentCoreHarness | Promise<AgentCoreHarness>;
+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;
+}
+
+/** @deprecated Use AgentSendInput.content. Kept so existing shared consumers compile during the P1 rename. */
+type SendMessageInput = AgentSendInput & {
+    sessionId: string;
+    message: string;
+};
+interface RunContext {
+    abortSignal: AbortSignal;
+    workdir: string;
+    workspaceId?: string;
+    requestId?: string;
+    userId?: string;
+    userEmail?: string;
+    userEmailVerified?: boolean;
+    /** When false, slash-command fallback through native model prompt must fail closed. */
+    allowPromptDispatch?: boolean;
+}
+
+export { type AgentTool as A, sessionStreamPath as B, type ToolReadinessRequirement as C, type AgentHarnessFactory as D, type AgentHarnessFactoryInput as E, type JSONSchema as J, type MessageAttachment as M, type RunContext as R, type SendMessageInput as S, type TelemetryEvent as T, AGENT_NOT_IMPLEMENTED_UNTIL_T1 as a, type Agent as b, type AgentActor as c, type AgentCoreHarness as d, type AgentCoreHarnessFactory as e, type AgentCorePromptInput as f, type AgentCoreSessionAdapter as g, type AgentCoreSessionSnapshot as h, type AgentEvent as i, type AgentHarness as j, type AgentMessageContent as k, type AgentMessagePart as l, AgentNotImplementedError as m, type AgentReadiness as n, type AgentReadinessStatus as o, type AgentResolveInputResponse as p, type AgentRuntimeAdapter as q, type AgentSendInput as r, type AgentStartReceipt as s, type AgentStreamOptions as t, type AgentConfig as u, type TelemetrySink as v, type ToolExecContext as w, type ToolResult as x, noopTelemetry as y, safeCapture as z };

package/dist/piChatCommand-C5ZM-AMG.d.ts

@@ -0,0 +1,40 @@
+import { C as ChatSubmitPayload } from './chatSubmitPayload-DwOHyiqR.js';
+import { Q as QueuedUserMessage } from './piChatEvent-B6Lg9ft-.js';
+
+type PromptPayload = ChatSubmitPayload;
+interface FollowUpPayload {
+    message: string;
+    displayMessage?: string;
+    clientNonce: string;
+    clientSeq: number;
+}
+interface QueueClearPayload {
+    clientNonce?: string;
+    clientSeq?: number;
+}
+type InterruptPayload = Record<string, never>;
+type StopPayload = Record<string, never>;
+interface CommandReceipt {
+    accepted: true;
+    cursor: number;
+}
+type PromptReceipt = CommandReceipt & {
+    clientNonce: string;
+    duplicate?: boolean;
+};
+type FollowUpReceipt = CommandReceipt & {
+    clientNonce: string;
+    clientSeq: number;
+    queued: true;
+    duplicate?: boolean;
+};
+type QueueClearReceipt = CommandReceipt & {
+    cleared: number;
+};
+type InterruptReceipt = CommandReceipt;
+type StopReceipt = CommandReceipt & {
+    stopped: boolean;
+    clearedQueue: QueuedUserMessage[];
+};
+
+export type { CommandReceipt as C, FollowUpPayload as F, InterruptPayload as I, PromptPayload as P, QueueClearPayload as Q, StopPayload as S, FollowUpReceipt as a, InterruptReceipt as b, PromptReceipt as c, QueueClearReceipt as d, StopReceipt as e };