@code-yeongyu/senpi 2026.8.16 → 2026.8.17

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/pi-args.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Translate Cursor Pi frame args into the local tool kwargs that run them.
+ *
+ * Shared deliberately by two consumers: the `cursor-agent` API synthesizes a
+ * display block from these and the coding-agent bridge executes with them.
+ * Separate hand-rolled copies drift, and the drift is invisible — the
+ * transcript shows one operation while a different one runs.
+ *
+ * Unlike upstream oh-my-pi (whose `read` tool takes inline path selectors),
+ * senpi's tools take plain kwargs, so most mappings are direct.
+ *
+ * Every `optional int32` here is presence-sensitive: `0` is a supplied value,
+ * not "unset", so it must never be folded into a default.
+ */
+/**
+ * A `pi_read` range as the local `read` tool's `offset`/`limit` kwargs.
+ *
+ * `offset` is a 1-indexed start; `limit` is a line count. `null` marks a
+ * present `limit: 0` — zero lines, which must be answered with empty output
+ * directly rather than degrading into a whole-file read.
+ */
+export declare function piReadArgs(path: string, offset?: number, limit?: number): {
+    path: string;
+    offset?: number;
+    limit?: number;
+} | null;
+/** The path a `pi_ls` / `lsArgs` frame lists; the local `ls` defaults to ".". */
+export declare function piLsPath(basePath: string | undefined): string;
+/** Clamp a present `optional int32` result cap; `undefined` stays unset. */
+export declare function piLimit(limit: number | undefined): number | undefined;
+/**
+ * A `pi_bash` frame's timeout as the local `bash` tool's kwarg (seconds).
+ *
+ * Presence-sensitive like every other `optional int32` here: `bash` documents
+ * `timeout: 0` as "disables the command deadline", so folding a supplied `0`
+ * into `undefined` applies the default deadline and kills exactly the
+ * long-running command that asked not to be. Negative values have no local
+ * meaning and fall back to the default.
+ */
+export declare function piTimeout(timeout: number | undefined): number | undefined;
+/**
+ * Compose a Cursor `workingDirectory` onto a command for the local `bash`
+ * tool, which has no `cwd` kwarg. Single-quote escaping keeps arbitrary
+ * directory names (spaces, `$`, backticks) inert.
+ */
+export declare function composeShellCommand(command: string, workingDirectory: string | undefined): string;
+/**
+ * Drop keys whose value is `undefined` so optional local-tool kwargs stay
+ * absent rather than present-as-undefined: schema validators reject a present
+ * `undefined` on an optional field even though omitting the key is valid.
+ */
+export declare function omitUndefinedArgs<T extends Record<string, unknown>>(args: T): {
+    [K in keyof T]?: Exclude<T[K], undefined>;
+};
+//# sourceMappingURL=pi-args.d.ts.map

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/pi-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi-args.d.ts","sourceRoot":"","sources":["../../../src/api/cursor-agent/pi-args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACZ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO1D;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAE7D;AAED,4EAA4E;AAC5E,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAErE;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAIjG;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,IAAI,EAAE,CAAC,GACL;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;CAAE,CAO/C"}

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/pi-args.js

