@otto-code/server 0.5.0

package/dist/server/server/agent/providers/pi/cli-runtime.d.ts

@@ -0,0 +1,21 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Logger } from "pino";
+import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { type PiRuntime, type PiRuntimeLaunch, type PiRuntimeSession, type PiStartSessionInput } from "./runtime.js";
+import type { PiCommandsRpcType } from "./rpc-types.js";
+export interface PiCliRuntimeOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    command?: [string, ...string[]];
+    commandsRpcType?: PiCommandsRpcType;
+    spawnProcess?: (launch: PiRuntimeLaunch) => ChildProcessWithoutNullStreams;
+}
+export declare class PiCliRuntime implements PiRuntime {
+    private readonly options;
+    private readonly command;
+    private readonly commandsRpcType;
+    private readonly spawnProcess;
+    constructor(options: PiCliRuntimeOptions);
+    startSession(input: PiStartSessionInput): Promise<PiRuntimeSession>;
+}
+//# sourceMappingURL=cli-runtime.d.ts.map

package/dist/server/server/agent/providers/pi/cli-runtime.js

@@ -0,0 +1,261 @@
+import { spawnProcess } from "../../../../utils/spawn.js";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
+import { buildPiLaunch, } from "./runtime.js";
+const DEFAULT_PI_COMMAND = [
+    process.env.PI_COMMAND ?? process.env.PI_ACP_PI_COMMAND ?? "pi",
+];
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_COMMANDS_RPC_TYPE = "get_commands";
+const STDERR_BUFFER_LIMIT = 8192;
+const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
+const FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
+function assertChildWithPipes(child) {
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("Pi process was spawned without stdio streams");
+    }
+}
+export class PiCliRuntime {
+    constructor(options) {
+        this.options = options;
+        this.command = options.command ?? DEFAULT_PI_COMMAND;
+        this.commandsRpcType = options.commandsRpcType ?? DEFAULT_COMMANDS_RPC_TYPE;
+        this.spawnProcess =
+            options.spawnProcess ??
+                ((launch) => {
+                    const [command, ...args] = launch.argv;
+                    const child = spawnProcess(command, args, {
+                        cwd: launch.cwd,
+                        envOverlay: launch.env,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                    assertChildWithPipes(child);
+                    return child;
+                });
+    }
+    async startSession(input) {
+        const launch = buildPiLaunch({
+            command: this.command,
+            runtimeSettings: this.options.runtimeSettings,
+            session: input,
+        });
+        return new PiCliRuntimeSession(launch, this.spawnProcess(launch), this.options.logger, this.commandsRpcType);
+    }
+}
+class PiCliRuntimeSession {
+    constructor(_launch, child, logger, commandsRpcType) {
+        this.child = child;
+        this.logger = logger;
+        this.commandsRpcType = commandsRpcType;
+        this.pending = new Map();
+        this.subscribers = new Set();
+        this.stderrBuffer = "";
+        this.nextRequestId = 1;
+        this.disposed = false;
+        this.stdoutBuffer = "";
+        child.stdout.on("data", (chunk) => {
+            this.handleStdoutChunk(chunk.toString());
+        });
+        child.stderr.on("data", (chunk) => {
+            this.stderrBuffer += chunk.toString();
+            if (this.stderrBuffer.length > STDERR_BUFFER_LIMIT) {
+                this.stderrBuffer = this.stderrBuffer.slice(-STDERR_BUFFER_LIMIT);
+            }
+        });
+        child.on("error", (error) => {
+            this.failAll(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.on("exit", (code, signal) => {
+            const error = new Error(`Pi RPC process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderrBuffer}`.trim());
+            this.emit({ type: "process_exit", error: error.message });
+            this.failAll(error);
+        });
+    }
+    onEvent(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    async prompt(message, images) {
+        await this.request({ type: "prompt", message, ...(images?.length ? { images } : {}) });
+    }
+    async compact(customInstructions) {
+        await this.request({
+            type: "compact",
+            ...(customInstructions ? { customInstructions } : {}),
+        });
+    }
+    async setAutoCompaction(enabled) {
+        await this.request({ type: "set_auto_compaction", enabled });
+    }
+    async abort() {
+        await this.request({ type: "abort" });
+    }
+    async getState() {
+        return (await this.request({ type: "get_state" }));
+    }
+    async getMessages() {
+        const data = (await this.request({ type: "get_messages" }));
+        return data.messages ?? [];
+    }
+    async getAvailableModels(timeoutMs) {
+        const data = (await this.request({ type: "get_available_models" }, timeoutMs));
+        return data.models ?? [];
+    }
+    async setModel(provider, modelId) {
+        return (await this.request({ type: "set_model", provider, modelId }));
+    }
+    async setThinkingLevel(level) {
+        await this.request({ type: "set_thinking_level", level: level });
+    }
+    async getSessionStats() {
+        // COMPAT(piGetStateFallback): added in v0.1.X — older Oh My Pi binaries
+        // lack the `get_session_stats` RPC command; fall back to extracting
+        // context window usage from `get_state`. Drop this gate when the floor
+        // daemon supports get_session_stats (added ~v0.1.97).
+        let stats;
+        try {
+            stats = (await this.request({ type: "get_session_stats" }));
+        }
+        catch {
+            // get_session_stats not supported by this binary — will try get_state below
+        }
+        if (stats?.tokens == null && stats?.cost == null && stats?.contextUsage == null) {
+            try {
+                const state = (await this.request({ type: "get_state" }));
+                const ctx = state.contextUsage;
+                if (ctx) {
+                    return {
+                        contextUsage: {
+                            tokens: typeof ctx.tokens === "number" ? ctx.tokens : undefined,
+                            contextWindow: typeof ctx.contextWindow === "number" ? ctx.contextWindow : undefined,
+                        },
+                    };
+                }
+            }
+            catch {
+                // get_state also failed — nothing we can do
+            }
+        }
+        return stats ?? {};
+    }
+    async getCommands() {
+        const data = (await this.request({ type: this.commandsRpcType }));
+        return data.commands ?? [];
+    }
+    respondToExtensionUiRequest(id, response) {
+        this.writeJsonLine({ type: "extension_ui_response", id, ...response });
+    }
+    cancelExtensionUiRequest(id) {
+        this.respondToExtensionUiRequest(id, { cancelled: true });
+    }
+    async close() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.child.stdin.end();
+        }
+        catch {
+            // ignore
+        }
+        const result = await terminateWithTreeKill(this.child, {
+            gracefulTimeoutMs: GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+            forceTimeoutMs: FORCE_SHUTDOWN_TIMEOUT_MS,
+            onForceSignal: () => {
+                this.logger.warn({ timeoutMs: GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "Pi RPC process did not exit after SIGTERM; sending SIGKILL");
+            },
+        });
+        if (result === "kill-timeout") {
+            this.logger.warn({ timeoutMs: FORCE_SHUTDOWN_TIMEOUT_MS }, "Pi RPC process did not report exit after SIGKILL");
+        }
+    }
+    request(command, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (this.disposed) {
+            return Promise.reject(new Error("Pi RPC session is closed"));
+        }
+        const id = `req_${this.nextRequestId}`;
+        this.nextRequestId += 1;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Pi RPC request timed out for ${command.type}\n${this.stderrBuffer}`.trim()));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.writeJsonLine({ ...command, id });
+        });
+    }
+    writeJsonLine(value) {
+        if (this.disposed || this.child.stdin.destroyed || !this.child.stdin.writable) {
+            return;
+        }
+        this.child.stdin.write(`${JSON.stringify(value)}\n`);
+    }
+    handleStdoutChunk(chunk) {
+        this.stdoutBuffer += chunk;
+        for (;;) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = this.stdoutBuffer.slice(0, newlineIndex).replace(/\r$/, "");
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (line.trim()) {
+                this.handleLine(line);
+            }
+        }
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            this.logger.warn({ error, line }, "Ignoring non-JSON Pi RPC stdout line");
+            return;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return;
+        }
+        const message = parsed;
+        if (message.type === "response") {
+            this.handleResponse(message);
+            return;
+        }
+        this.emit(message);
+    }
+    handleResponse(response) {
+        const id = response.id;
+        if (!id) {
+            return;
+        }
+        const pending = this.pending.get(id);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+        if (!response.success) {
+            pending.reject(new Error(response.error ?? `Pi RPC ${response.command} failed`));
+            return;
+        }
+        pending.resolve(response.data);
+    }
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+    failAll(error) {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+//# sourceMappingURL=cli-runtime.js.map

package/dist/server/server/agent/providers/pi/history-mapper.d.ts

@@ -0,0 +1,9 @@
+import type { AgentStreamEvent } from "../../agent-sdk-types.js";
+import type { PiAgentMessage, PiImageContent, PiTextContent } from "./rpc-types.js";
+export interface PiCapturedUserMessageEntry {
+    id: string;
+    text: string;
+}
+export declare function getUserMessageText(content: string | (PiTextContent | PiImageContent)[]): string;
+export declare function streamPiHistory(provider: string, messages: PiAgentMessage[], userEntries?: readonly PiCapturedUserMessageEntry[]): AsyncGenerator<AgentStreamEvent>;
+//# sourceMappingURL=history-mapper.d.ts.map

package/dist/server/server/agent/providers/pi/history-mapper.js

@@ -0,0 +1,140 @@
+import { extractTextFromToolResult, mapToolDetail, parseToolArgs, parseToolResult, } from "./tool-call-mapper.js";
+function isTextContentBlock(block) {
+    return (typeof block === "object" &&
+        block !== null &&
+        !Array.isArray(block) &&
+        Reflect.get(block, "type") === "text" &&
+        typeof Reflect.get(block, "text") === "string");
+}
+export function getUserMessageText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const textParts = [];
+    for (const block of content) {
+        if (isTextContentBlock(block)) {
+            textParts.push(block.text);
+        }
+    }
+    return textParts.join("\n\n");
+}
+export async function* streamPiHistory(provider, messages, userEntries = []) {
+    const pendingToolCalls = new Map();
+    let userIndex = 0;
+    for (const message of messages) {
+        if (message.role === "user") {
+            const text = getUserMessageText(message.content);
+            if (text) {
+                const userEntry = userEntries[userIndex];
+                yield {
+                    type: "timeline",
+                    provider,
+                    item: {
+                        type: "user_message",
+                        text,
+                        ...(userEntry ? { messageId: userEntry.id } : {}),
+                    },
+                };
+            }
+            userIndex += 1;
+            continue;
+        }
+        if (message.role === "assistant") {
+            for (const content of message.content) {
+                if (content.type === "text" && content.text) {
+                    yield {
+                        type: "timeline",
+                        provider,
+                        item: { type: "assistant_message", text: content.text },
+                    };
+                    continue;
+                }
+                if (content.type === "thinking" && content.thinking) {
+                    yield {
+                        type: "timeline",
+                        provider,
+                        item: { type: "reasoning", text: content.thinking },
+                    };
+                    continue;
+                }
+                if (content.type === "toolCall") {
+                    const tracked = parseToolArgs(content.name, content.arguments);
+                    pendingToolCalls.set(content.id, tracked);
+                    yield {
+                        type: "timeline",
+                        provider,
+                        item: {
+                            type: "tool_call",
+                            callId: content.id,
+                            name: tracked.toolName,
+                            status: "running",
+                            detail: mapToolDetail(tracked, null),
+                            error: null,
+                        },
+                    };
+                }
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            const tracked = pendingToolCalls.get(message.toolCallId) ?? parseToolArgs(message.toolName, null);
+            pendingToolCalls.delete(message.toolCallId);
+            const result = parseToolResult({ content: message.content });
+            const detail = mapToolDetail(tracked, result);
+            yield {
+                type: "timeline",
+                provider,
+                item: toToolResultTimelineItem({
+                    callId: message.toolCallId,
+                    name: tracked.toolName,
+                    isError: Boolean(message.isError),
+                    detail,
+                    errorText: extractTextFromToolResult(result) ?? "Tool call failed",
+                }),
+            };
+            continue;
+        }
+        if (message.role === "bashExecution") {
+            const callId = `pi-bash-${message.timestamp}`;
+            const detail = {
+                type: "shell",
+                command: message.command,
+                output: message.output,
+                exitCode: message.exitCode ?? null,
+            };
+            yield {
+                type: "timeline",
+                provider,
+                item: {
+                    type: "tool_call",
+                    callId,
+                    name: "bash",
+                    status: message.cancelled ? "canceled" : "completed",
+                    detail,
+                    error: null,
+                },
+            };
+        }
+    }
+}
+function toToolResultTimelineItem(input) {
+    if (input.isError) {
+        return {
+            type: "tool_call",
+            callId: input.callId,
+            name: input.name,
+            status: "failed",
+            detail: input.detail,
+            error: input.errorText,
+        };
+    }
+    return {
+        type: "tool_call",
+        callId: input.callId,
+        name: input.name,
+        status: "completed",
+        detail: input.detail,
+        error: null,
+    };
+}
+//# sourceMappingURL=history-mapper.js.map

package/dist/server/server/agent/providers/pi/rewind.d.ts

@@ -0,0 +1,8 @@
+export interface PiRewindNavigator {
+    navigateTree(targetId: string): Promise<unknown>;
+}
+export declare function revertPiConversation(input: {
+    messageId: string;
+    navigator: PiRewindNavigator;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

package/dist/server/server/agent/providers/pi/rewind.js

@@ -0,0 +1,8 @@
+export async function revertPiConversation(input) {
+    const targetId = input.messageId.trim();
+    if (!targetId) {
+        throw new Error("Pi rewind requires a user message id");
+    }
+    await input.navigator.navigateTree(targetId);
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -0,0 +1,208 @@
+export type PiThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export interface PiImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface PiTextContent {
+    type: "text";
+    text: string;
+}
+export interface PiThinkingContent {
+    type: "thinking";
+    thinking: string;
+}
+export interface PiToolCallContent {
+    type: "toolCall";
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+export type PiAssistantContent = PiTextContent | PiThinkingContent | PiToolCallContent;
+export type PiAgentMessage = {
+    role: "user";
+    content: string | Array<PiTextContent | PiImageContent>;
+} | {
+    role: "custom";
+    content: string | Array<PiTextContent | PiImageContent>;
+} | {
+    role: "assistant";
+    content: PiAssistantContent[];
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    responseModel?: string;
+    errorMessage?: string | null;
+    stopReason?: string;
+} | {
+    role: "toolResult";
+    toolCallId: string;
+    toolName: string;
+    content: unknown;
+    isError?: boolean;
+} | {
+    role: "bashExecution";
+    command: string;
+    output?: string;
+    exitCode?: number | null;
+    cancelled?: boolean;
+    timestamp: number;
+};
+export interface PiModel {
+    provider: string;
+    id: string;
+    name?: string;
+    reasoning?: boolean;
+    contextWindow?: number;
+    maxTokens?: number;
+    api?: string;
+    baseUrl?: string;
+    input?: string[];
+    cost?: Record<string, unknown>;
+    compat?: unknown;
+}
+export interface PiSessionState {
+    model?: PiModel | null;
+    thinkingLevel: PiThinkingLevel;
+    isStreaming: boolean;
+    isCompacting: boolean;
+    autoCompactionEnabled?: boolean;
+    sessionFile?: string;
+    sessionId: string;
+    sessionName?: string;
+    messageCount: number;
+    pendingMessageCount: number;
+}
+export interface PiSessionStats {
+    tokens?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        total?: number;
+    };
+    cost?: number;
+    contextUsage?: {
+        tokens?: number | null;
+        contextWindow?: number | null;
+        percent?: number | null;
+    };
+}
+export interface PiRpcSlashCommand {
+    name: string;
+    description?: string;
+    source: "extension" | "prompt" | "skill";
+    sourceInfo?: Record<string, unknown>;
+}
+export type PiCommandsRpcType = "get_commands" | "get_available_commands";
+export type PiRpcCommand = {
+    id?: string;
+    type: "prompt";
+    message: string;
+    images?: PiImageContent[];
+} | {
+    id?: string;
+    type: "compact";
+    customInstructions?: string;
+} | {
+    id?: string;
+    type: "set_auto_compaction";
+    enabled: boolean;
+} | {
+    id?: string;
+    type: "abort";
+} | {
+    id?: string;
+    type: "get_state";
+} | {
+    id?: string;
+    type: "get_messages";
+} | {
+    id?: string;
+    type: "get_available_models";
+} | {
+    id?: string;
+    type: "set_model";
+    provider: string;
+    modelId: string;
+} | {
+    id?: string;
+    type: "set_thinking_level";
+    level: PiThinkingLevel;
+} | {
+    id?: string;
+    type: "get_session_stats";
+} | {
+    id?: string;
+    type: PiCommandsRpcType;
+};
+export interface PiRpcResponse {
+    id?: string;
+    type: "response";
+    command: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export type PiAssistantMessageEvent = {
+    type: "text_delta";
+    delta?: string;
+} | {
+    type: "thinking_delta";
+    delta?: string;
+} | {
+    type: "start" | "text_start" | "text_end" | "thinking_start" | "thinking_end" | "done";
+};
+export type PiAgentSessionEvent = {
+    type: "agent_start";
+} | {
+    type: "turn_start";
+} | {
+    type: "message_start";
+    message: PiAgentMessage;
+} | {
+    type: "message_end";
+    message: PiAgentMessage;
+} | {
+    type: "message_update";
+    message: PiAgentMessage;
+    assistantMessageEvent: PiAssistantMessageEvent;
+} | {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args?: unknown;
+    partialResult: unknown;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+} | {
+    type: "compaction_start";
+    reason?: "manual" | "threshold" | "overflow" | string;
+} | {
+    type: "compaction_end";
+    reason?: string;
+    errorMessage?: string;
+    aborted?: boolean;
+} | {
+    type: "agent_end";
+    messages?: PiAgentMessage[];
+};
+export type PiRuntimeEvent = PiAgentSessionEvent | {
+    type: "extension_ui_request";
+    id: string;
+    method: string;
+    [key: string]: unknown;
+} | {
+    type: "process_exit";
+    error: string;
+};
+//# sourceMappingURL=rpc-types.d.ts.map

package/dist/server/server/agent/providers/pi/rpc-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rpc-types.js.map