@automatalabs/pi-acp 0.1.0

package/dist/errors.js

@@ -0,0 +1,104 @@
+import { RequestError } from "@agentclientprotocol/sdk";
+const LABELS = {
+    auth_error: "provider credentials required",
+    rate_limit: "provider rate limit",
+    billing_error: "provider billing or quota wall",
+    provider_error: "provider error",
+    invalid_model: "unknown or unselectable model",
+    empty_prompt: "prompt has no text or images",
+    session_busy: "session has a turn in flight",
+    invalid_config_value: "invalid config option",
+    invalid_config_type: "invalid config option",
+    unknown_config_option: "invalid config option",
+    invalid_cwd: "invalid working directory",
+    unknown_session: "unknown session id",
+    session_already_open: "session already open",
+    session_terminated: "session terminated",
+    session_corrupt: "session file could not be read",
+    session_not_forkable: "session has no persisted history to fork",
+    mcp_init_error: "mcp server initialization failed",
+    unsupported_mcp_transport: "unsupported mcp transport",
+    structured_tool_collision: "structured-output tool unavailable",
+    invalid_output_schema: "invalid output schema",
+    invalid_cursor: "invalid list cursor",
+    unknown_auth_method: "unknown auth method",
+    notification_error: "notification delivery failed",
+    internal_error: "internal error",
+};
+const INVALID_KINDS = new Set([
+    "invalid_model",
+    "empty_prompt",
+    "session_busy",
+    "invalid_config_value",
+    "invalid_config_type",
+    "unknown_config_option",
+    "invalid_cwd",
+    "unknown_session",
+    "session_already_open",
+    "session_terminated",
+    "session_not_forkable",
+    "unsupported_mcp_transport",
+    "invalid_output_schema",
+    "invalid_cursor",
+    "unknown_auth_method",
+]);
+export function redactedDiagnostics(diagnostics) {
+    return diagnostics?.length
+        ? diagnostics.map(({ type, timestamp }) => ({ type, timestamp }))
+        : undefined;
+}
+export function adapterError(kind, extras = {}) {
+    const data = { errorKind: kind, message: LABELS[kind] };
+    if (extras.server !== undefined)
+        data.server = extras.server;
+    if (extras.details !== undefined)
+        data.details = extras.details;
+    if (kind === "auth_error")
+        return RequestError.authRequired(data);
+    if (INVALID_KINDS.has(kind))
+        return RequestError.invalidParams(data);
+    return RequestError.internalError(data);
+}
+export function classifyPreflight(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : "";
+    if (message.includes("no model selected"))
+        return adapterError("invalid_model");
+    if (message.includes("no api key found") ||
+        message.includes("authentication failed for") ||
+        message.includes("run '/login")) {
+        return adapterError("auth_error");
+    }
+    return adapterError("provider_error");
+}
+export function classifyTerminal(message) {
+    const diagnostics = message.diagnostics ?? [];
+    const haystack = [
+        message.errorMessage ?? "",
+        ...diagnostics.flatMap((item) => [
+            item.type,
+            item.error?.name ?? "",
+            item.error?.message ?? "",
+        ]),
+    ]
+        .join("\n")
+        .toLowerCase();
+    if (/\b401\b|\b403\b|unauthorized|invalid api key|authentication|forbidden|expired/.test(haystack)) {
+        return adapterError("auth_error");
+    }
+    if (/quota|billing|insufficient|payment|credit|exceeded your/.test(haystack)) {
+        return adapterError("billing_error");
+    }
+    if (/\b429\b|rate limit|too many requests|overloaded/.test(haystack)) {
+        return adapterError("rate_limit");
+    }
+    return adapterError("provider_error", { details: redactedDiagnostics(diagnostics) });
+}
+export function unexpectedError(error, terminal) {
+    console.error("pi-acp internal error:", error);
+    return adapterError("internal_error", {
+        details: redactedDiagnostics(terminal?.diagnostics),
+    });
+}
+export function isRequestError(error) {
+    return error instanceof RequestError;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// No static pi/SDK/adapter imports: stdout is reserved before module evaluation.
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    const manifest = await import("../package.json", { with: { type: "json" } }).then((module) => module.default);
+    process.stdout.write(`${manifest.version}\n`);
+    process.exit(0);
+}
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+process.on("unhandledRejection", (reason) => {
+    console.error("unhandledRejection:", reason);
+});
+function withTimeout(promise, milliseconds) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("shutdown timed out")), milliseconds);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+try {
+    const { runAcp } = await import("./server.js");
+    const { connection, agent } = await runAcp();
+    let shuttingDown;
+    const shutdown = (code) => {
+        shuttingDown ??= (async () => {
+            try {
+                await withTimeout(agent.dispose(), 5_000);
+            }
+            catch (error) {
+                console.error("shutdown error:", error);
+            }
+            finally {
+                process.exit(code);
+            }
+        })();
+        return shuttingDown;
+    };
+    connection.closed.then(() => shutdown(0), () => shutdown(1));
+    process.on("SIGTERM", () => { void shutdown(0); });
+    process.on("SIGINT", () => { void shutdown(0); });
+    process.stdin.resume();
+}
+catch (error) {
+    console.error("startup error:", error);
+    process.exit(1);
+}
+export {};