@@ -0,0 +1,76 @@
+/**
+ * Translate Cursor Pi frame args into the local tool kwargs that run them.
+ *
+ * Shared deliberately by two consumers: the `cursor-agent` API synthesizes a
+ * display block from these and the coding-agent bridge executes with them.
+ * Separate hand-rolled copies drift, and the drift is invisible — the
+ * transcript shows one operation while a different one runs.
+ *
+ * Unlike upstream oh-my-pi (whose `read` tool takes inline path selectors),
+ * senpi's tools take plain kwargs, so most mappings are direct.
+ *
+ * Every `optional int32` here is presence-sensitive: `0` is a supplied value,
+ * not "unset", so it must never be folded into a default.
+ */
+/**
+ * A `pi_read` range as the local `read` tool's `offset`/`limit` kwargs.
+ *
+ * `offset` is a 1-indexed start; `limit` is a line count. `null` marks a
+ * present `limit: 0` — zero lines, which must be answered with empty output
+ * directly rather than degrading into a whole-file read.
+ */
+export function piReadArgs(path, offset, limit) {
+    if (limit !== undefined && Math.floor(limit) <= 0)
+        return null;
+    return {
+        path,
+        offset: offset !== undefined ? Math.max(1, Math.floor(offset)) : undefined,
+        limit: limit !== undefined ? Math.floor(limit) : undefined,
+    };
+}
+/** The path a `pi_ls` / `lsArgs` frame lists; the local `ls` defaults to ".". */
+export function piLsPath(basePath) {
+    return basePath || ".";
+}
+/** Clamp a present `optional int32` result cap; `undefined` stays unset. */
+export function piLimit(limit) {
+    return limit === undefined ? undefined : Math.max(1, Math.floor(limit));
+}
+/**
+ * A `pi_bash` frame's timeout as the local `bash` tool's kwarg (seconds).
+ *
+ * Presence-sensitive like every other `optional int32` here: `bash` documents
+ * `timeout: 0` as "disables the command deadline", so folding a supplied `0`
+ * into `undefined` applies the default deadline and kills exactly the
+ * long-running command that asked not to be. Negative values have no local
+ * meaning and fall back to the default.
+ */
+export function piTimeout(timeout) {
+    return timeout !== undefined && timeout >= 0 ? timeout : undefined;
+}
+/**
+ * Compose a Cursor `workingDirectory` onto a command for the local `bash`
+ * tool, which has no `cwd` kwarg. Single-quote escaping keeps arbitrary
+ * directory names (spaces, `$`, backticks) inert.
+ */
+export function composeShellCommand(command, workingDirectory) {
+    if (!workingDirectory)
+        return command;
+    const quoted = `'${workingDirectory.replace(/'/g, "'\\''")}'`;
+    return `cd ${quoted} && { ${command}\n}`;
+}
+/**
+ * Drop keys whose value is `undefined` so optional local-tool kwargs stay
+ * absent rather than present-as-undefined: schema validators reject a present
+ * `undefined` on an optional field even though omitting the key is valid.
+ */
+export function omitUndefinedArgs(args) {
+    const out = {};
+    for (const key of Object.keys(args)) {
+        const value = args[key];
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+//# sourceMappingURL=pi-args.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/pi-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi-args.js","sourceRoot":"","sources":["../../../src/api/cursor-agent/pi-args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CACzB,IAAY,EACZ,MAAe,EACf,KAAc;IAEd,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/D,OAAO;QACN,IAAI;QACJ,MAAM,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;QAC1E,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS;KAC1D,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,QAAQ,CAAC,QAA4B;IACpD,OAAO,QAAQ,IAAI,GAAG,CAAC;AACxB,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,OAAO,CAAC,KAAyB;IAChD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,OAA2B;IACpD,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAe,EAAE,gBAAoC;IACxF,IAAI,CAAC,gBAAgB;QAAE,OAAO,OAAO,CAAC;IACtC,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;IAC9D,OAAO,MAAM,MAAM,SAAS,OAAO,KAAK,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAChC,IAAO;IAEP,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,KAAK,KAAK,SAAS;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC3C,CAAC;IACD,OAAO,GAAoD,CAAC;AAC7D,CAAC","sourcesContent":["/**\n * Translate Cursor Pi frame args into the local tool kwargs that run them.\n *\n * Shared deliberately by two consumers: the `cursor-agent` API synthesizes a\n * display block from these and the coding-agent bridge executes with them.\n * Separate hand-rolled copies drift, and the drift is invisible — the\n * transcript shows one operation while a different one runs.\n *\n * Unlike upstream oh-my-pi (whose `read` tool takes inline path selectors),\n * senpi's tools take plain kwargs, so most mappings are direct.\n *\n * Every `optional int32` here is presence-sensitive: `0` is a supplied value,\n * not \"unset\", so it must never be folded into a default.\n */\n\n/**\n * A `pi_read` range as the local `read` tool's `offset`/`limit` kwargs.\n *\n * `offset` is a 1-indexed start; `limit` is a line count. `null` marks a\n * present `limit: 0` — zero lines, which must be answered with empty output\n * directly rather than degrading into a whole-file read.\n */\nexport function piReadArgs(\n\tpath: string,\n\toffset?: number,\n\tlimit?: number,\n): { path: string; offset?: number; limit?: number } | null {\n\tif (limit !== undefined && Math.floor(limit) <= 0) return null;\n\treturn {\n\t\tpath,\n\t\toffset: offset !== undefined ? Math.max(1, Math.floor(offset)) : undefined,\n\t\tlimit: limit !== undefined ? Math.floor(limit) : undefined,\n\t};\n}\n\n/** The path a `pi_ls` / `lsArgs` frame lists; the local `ls` defaults to \".\". */\nexport function piLsPath(basePath: string | undefined): string {\n\treturn basePath || \".\";\n}\n\n/** Clamp a present `optional int32` result cap; `undefined` stays unset. */\nexport function piLimit(limit: number | undefined): number | undefined {\n\treturn limit === undefined ? undefined : Math.max(1, Math.floor(limit));\n}\n\n/**\n * A `pi_bash` frame's timeout as the local `bash` tool's kwarg (seconds).\n *\n * Presence-sensitive like every other `optional int32` here: `bash` documents\n * `timeout: 0` as \"disables the command deadline\", so folding a supplied `0`\n * into `undefined` applies the default deadline and kills exactly the\n * long-running command that asked not to be. Negative values have no local\n * meaning and fall back to the default.\n */\nexport function piTimeout(timeout: number | undefined): number | undefined {\n\treturn timeout !== undefined && timeout >= 0 ? timeout : undefined;\n}\n\n/**\n * Compose a Cursor `workingDirectory` onto a command for the local `bash`\n * tool, which has no `cwd` kwarg. Single-quote escaping keeps arbitrary\n * directory names (spaces, `$`, backticks) inert.\n */\nexport function composeShellCommand(command: string, workingDirectory: string | undefined): string {\n\tif (!workingDirectory) return command;\n\tconst quoted = `'${workingDirectory.replace(/'/g, \"'\\\\''\")}'`;\n\treturn `cd ${quoted} && { ${command}\\n}`;\n}\n\n/**\n * Drop keys whose value is `undefined` so optional local-tool kwargs stay\n * absent rather than present-as-undefined: schema validators reject a present\n * `undefined` on an optional field even though omitting the key is valid.\n */\nexport function omitUndefinedArgs<T extends Record<string, unknown>>(\n\targs: T,\n): { [K in keyof T]?: Exclude<T[K], undefined> } {\n\tconst out: Record<string, unknown> = {};\n\tfor (const key of Object.keys(args)) {\n\t\tconst value = args[key];\n\t\tif (value !== undefined) out[key] = value;\n\t}\n\treturn out as { [K in keyof T]?: Exclude<T[K], undefined> };\n}\n"]}

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Cursor exec-channel handler contracts.
+ *
+ * The Cursor agent protocol is server-driven: mid-turn, the server sends
+ * `ExecServerMessage` frames asking the CLIENT to run a tool and blocks until
+ * the reply arrives on the same stream. The host (coding-agent) supplies
+ * these handlers; the `cursor-agent` API dispatches frames onto them, sends
+ * their protobuf answers back on the wire, synthesizes already-resolved
+ * `toolCall` blocks into the assistant message, and pairs each with a
+ * `ToolResultMessage` delivered through {@link CursorToolResultHandler}.
+ *
+ * Everything here is type-only over the generated protobuf shapes, so it is
+ * safe to import from browser-reachable modules.
+ */
+import type { StreamOptions, ToolResultMessage } from "../../types.ts";
+import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, GrepArgs, GrepResult, LsArgs, LsResult, McpResult, PiBashExecArgs, PiBashExecResult, PiEditExecArgs, PiEditExecResult, PiFindExecArgs, PiFindExecResult, PiGrepExecArgs, PiGrepExecResult, PiLsExecArgs, PiLsExecResult, PiReadExecArgs, PiReadExecResult, PiWriteExecArgs, PiWriteExecResult, ReadArgs, ReadResult, ShellArgs, ShellResult, WriteArgs, WriteResult } from "./gen/agent_pb.ts";
+/**
+ * The three return forms an exec handler may use: a wire result with an
+ * optional transcript pairing, a bare wire result, or a bare
+ * `ToolResultMessage` from which the wire result is derived.
+ */
+export type CursorExecHandlerResult<T> = {
+    result: T;
+    toolResult?: ToolResultMessage;
+} | T | ToolResultMessage;
+/**
+ * Optional rewrite of a Cursor exec-channel tool result.
+ * May return a Promise. Returning `undefined` keeps the original result.
+ */
+export type CursorToolResultHandler = (result: ToolResultMessage) => ToolResultMessage | undefined | Promise<ToolResultMessage | undefined>;
+/**
+ * Identifies the synthesized assistant block a Cursor exec call was filed
+ * under, so paths that produce no handler `toolResult` can still pair one.
+ */
+export interface CursorExecPairing {
+    toolCallId: string;
+    toolName: string;
+}
+export interface CursorMcpCall {
+    name: string;
+    providerIdentifier: string;
+    toolName: string;
+    toolCallId: string;
+    args: Record<string, unknown>;
+    rawArgs: Record<string, Uint8Array>;
+    /**
+     * The frame asks only whether this call would be permitted — it must not
+     * run. The server sends it to resolve a smart-mode approval decision ahead
+     * of the real invocation; executing here would fire a side-effecting tool
+     * the user has not yet been asked about (and fire it twice once the real
+     * call arrives).
+     */
+    approvalOnly?: boolean;
+}
+export interface CursorShellStreamCallbacks {
+    onStdout(data: string): void;
+    onStderr(data: string): void;
+}
+/**
+ * A modern Pi exec frame plus the call id the dispatcher minted for it.
+ *
+ * Unlike the legacy exec args (`ReadArgs`, `ShellArgs`, ...), the Pi frames
+ * carry no `tool_call_id` field: the id rides the streamed `ToolCall`
+ * envelope instead. The exec channel has no access to that envelope, so the
+ * dispatcher mints an id and hands it to the handler, keeping the synthesized
+ * transcript block and its paired `toolResult` on the same key.
+ */
+export interface CursorPiCall<TArgs> {
+    args: TArgs;
+    toolCallId: string;
+}
+export interface CursorExecHandlers {
+    read?: (args: ReadArgs) => Promise<CursorExecHandlerResult<ReadResult>>;
+    ls?: (args: LsArgs) => Promise<CursorExecHandlerResult<LsResult>>;
+    grep?: (args: GrepArgs) => Promise<CursorExecHandlerResult<GrepResult>>;
+    write?: (args: WriteArgs) => Promise<CursorExecHandlerResult<WriteResult>>;
+    delete?: (args: DeleteArgs) => Promise<CursorExecHandlerResult<DeleteResult>>;
+    shell?: (args: ShellArgs) => Promise<CursorExecHandlerResult<ShellResult>>;
+    shellStream?: (args: ShellArgs, callbacks: CursorShellStreamCallbacks) => Promise<CursorExecHandlerResult<ShellResult>>;
+    diagnostics?: (args: DiagnosticsArgs) => Promise<CursorExecHandlerResult<DiagnosticsResult>>;
+    mcp?: (call: CursorMcpCall) => Promise<CursorExecHandlerResult<McpResult>>;
+    /**
+     * Answers "would this MCP call be permitted", without running it.
+     *
+     * `true` only when the host's policy resolves to a definite allow. A
+     * pending prompt is `false`: it can only be answered interactively at
+     * execution time. When no handler is registered the provider refuses,
+     * since it cannot decide.
+     */
+    mcpApprovalPreflight?: (call: CursorMcpCall) => Promise<boolean>;
+    /**
+     * Modern Cursor CLI Pi tool frames (`ExecServerMessage` 45-51). They are a
+     * distinct frame family from the legacy `readArgs`/`shellArgs`/... set:
+     * different args, different result oneofs, and no `tool_call_id`.
+     */
+    piRead?: (call: CursorPiCall<PiReadExecArgs>) => Promise<CursorExecHandlerResult<PiReadExecResult>>;
+    piBash?: (call: CursorPiCall<PiBashExecArgs>) => Promise<CursorExecHandlerResult<PiBashExecResult>>;
+    piEdit?: (call: CursorPiCall<PiEditExecArgs>) => Promise<CursorExecHandlerResult<PiEditExecResult>>;
+    piWrite?: (call: CursorPiCall<PiWriteExecArgs>) => Promise<CursorExecHandlerResult<PiWriteExecResult>>;
+    piGrep?: (call: CursorPiCall<PiGrepExecArgs>) => Promise<CursorExecHandlerResult<PiGrepExecResult>>;
+    piFind?: (call: CursorPiCall<PiFindExecArgs>) => Promise<CursorExecHandlerResult<PiFindExecResult>>;
+    piLs?: (call: CursorPiCall<PiLsExecArgs>) => Promise<CursorExecHandlerResult<PiLsExecResult>>;
+    onToolResult?: CursorToolResultHandler;
+}
+/** Stream options accepted by the `cursor-agent` API. */
+export interface CursorAgentOptions extends StreamOptions {
+    /** Optional server-side system prompt override (RunRequest.customSystemPrompt). */
+    customSystemPrompt?: string;
+    /** Conversation id override; defaults to `sessionId`, else a random UUID per stream. */
+    conversationId?: string;
+    /** Cursor exec/MCP tool handlers supplied by the host. */
+    execHandlers?: CursorExecHandlers;
+    /** Receives every exec-channel tool result for transcript pairing. */
+    onToolResult?: CursorToolResultHandler;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/api/cursor-agent/types.ts"],"names":[],"mappings":"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"}

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/types.js

@@ -0,0 +1,16 @@
+/**
+ * Cursor exec-channel handler contracts.
+ *
+ * The Cursor agent protocol is server-driven: mid-turn, the server sends
+ * `ExecServerMessage` frames asking the CLIENT to run a tool and blocks until
+ * the reply arrives on the same stream. The host (coding-agent) supplies
+ * these handlers; the `cursor-agent` API dispatches frames onto them, sends
+ * their protobuf answers back on the wire, synthesizes already-resolved
+ * `toolCall` blocks into the assistant message, and pairs each with a
+ * `ToolResultMessage` delivered through {@link CursorToolResultHandler}.
+ *
+ * Everything here is type-only over the generated protobuf shapes, so it is
+ * safe to import from browser-reachable modules.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/api/cursor-agent/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * Cursor exec-channel handler contracts.\n *\n * The Cursor agent protocol is server-driven: mid-turn, the server sends\n * `ExecServerMessage` frames asking the CLIENT to run a tool and blocks until\n * the reply arrives on the same stream. The host (coding-agent) supplies\n * these handlers; the `cursor-agent` API dispatches frames onto them, sends\n * their protobuf answers back on the wire, synthesizes already-resolved\n * `toolCall` blocks into the assistant message, and pairs each with a\n * `ToolResultMessage` delivered through {@link CursorToolResultHandler}.\n *\n * Everything here is type-only over the generated protobuf shapes, so it is\n * safe to import from browser-reachable modules.\n */\n\nimport type { StreamOptions, ToolResultMessage } from \"../../types.ts\";\nimport type {\n\tDeleteArgs,\n\tDeleteResult,\n\tDiagnosticsArgs,\n\tDiagnosticsResult,\n\tGrepArgs,\n\tGrepResult,\n\tLsArgs,\n\tLsResult,\n\tMcpResult,\n\tPiBashExecArgs,\n\tPiBashExecResult,\n\tPiEditExecArgs,\n\tPiEditExecResult,\n\tPiFindExecArgs,\n\tPiFindExecResult,\n\tPiGrepExecArgs,\n\tPiGrepExecResult,\n\tPiLsExecArgs,\n\tPiLsExecResult,\n\tPiReadExecArgs,\n\tPiReadExecResult,\n\tPiWriteExecArgs,\n\tPiWriteExecResult,\n\tReadArgs,\n\tReadResult,\n\tShellArgs,\n\tShellResult,\n\tWriteArgs,\n\tWriteResult,\n} from \"./gen/agent_pb.ts\";\n\n/**\n * The three return forms an exec handler may use: a wire result with an\n * optional transcript pairing, a bare wire result, or a bare\n * `ToolResultMessage` from which the wire result is derived.\n */\nexport type CursorExecHandlerResult<T> = { result: T; toolResult?: ToolResultMessage } | T | ToolResultMessage;\n\n/**\n * Optional rewrite of a Cursor exec-channel tool result.\n * May return a Promise. Returning `undefined` keeps the original result.\n */\nexport type CursorToolResultHandler = (\n\tresult: ToolResultMessage,\n) => ToolResultMessage | undefined | Promise<ToolResultMessage | undefined>;\n\n/**\n * Identifies the synthesized assistant block a Cursor exec call was filed\n * under, so paths that produce no handler `toolResult` can still pair one.\n */\nexport interface CursorExecPairing {\n\ttoolCallId: string;\n\ttoolName: string;\n}\n\nexport interface CursorMcpCall {\n\tname: string;\n\tproviderIdentifier: string;\n\ttoolName: string;\n\ttoolCallId: string;\n\targs: Record<string, unknown>;\n\trawArgs: Record<string, Uint8Array>;\n\t/**\n\t * The frame asks only whether this call would be permitted — it must not\n\t * run. The server sends it to resolve a smart-mode approval decision ahead\n\t * of the real invocation; executing here would fire a side-effecting tool\n\t * the user has not yet been asked about (and fire it twice once the real\n\t * call arrives).\n\t */\n\tapprovalOnly?: boolean;\n}\n\nexport interface CursorShellStreamCallbacks {\n\tonStdout(data: string): void;\n\tonStderr(data: string): void;\n}\n\n/**\n * A modern Pi exec frame plus the call id the dispatcher minted for it.\n *\n * Unlike the legacy exec args (`ReadArgs`, `ShellArgs`, ...), the Pi frames\n * carry no `tool_call_id` field: the id rides the streamed `ToolCall`\n * envelope instead. The exec channel has no access to that envelope, so the\n * dispatcher mints an id and hands it to the handler, keeping the synthesized\n * transcript block and its paired `toolResult` on the same key.\n */\nexport interface CursorPiCall<TArgs> {\n\targs: TArgs;\n\ttoolCallId: string;\n}\n\nexport interface CursorExecHandlers {\n\tread?: (args: ReadArgs) => Promise<CursorExecHandlerResult<ReadResult>>;\n\tls?: (args: LsArgs) => Promise<CursorExecHandlerResult<LsResult>>;\n\tgrep?: (args: GrepArgs) => Promise<CursorExecHandlerResult<GrepResult>>;\n\twrite?: (args: WriteArgs) => Promise<CursorExecHandlerResult<WriteResult>>;\n\tdelete?: (args: DeleteArgs) => Promise<CursorExecHandlerResult<DeleteResult>>;\n\tshell?: (args: ShellArgs) => Promise<CursorExecHandlerResult<ShellResult>>;\n\tshellStream?: (\n\t\targs: ShellArgs,\n\t\tcallbacks: CursorShellStreamCallbacks,\n\t) => Promise<CursorExecHandlerResult<ShellResult>>;\n\tdiagnostics?: (args: DiagnosticsArgs) => Promise<CursorExecHandlerResult<DiagnosticsResult>>;\n\tmcp?: (call: CursorMcpCall) => Promise<CursorExecHandlerResult<McpResult>>;\n\t/**\n\t * Answers \"would this MCP call be permitted\", without running it.\n\t *\n\t * `true` only when the host's policy resolves to a definite allow. A\n\t * pending prompt is `false`: it can only be answered interactively at\n\t * execution time. When no handler is registered the provider refuses,\n\t * since it cannot decide.\n\t */\n\tmcpApprovalPreflight?: (call: CursorMcpCall) => Promise<boolean>;\n\t/**\n\t * Modern Cursor CLI Pi tool frames (`ExecServerMessage` 45-51). They are a\n\t * distinct frame family from the legacy `readArgs`/`shellArgs`/... set:\n\t * different args, different result oneofs, and no `tool_call_id`.\n\t */\n\tpiRead?: (call: CursorPiCall<PiReadExecArgs>) => Promise<CursorExecHandlerResult<PiReadExecResult>>;\n\tpiBash?: (call: CursorPiCall<PiBashExecArgs>) => Promise<CursorExecHandlerResult<PiBashExecResult>>;\n\tpiEdit?: (call: CursorPiCall<PiEditExecArgs>) => Promise<CursorExecHandlerResult<PiEditExecResult>>;\n\tpiWrite?: (call: CursorPiCall<PiWriteExecArgs>) => Promise<CursorExecHandlerResult<PiWriteExecResult>>;\n\tpiGrep?: (call: CursorPiCall<PiGrepExecArgs>) => Promise<CursorExecHandlerResult<PiGrepExecResult>>;\n\tpiFind?: (call: CursorPiCall<PiFindExecArgs>) => Promise<CursorExecHandlerResult<PiFindExecResult>>;\n\tpiLs?: (call: CursorPiCall<PiLsExecArgs>) => Promise<CursorExecHandlerResult<PiLsExecResult>>;\n\tonToolResult?: CursorToolResultHandler;\n}\n\n/** Stream options accepted by the `cursor-agent` API. */\nexport interface CursorAgentOptions extends StreamOptions {\n\t/** Optional server-side system prompt override (RunRequest.customSystemPrompt). */\n\tcustomSystemPrompt?: string;\n\t/** Conversation id override; defaults to `sessionId`, else a random UUID per stream. */\n\tconversationId?: string;\n\t/** Cursor exec/MCP tool handlers supplied by the host. */\n\texecHandlers?: CursorExecHandlers;\n\t/** Receives every exec-channel tool result for transcript pairing. */\n\tonToolResult?: CursorToolResultHandler;\n}\n"]}

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Cursor agent protocol (`agent.v1.AgentService/Run`) over HTTP/2 Connect.
+ *
+ * Ported from upstream oh-my-pi's Cursor provider and adapted to senpi's
+ * provider-neutral API architecture. The protocol is server-driven: the
+ * client opens one `Run` stream per assistant turn, the server streams
+ * interaction updates (text/thinking/tool-call deltas) and, mid-turn, sends
+ * `ExecServerMessage` frames asking the CLIENT to execute a tool and blocks
+ * until the answer arrives on the same stream. Tool execution is therefore
+ * bridged through injected {@link CursorExecHandlers}; each bridged call is
+ * synthesized into the assistant message as an already-resolved `toolCall`
+ * block (marked {@link kCursorExecResolved} so the agent loop never re-runs
+ * it) and paired with a `ToolResultMessage` delivered via `onToolResult`.
+ *
+ * NOTE: This module is Node-only (node:http2) and must only be reached
+ * through the lazy wrapper (`cursor-agent.lazy.ts`).
+ */
+import * as http2 from "node:http2";
+import type { AssistantMessage, Message, SimpleStreamOptions, StreamFunction, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage } from "../types.ts";
+import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingEnvelopeId, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { type AgentServerMessage, type ConversationStateStructure, type McpToolDefinition } from "./cursor-agent/gen/agent_pb.ts";
+import type { CursorAgentOptions, CursorExecHandlerResult, CursorExecHandlers, CursorExecPairing, CursorToolResultHandler } from "./cursor-agent/types.ts";
+export type { CursorAgentOptions, CursorExecHandlerResult, CursorExecHandlers, CursorExecPairing, CursorMcpCall, CursorPiCall, CursorShellStreamCallbacks, CursorToolResultHandler, } from "./cursor-agent/types.ts";
+export declare const CURSOR_API_URL = "https://api2.cursor.sh";
+export declare const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
+/** Reduce caller-supplied headers to what this HTTP/2 request can legally carry. */
+export declare function sanitizeCursorCallerHeaders(headers: Record<string, string> | undefined): Record<string, string>;
+export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
+/**
+ * Maps an opaque HTTP/2 negotiation failure into an actionable error. The
+ * Cursor run RPC is HTTP/2-only (the ALB rejects HTTP/1.1 with 464), so a
+ * TLS-intercepting proxy that strips ALPN kills the run with no h1 fallback.
+ */
+export declare function mapH2TransportError(error: unknown, baseUrl: string): unknown;
+export declare const stream: StreamFunction<"cursor-agent", CursorAgentOptions>;
+/**
+ * `streamSimple` for Cursor: reasoning/thinking is managed server-side per
+ * model (there is no client thinking knob on the Run request), so the simple
+ * options map through unchanged.
+ */
+export declare const streamSimple: StreamFunction<"cursor-agent", SimpleStreamOptions>;
+export type ToolCallState = ToolCall & {
+    [kStreamingBlockIndex]: number;
+    [kStreamingPartialJson]?: string;
+    [kStreamingLastParseLen]?: number;
+    [kStreamingBlockKind]: "mcp" | "todo" | "cursor-exec" | "connect-scm";
+    [kStreamingEnvelopeId]?: string;
+    [kCursorExecResolved]?: true;
+};
+export interface BlockState {
+    currentTextBlock: (TextContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null;
+    currentThinkingBlock: (ThinkingContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null;
+    currentToolCall: ToolCallState | null;
+    /**
+     * Open streamed tool-call blocks, keyed by the interaction envelope's
+     * `call_id`. Cursor interleaves calls: two `toolCallStarted` frames can
+     * arrive before either completes.
+     */
+    openToolCalls: Map<string, ToolCallState>;
+    /** MCP call IDs synthesized from exec frames before their redundant streamed block arrives. */
+    resolvedMcpToolCallIds: Set<string>;
+    setTextBlock: (b: (TextContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null) => void;
+    setThinkingBlock: (b: (ThinkingContent & {
+        [kStreamingBlockIndex]: number;
+    }) | null) => void;
+    setToolCall: (t: ToolCallState | null) => void;
+    /**
+     * Persist a paired `toolResult` for a server-resolved call. Native todo
+     * calls never travel the exec channel, so without this the resolved block
+     * has no matching result and every transcript rebuild strips it as dangling.
+     */
+    onToolResult?: CursorToolResultHandler;
+}
+export interface UsageState {
+    sawTokenDelta: boolean;
+}
+/** Exported for tests: drives one Cursor server message through the stream (exec waits mark the stream busy). */
+export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, h2Request: http2.ClientHttp2Stream, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void): Promise<void>;
+/**
+ * Exported for tests: dispatches one exec frame onto its handler.
+ *
+ * Every exit pairs a `toolResult`. The synthesized block was already marked
+ * `kCursorExecResolved` before this runs, so the agent loop emits no
+ * placeholder for it: a path that returns without a result leaves the call
+ * unpaired and transcript rebuilds strip the whole interaction. The three
+ * result-less paths — no handler installed, a handler that produced nothing,
+ * and a thrown handler — therefore synthesize one from the same text the
+ * server sees in `execResult`.
+ *
+ * `pairing` is required so a new callsite cannot silently recreate the
+ * orphan, and nullable for the callers whose block is NOT pre-resolved (MCP
+ * without an `mcp` handler, which the agent loop runs locally and pairs
+ * itself, and frames that never synthesize a block).
+ */
+export declare function resolveExecHandler<TArgs, TResult>(args: TArgs, handler: ((args: TArgs) => Promise<CursorExecHandlerResult<TResult>>) | undefined, onToolResult: CursorToolResultHandler | undefined, buildFromToolResult: (toolResult: ToolResultMessage) => TResult, buildRejected: (reason: string) => TResult, buildError: (error: string) => TResult, pairing: CursorExecPairing | null): Promise<{
+    execResult: TResult;
+    toolResult?: ToolResultMessage;
+}>;
+/**
+ * Reject a Cursor exec-channel `grepArgs` frame whose `pattern` is empty or
+ * whitespace-only. Returns an actionable error message (with a `glob`-aware
+ * hint when the model likely meant to list files) or `null` when the pattern
+ * is valid and grep should run. Exported for tests.
+ */
+export declare function emptyGrepPatternRejection(pattern: string | undefined, glob: string | undefined): string | null;
+/**
+ * Close every tool-call block still open when the stream ends.
+ *
+ * Not just the last one started: with interleaved calls several can be open
+ * at once, and an unclosed block leaves its live card animating and its call
+ * unpaired. Only blocks fed by a streamed argument buffer get reparsed.
+ * Server-owned blocks (`connect-scm`, `todo`) are also paired here: they are
+ * stamped resolved the moment they open, so only their completion frame pairs
+ * a result — a transport that closes before that frame would leave the call
+ * unpaired. MCP blocks are excluded even when resolved: the exec dispatch
+ * that marked them owns their result.
+ */
+export declare function flushOpenToolCalls(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState): void;
+/**
+ * Merge the decoded completion-frame `McpArgs` map into the args assembled
+ * from streamed `args_text_delta` snapshots.
+ *
+ * The completion frame is authoritative for the scalars it carries — but it
+ * can omit oversized parameters entirely and can downgrade a structured value
+ * to its raw string fallback. Rules per key:
+ * - completion key absent → keep the streamed value.
+ * - completion is a string while the streamed value is structured → keep the
+ *   streamed value (the completion frame downgraded it).
+ * - otherwise → completion wins.
+ */
+export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unknown> | undefined, completion: Record<string, unknown> | undefined): Record<string, unknown>;
+/**
+ * Synthesize a completed `toolCall` content block for a Cursor exec-channel
+ * native tool or for an MCP exec frame whose corresponding interaction block
+ * is absent.
+ *
+ * Args arrive complete on the exec message, so the block opens and closes in
+ * one step. Without this the persisted assistant message carries only
+ * text/thinking blocks, and on replay the following `toolResult` messages
+ * have no matching `toolCall.id`.
+ *
+ * The block is stamped with {@link kCursorExecResolved} so the agent loop's
+ * execution pass skips it — Cursor's server-driven exec channel already ran
+ * the tool via the bridge and buffered the result. Exported for tests.
+ */
+export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>): void;
+/** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
+export declare function processInteractionUpdate(update: any, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, usageState: UsageState): void;
+export declare function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[];
+/**
+ * Build one Cursor system-message JSON blob per system prompt. When no system
+ * prompt is provided, returns a single default greeting so we never emit an
+ * empty `rootPromptMessagesJson` head.
+ */
+export declare function buildCursorSystemPromptJsons(systemPrompt: string | undefined): string[];
+/** Exported for tests: decodes Cursor history blobs built from conversation messages. */
+export declare function buildCursorHistoryForTest(messages: Message[], activeUserMessageIndex?: number): {
+    rootPromptMessagesJson: unknown[];
+    turnUserMessagesJson: unknown[];
+    turnStepMessagesJson: unknown[][];
+};
+export interface CursorDiscoveredModel {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    input: ("text" | "image")[];
+    contextWindow: number;
+    maxTokens: number;
+    cursorMaxMode: boolean;
+}
+/**
+ * Fetches Cursor models through `GetUsableModels` (unary protobuf over
+ * HTTP/2; the ALB rejects HTTP/1.1 with 464) and normalizes them.
+ *
+ * Returns `null` on request/decode failures; `[]` only when the endpoint
+ * responds successfully with no usable models.
+ */
+export declare function fetchCursorUsableModels(options: {
+    apiKey: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<CursorDiscoveredModel[] | null>;
+//# sourceMappingURL=cursor-agent.d.ts.map

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-agent.d.ts","sourceRoot":"","sources":["../../src/api/cursor-agent.ts"],"names":[],"mappings":"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"}