package/dist/lib.d.ts

@@ -0,0 +1,4 @@
+export { runAcp, PiAcpAgent } from "./server.js";
+export { resolveDeps } from "./deps.js";
+export type { PiAcpDeps } from "./deps.js";
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC"}

package/dist/lib.js

@@ -0,0 +1,2 @@
+export { runAcp, PiAcpAgent } from "./server.js";
+export { resolveDeps } from "./deps.js";

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,58 @@
+import type { McpServer, McpServerStdio } from "@agentclientprotocol/sdk";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { PiAcpDeps } from "./deps.js";
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpListResult {
+    tools: McpToolInfo[];
+    nextCursor?: string;
+}
+export interface McpClientHandle {
+    listTools(cursor: string | undefined, signal: AbortSignal, timeoutMs: number): Promise<McpListResult>;
+    callTool(name: string, args: unknown, signal: AbortSignal, timeoutMs: number): Promise<CallToolResult>;
+    close(): Promise<void>;
+}
+export declare class McpTimeoutError extends Error {
+    constructor();
+}
+export declare function bounded<T>(operation: Promise<T>, signal: AbortSignal, timeoutMs: number, sleep: PiAcpDeps["sleep"]): Promise<T>;
+export declare function connectDefaultMcpClient(server: McpServerStdio, signal: AbortSignal, timeoutMs: number, sleep: PiAcpDeps["sleep"]): Promise<McpClientHandle>;
+export declare function allocateAlias(server: string, tool: string, used: Set<string>): string;
+type McpContent = CallToolResult["content"][number];
+export declare function convertMcpContent(content: McpContent): {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
+export declare function convertMcpResult(result: CallToolResult): {
+    details?: {
+        [x: string]: unknown;
+    } | undefined;
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+    })[];
+};
+export type McpResultProjection = ReturnType<typeof convertMcpResult>;
+export interface McpBridge {
+    clients: McpClientHandle[];
+    tools: ToolDefinition[];
+    aliases: string[];
+    aliasServers: Map<string, string>;
+    failedResults: Map<string, McpResultProjection>;
+}
+export declare function bridgeMcpServers(servers: readonly McpServer[], openSignal: AbortSignal, deps: PiAcpDeps): Promise<McpBridge>;
+export declare function disposeMcpBridge(clients: readonly McpClientHandle[], deps: PiAcpDeps): Promise<void>;
+export {};
+//# sourceMappingURL=mcp-bridge.d.ts.map

package/dist/mcp-bridge.d.ts.map

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

package/dist/mcp-bridge.js

@@ -0,0 +1,240 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { adapterError } from "./errors.js";
+export class McpTimeoutError extends Error {
+    constructor() {
+        super("MCP operation timed out");
+        this.name = "McpTimeoutError";
+    }
+}
+function abortPromise(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        else
+            signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+    });
+}
+export async function bounded(operation, signal, timeoutMs, sleep) {
+    const timeoutController = new AbortController();
+    const timeout = sleep(timeoutMs, timeoutController.signal).then(() => {
+        throw new McpTimeoutError();
+    });
+    operation.then(() => undefined, () => undefined);
+    try {
+        return await Promise.race([operation, abortPromise(signal), timeout]);
+    }
+    finally {
+        timeoutController.abort();
+        timeout.catch(() => undefined);
+    }
+}
+export async function connectDefaultMcpClient(server, signal, timeoutMs, sleep) {
+    const client = new Client({ name: "@automatalabs/pi-acp", version: "0.0.0" });
+    const transport = new StdioClientTransport({
+        command: server.command,
+        args: server.args,
+        env: Object.fromEntries(server.env.map(({ name, value }) => [name, value])),
+    });
+    try {
+        await bounded(client.connect(transport), signal, timeoutMs, sleep);
+    }
+    catch (error) {
+        const pid = transport.pid;
+        const close = transport.close().catch(() => undefined);
+        try {
+            await bounded(close, new AbortController().signal, timeoutMs, sleep);
+        }
+        catch {
+            if (pid !== null) {
+                try {
+                    process.kill(pid, "SIGKILL");
+                }
+                catch {
+                    // The child may have exited between the timeout and the kill.
+                }
+            }
+            try {
+                await bounded(close, new AbortController().signal, timeoutMs, sleep);
+            }
+            catch {
+                close.then(() => undefined, () => undefined);
+            }
+        }
+        throw error;
+    }
+    let closed = false;
+    return {
+        async listTools(cursor, requestSignal, requestTimeout) {
+            const result = await client.listTools(cursor ? { cursor } : undefined, {
+                signal: requestSignal,
+                timeout: requestTimeout,
+            });
+            return {
+                tools: result.tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                })),
+                nextCursor: result.nextCursor,
+            };
+        },
+        callTool(name, args, requestSignal, requestTimeout) {
+            return client.callTool({ name, arguments: typeof args === "object" && args !== null ? args : {} }, undefined, { signal: requestSignal, timeout: requestTimeout }).then((result) => {
+                if (!("content" in result))
+                    throw new Error("MCP task result did not contain tool content");
+                return result;
+            });
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            await client.close();
+        },
+    };
+}
+function slug(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_");
+    return sanitized || "_";
+}
+export function allocateAlias(server, tool, used) {
+    const base = `mcp__${slug(server)}__${slug(tool)}`;
+    let candidate = base.slice(0, 128);
+    if (!used.has(candidate)) {
+        used.add(candidate);
+        return candidate;
+    }
+    for (let index = 2;; index += 1) {
+        const suffix = `_${index}`;
+        candidate = `${base.slice(0, 128 - suffix.length)}${suffix}`;
+        if (!used.has(candidate)) {
+            used.add(candidate);
+            return candidate;
+        }
+    }
+}
+export function convertMcpContent(content) {
+    switch (content.type) {
+        case "text":
+            return { type: "text", text: content.text };
+        case "image":
+            return { type: "image", data: content.data, mimeType: content.mimeType };
+        case "audio":
+            return { type: "text", text: "[unsupported audio tool-result omitted]" };
+        case "resource_link":
+            return { type: "text", text: `[${content.title ?? content.name ?? content.uri}](${content.uri})` };
+        case "resource":
+            return {
+                type: "text",
+                text: "text" in content.resource
+                    ? content.resource.text
+                    : `[embedded resource: ${content.resource.uri}]`,
+            };
+        default: {
+            const exhaustive = content;
+            return exhaustive;
+        }
+    }
+}
+export function convertMcpResult(result) {
+    return {
+        content: result.content.map(convertMcpContent),
+        ...(result.structuredContent === undefined ? {} : { details: result.structuredContent }),
+    };
+}
+async function closeClients(clients, deps) {
+    await Promise.allSettled(clients.map((client) => bounded(client.close(), new AbortController().signal, deps.mcpTimeoutMs, deps.sleep).catch((error) => {
+        console.error("pi-acp MCP close error:", error);
+    })));
+}
+export async function bridgeMcpServers(servers, openSignal, deps) {
+    const seenNames = new Set();
+    for (const server of servers) {
+        if (seenNames.has(server.name))
+            throw adapterError("mcp_init_error", { server: server.name });
+        seenNames.add(server.name);
+        if ("type" in server) {
+            throw adapterError("unsupported_mcp_transport", { server: server.name });
+        }
+    }
+    const clients = [];
+    const tools = [];
+    const aliases = [];
+    const aliasServers = new Map();
+    const failedResults = new Map();
+    const usedAliases = new Set();
+    try {
+        for (const server of servers) {
+            let handle;
+            try {
+                handle = await bounded(deps.connectMcpClient(server, openSignal), openSignal, deps.mcpTimeoutMs, deps.sleep);
+            }
+            catch (error) {
+                if (openSignal.aborted)
+                    throw error;
+                throw adapterError("mcp_init_error", { server: server.name });
+            }
+            clients.push(handle);
+            const serverTools = [];
+            const cursors = new Set();
+            let cursor;
+            try {
+                do {
+                    if (cursor !== undefined) {
+                        if (cursors.has(cursor))
+                            throw new Error("cycling tools/list cursor");
+                        cursors.add(cursor);
+                    }
+                    const page = await bounded(handle.listTools(cursor, openSignal, deps.mcpTimeoutMs), openSignal, deps.mcpTimeoutMs, deps.sleep);
+                    serverTools.push(...page.tools);
+                    cursor = page.nextCursor;
+                } while (cursor !== undefined);
+            }
+            catch (error) {
+                if (openSignal.aborted)
+                    throw error;
+                throw adapterError("mcp_init_error", { server: server.name });
+            }
+            for (const remoteTool of serverTools) {
+                const alias = allocateAlias(server.name, remoteTool.name, usedAliases);
+                aliases.push(alias);
+                aliasServers.set(alias, server.name);
+                const tool = {
+                    name: alias,
+                    label: remoteTool.name,
+                    description: remoteTool.description ?? `MCP tool ${remoteTool.name}`,
+                    parameters: remoteTool.inputSchema,
+                    execute: async (_toolCallId, params, signal) => {
+                        const turnSignal = signal ?? new AbortController().signal;
+                        let result;
+                        try {
+                            result = await bounded(handle.callTool(remoteTool.name, params, turnSignal, deps.mcpTimeoutMs), turnSignal, deps.mcpTimeoutMs, deps.sleep);
+                        }
+                        catch (error) {
+                            if (error instanceof McpTimeoutError) {
+                                throw new Error(`MCP tool ${alias} timed out`);
+                            }
+                            throw new Error(`MCP tool ${alias} failed`);
+                        }
+                        const converted = convertMcpResult(result);
+                        if (result.isError) {
+                            failedResults.set(_toolCallId, converted);
+                            throw new Error(`MCP tool ${alias} returned an error result`);
+                        }
+                        return converted;
+                    },
+                };
+                tools.push(tool);
+            }
+        }
+        return { clients, tools, aliases, aliasServers, failedResults };
+    }
+    catch (error) {
+        await closeClients(clients, deps);
+        throw error;
+    }
+}
+export async function disposeMcpBridge(clients, deps) {
+    await closeClients(clients, deps);
+}

package/dist/permissions.d.ts

@@ -0,0 +1,11 @@
+import { type AgentContext } from "@agentclientprotocol/sdk";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+interface PermissionHost {
+    readonly sessionId: string;
+    readonly client: AgentContext;
+    drain(): Promise<void>;
+    turnSignal(): AbortSignal | undefined;
+}
+export declare function installPermissionWrapper(session: AgentSession, host: PermissionHost): void;
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../src/permissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGpE,UAAU,cAAc;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,UAAU,IAAI,WAAW,GAAG,SAAS,CAAC;CACvC;AAaD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CA2D1F"}

package/dist/permissions.js

@@ -0,0 +1,77 @@
+import { methods } from "@agentclientprotocol/sdk";
+import { mapKind } from "./translate.js";
+function raceSignal(promise, signal) {
+    promise.then(() => undefined, () => undefined);
+    if (signal.aborted)
+        return Promise.resolve(undefined);
+    return Promise.race([
+        promise,
+        new Promise((resolve) => {
+            signal.addEventListener("abort", () => resolve(undefined), { once: true });
+        }),
+    ]);
+}
+export function installPermissionWrapper(session, host) {
+    const inner = session.agent.beforeToolCall;
+    const alwaysAllowed = new Set();
+    session.agent.beforeToolCall = async (context, signal) => {
+        const toolName = context.toolCall.name;
+        let block = false;
+        let reason;
+        if (!alwaysAllowed.has(toolName)) {
+            await host.drain();
+            const turnSignal = host.turnSignal() ?? signal ?? new AbortController().signal;
+            try {
+                const pending = host.client.request(methods.client.session.requestPermission, {
+                    sessionId: host.sessionId,
+                    toolCall: {
+                        toolCallId: context.toolCall.id,
+                        title: toolName,
+                        kind: mapKind(toolName),
+                        _meta: { toolName },
+                    },
+                    options: [
+                        { optionId: "allow_always", name: `Always allow ${toolName}`, kind: "allow_always" },
+                        { optionId: "allow_once", name: "Allow once", kind: "allow_once" },
+                        { optionId: "reject_once", name: "Reject", kind: "reject_once" },
+                    ],
+                }, { cancellationSignal: turnSignal });
+                const response = await raceSignal(pending, turnSignal);
+                if (response === undefined) {
+                    block = true;
+                    reason = "cancelled";
+                }
+                else if (typeof response.outcome !== "object" || response.outcome === null || !("outcome" in response.outcome)) {
+                    block = true;
+                    reason = "unrecognized permission selection";
+                }
+                else if (response.outcome.outcome === "cancelled") {
+                    block = true;
+                    reason = "cancelled";
+                }
+                else if (response.outcome.optionId === "allow_once") {
+                    block = false;
+                }
+                else if (response.outcome.optionId === "allow_always") {
+                    alwaysAllowed.add(toolName);
+                    block = false;
+                }
+                else if (response.outcome.optionId === "reject_once") {
+                    block = true;
+                    reason = "denied by user";
+                }
+                else {
+                    block = true;
+                    reason = "unrecognized permission selection";
+                }
+            }
+            catch {
+                block = true;
+                reason = "permission unavailable";
+            }
+        }
+        if (block)
+            return { block: true, reason };
+        return inner ? inner(context, signal) : undefined;
+    };
+}

package/dist/prompt-content.d.ts

@@ -0,0 +1,12 @@
+import type { ContentBlock } from "@agentclientprotocol/sdk";
+export interface PiImage {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface ConvertedPrompt {
+    text: string;
+    images: PiImage[];
+}
+export declare function convertPromptContent(blocks: readonly ContentBlock[]): ConvertedPrompt;
+//# sourceMappingURL=prompt-content.d.ts.map

package/dist/prompt-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-content.d.ts","sourceRoot":"","sources":["../src/prompt-content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,eAAe,CAmCrF"}

package/dist/prompt-content.js

@@ -0,0 +1,35 @@
+import { adapterError } from "./errors.js";
+export function convertPromptContent(blocks) {
+    const text = [];
+    const images = [];
+    for (const block of blocks) {
+        switch (block.type) {
+            case "text":
+                text.push(block.text);
+                break;
+            case "image":
+                images.push({ type: "image", data: block.data, mimeType: block.mimeType });
+                break;
+            case "resource_link":
+                text.push(`[${block.title ?? block.name ?? block.uri}](${block.uri})`);
+                break;
+            case "resource":
+                text.push("text" in block.resource
+                    ? block.resource.text
+                    : `[embedded resource: ${block.resource.uri}]`);
+                break;
+            case "audio":
+                text.push("[unsupported audio content omitted]");
+                break;
+            default: {
+                const exhaustive = block;
+                return exhaustive;
+            }
+        }
+    }
+    const joined = text.join("\n\n");
+    if (!text.some((segment) => segment.length > 0) && images.length === 0) {
+        throw adapterError("empty_prompt");
+    }
+    return { text: joined, images };
+}

package/dist/replay.d.ts

@@ -0,0 +1,4 @@
+import type { SessionUpdate } from "@agentclientprotocol/sdk";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+export declare function replayEntry(entry: SessionEntry): SessionUpdate[];
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../src/replay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAoGpE,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,EAAE,CAwBhE"}