@evandu/super-pi 0.0.0-stage → 0.1.1

package/dist/server/application/conversation-service.d.ts

@@ -0,0 +1,73 @@
+import { type Store } from "../store.js";
+import type { AgentRuntime } from "../runtime.js";
+import type { SubagentRunRecorder } from "../subagent-runs.js";
+import type { EventBroadcaster } from "../server-context.js";
+import type { CatalogService } from "./catalog-service.js";
+import type { RunService } from "./run-service.js";
+import type { ExtensionUiService } from "./extension-ui-service.js";
+export type ForkConversationResult = {
+    ok: true;
+    forkedId: string;
+    title: string;
+    messagesCopied: number;
+    piSessionFile?: string;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Service managing conversation lifecycle: creation, selection, archiving,
+ * model/thinking/agent configuration, message reversion, and session forking.
+ */
+export declare class ConversationService {
+    private readonly store;
+    private readonly runtime;
+    private readonly subagents;
+    private readonly broadcaster;
+    private readonly catalogService;
+    private readonly runService;
+    private readonly extensionUiService;
+    private readonly agentsDir;
+    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, agentsDir: string);
+    /**
+     * Creates a new conversation in a workspace.
+     */
+    createConversation(workspaceId: string): Promise<void>;
+    /**
+     * Selects a conversation and broadcasts the catalog for that conversation's model.
+     */
+    selectConversation(conversationId: string): Promise<void>;
+    /**
+     * Archives a conversation.
+     */
+    archiveConversation(conversationId: string): Promise<void>;
+    /**
+     * Unarchives a conversation.
+     */
+    unarchiveConversation(conversationId: string): Promise<void>;
+    /**
+     * Renames a conversation.
+     */
+    renameConversation(conversationId: string, name: string): Promise<void>;
+    /**
+     * Sets the active model on a conversation, validating against Pi's catalog.
+     */
+    setModel(conversationId: string, provider: string, modelId: string): Promise<void>;
+    /**
+     * Sets the thinking level on a conversation, validating against the model's available levels.
+     */
+    setThinking(conversationId: string, level: string): Promise<void>;
+    /**
+     * Configures or clears the primary agent assigned to a conversation.
+     */
+    setAgent(conversationId: string, agentId: string | null): Promise<void>;
+    /**
+     * Reverts conversation history to a designated message boundary, truncating both
+     * Pi's transcript and state.json.
+     */
+    revertMessage(conversationId: string, messageId: string): Promise<void>;
+    /**
+     * Forks an existing conversation into a new parallel branch, cloning the Pi session.
+     */
+    forkConversation(conversationId: string): Promise<ForkConversationResult>;
+}

package/dist/server/application/conversation-service.js

@@ -0,0 +1,202 @@
+import { newConversationId } from "../store.js";
+/**
+ * Service managing conversation lifecycle: creation, selection, archiving,
+ * model/thinking/agent configuration, message reversion, and session forking.
+ */
+export class ConversationService {
+    store;
+    runtime;
+    subagents;
+    broadcaster;
+    catalogService;
+    runService;
+    extensionUiService;
+    agentsDir;
+    constructor(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, agentsDir) {
+        this.store = store;
+        this.runtime = runtime;
+        this.subagents = subagents;
+        this.broadcaster = broadcaster;
+        this.catalogService = catalogService;
+        this.runService = runService;
+        this.extensionUiService = extensionUiService;
+        this.agentsDir = agentsDir;
+    }
+    /**
+     * Creates a new conversation in a workspace.
+     */
+    async createConversation(workspaceId) {
+        await this.store.createConversation(workspaceId);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Selects a conversation and broadcasts the catalog for that conversation's model.
+     */
+    async selectConversation(conversationId) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        await this.catalogService.broadcastCatalog(conversation?.model);
+    }
+    /**
+     * Archives a conversation.
+     */
+    async archiveConversation(conversationId) {
+        await this.store.archiveConversation(conversationId);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Unarchives a conversation.
+     */
+    async unarchiveConversation(conversationId) {
+        await this.store.unarchiveConversation(conversationId);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Renames a conversation.
+     */
+    async renameConversation(conversationId, name) {
+        await this.store.renameConversation(conversationId, name);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Sets the active model on a conversation, validating against Pi's catalog.
+     */
+    async setModel(conversationId, provider, modelId) {
+        const catalog = await this.runtime.catalog();
+        const option = catalog.source === "pi"
+            ? catalog.models.find((model) => model.provider === provider && model.modelId === modelId)
+            : undefined;
+        if (catalog.source === "pi" && !option) {
+            throw this.catalogService.notOffered(`模型 ${provider}/${modelId}`, catalog);
+        }
+        const selection = option
+            ? { provider: option.provider, modelId: option.modelId, label: option.label }
+            : { provider, modelId, label: modelId };
+        await this.store.setConversationModel(conversationId, selection);
+        this.broadcaster.broadcastState();
+        await this.catalogService.broadcastCatalog(selection);
+    }
+    /**
+     * Sets the thinking level on a conversation, validating against the model's available levels.
+     */
+    async setThinking(conversationId, level) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        const catalog = await this.runtime.catalog(conversation?.model);
+        if (catalog.source === "pi" && !catalog.levels.includes(level)) {
+            throw this.catalogService.notOffered(`思考等级 ${level}`, catalog);
+        }
+        await this.store.setConversationThinking(conversationId, level);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Configures or clears the primary agent assigned to a conversation.
+     */
+    async setAgent(conversationId, agentId) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            throw new Error("Conversation not found");
+        if (agentId === null) {
+            await this.store.setConversationAgent(conversationId, undefined);
+            this.broadcaster.broadcastState();
+            return;
+        }
+        const agent = await this.runtime.agentFor?.({ id: conversation.id, agentId });
+        if (!agent) {
+            throw new Error(`Agent ${JSON.stringify(agentId)} 不存在或不是可用的 primary agent（目录：${this.agentsDir}）`);
+        }
+        if (agent.model) {
+            const catalog = await this.runtime.catalog();
+            if (catalog.source === "pi" && !catalog.models.some((model) => model.provider === agent.model?.provider && model.modelId === agent.model?.modelId)) {
+                throw this.catalogService.notOffered(`Agent ${agent.name} 指定的模型 ${agent.model.provider}/${agent.model.modelId}`, catalog);
+            }
+            const option = catalog.models.find((model) => model.provider === agent.model?.provider && model.modelId === agent.model?.modelId);
+            await this.store.setConversationModel(conversationId, option
+                ? { provider: option.provider, modelId: option.modelId, label: option.label }
+                : { provider: agent.model.provider, modelId: agent.model.modelId, label: `${agent.model.provider}/${agent.model.modelId}` });
+        }
+        if (agent.thinkingLevel) {
+            const catalog = await this.runtime.catalog(this.store.snapshot().conversations.find((item) => item.id === conversationId)?.model);
+            if (catalog.source === "pi" && !catalog.levels.includes(agent.thinkingLevel)) {
+                throw this.catalogService.notOffered(`Agent ${agent.name} 指定的思考等级 ${agent.thinkingLevel}`, catalog);
+            }
+            await this.store.setConversationThinking(conversationId, agent.thinkingLevel);
+        }
+        await this.store.setConversationAgent(conversationId, agent.id);
+        this.broadcaster.broadcastState();
+        await this.catalogService.broadcastCatalog(this.store.snapshot().conversations.find((item) => item.id === conversationId)?.model);
+    }
+    /**
+     * Reverts conversation history to a designated message boundary, truncating both
+     * Pi's transcript and state.json.
+     */
+    async revertMessage(conversationId, messageId) {
+        const plan = this.store.planRevert(conversationId, messageId);
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            throw new Error("会话不存在");
+        const workspace = this.store.snapshot().workspaces.find((item) => item.id === conversation.workspaceId);
+        if (!workspace)
+            throw new Error(`会话所属的工作区 ${conversation.workspaceId} 已不存在，拒绝回退`);
+        if (!this.runtime.revert) {
+            throw new Error("当前运行时没有 Pi 会话，无法回退消息");
+        }
+        if (this.runService.isRunning(conversationId)) {
+            this.extensionUiService.cancelPendingUi(conversationId, "aborted");
+            await this.runService.stopRun(conversationId);
+        }
+        for (const runId of plan.doomedRunIds) {
+            if (this.subagents.stop(runId)) {
+                console.log(`Super Pi: stopped sub-agent run ${runId}, whose turn was reverted away.`);
+            }
+        }
+        const outcome = await this.runtime.revert({
+            conversation,
+            cwd: workspace.path,
+            boundaryEntryId: plan.boundaryEntryId,
+        });
+        const applied = await this.store.revertMessages(conversationId, messageId);
+        console.log(`Super Pi: reverted conversation ${conversationId} to ${applied.boundaryIndex + 1} message(s): ` +
+            `${plan.removedMessageIds.length} message(s) and ${applied.doomedRunIds.length} sub-agent run(s) dropped from state.json; ` +
+            `Pi's file ${outcome.sessionFile} kept ${outcome.linesKept} line(s) and lost ${outcome.entriesDropped}.`);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Forks an existing conversation into a new parallel branch, cloning the Pi session.
+     */
+    async forkConversation(conversationId) {
+        const snapshot = this.store.snapshot();
+        const conversation = snapshot.conversations.find((item) => item.id === conversationId);
+        if (!conversation) {
+            return { ok: false, message: "会话不存在" };
+        }
+        const workspace = snapshot.workspaces.find((item) => item.id === conversation.workspaceId);
+        if (!workspace) {
+            return { ok: false, message: `会话所属的工作区 ${conversation.workspaceId} 已不存在，拒绝分叉` };
+        }
+        if (this.runService.isRunning(conversationId)) {
+            return { ok: false, message: "这个会话还有一轮任务在跑，等它结束（或先停止它）再分叉" };
+        }
+        if (!this.runtime.fork) {
+            return { ok: false, message: "当前运行时没有 Pi 会话，无法分叉（只能复制可见的历史）" };
+        }
+        try {
+            const forkedId = newConversationId();
+            const outcome = await this.runtime.fork({ conversation, cwd: workspace.path, forkedConversationId: forkedId });
+            const forked = await this.store.forkConversation(conversationId, forkedId);
+            console.log(`Super Pi: forked conversation ${conversation.id} into ${forked.id}: ` +
+                `${forked.messages.length} message(s) copied in state.json` +
+                `${outcome.sessionFile ? `, ${outcome.entriesCopied} Pi entry/entries copied to ${outcome.sessionFile}` : ", and this conversation had no Pi transcript to copy (no messages)"}.`);
+            this.broadcaster.broadcastState();
+            return {
+                ok: true,
+                forkedId: forked.id,
+                title: forked.title,
+                messagesCopied: forked.messages.length,
+                piSessionFile: outcome.sessionFile,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : `分叉失败：${String(error)}`;
+            return { ok: false, message };
+        }
+    }
+}

package/dist/server/application/extension-ui-service.d.ts

@@ -0,0 +1,28 @@
+import type { ExtensionUiHost } from "../runtime.js";
+import type { ExtensionUiAnswer, ExtensionUiCloseReason } from "../types.js";
+import type { EventBroadcaster } from "../server-context.js";
+/**
+ * Service managing extension UI interactive prompts between Pi / subagents and connected clients.
+ */
+export declare class ExtensionUiService {
+    private readonly broadcaster;
+    private readonly pendingUi;
+    constructor(broadcaster: EventBroadcaster);
+    private uiKey;
+    /**
+     * Settles a pending UI request by answering, timing out, or aborting.
+     */
+    settleUi(key: string, answer: ExtensionUiAnswer, reason: ExtensionUiCloseReason): boolean;
+    /**
+     * Responds to an extension UI question from the client.
+     */
+    answerUi(conversationId: string, requestId: string, answer: ExtensionUiAnswer): boolean;
+    /**
+     * Cancels any pending UI requests for a given conversation.
+     */
+    cancelPendingUi(conversationId: string, reason: ExtensionUiCloseReason): void;
+    /**
+     * Creates an ExtensionUiHost interface for a conversation or subagent run.
+     */
+    createHost(conversationId: string, runId?: string): ExtensionUiHost;
+}

package/dist/server/application/extension-ui-service.js

@@ -0,0 +1,73 @@
+/**
+ * Service managing extension UI interactive prompts between Pi / subagents and connected clients.
+ */
+export class ExtensionUiService {
+    broadcaster;
+    pendingUi = new Map();
+    constructor(broadcaster) {
+        this.broadcaster = broadcaster;
+    }
+    uiKey(conversationId, requestId) {
+        return `${conversationId}\u0000${requestId}`;
+    }
+    /**
+     * Settles a pending UI request by answering, timing out, or aborting.
+     */
+    settleUi(key, answer, reason) {
+        const pending = this.pendingUi.get(key);
+        if (!pending) {
+            console.warn(`Super Pi: Extension UI answer for ${key.replace("\u0000", "/")} arrived after that request was already closed - ignored, no second reply sent.`);
+            return false;
+        }
+        this.pendingUi.delete(key);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        pending.resolve(answer);
+        this.broadcaster.broadcast({
+            type: "extension.ui.closed",
+            conversationId: pending.conversationId,
+            requestId: pending.request.requestId,
+            reason,
+        });
+        return true;
+    }
+    /**
+     * Responds to an extension UI question from the client.
+     */
+    answerUi(conversationId, requestId, answer) {
+        return this.settleUi(this.uiKey(conversationId, requestId), answer, answer.cancelled ? "cancelled" : "answered");
+    }
+    /**
+     * Cancels any pending UI requests for a given conversation.
+     */
+    cancelPendingUi(conversationId, reason) {
+        for (const [key, pending] of [...this.pendingUi]) {
+            if (pending.conversationId === conversationId) {
+                this.settleUi(key, { cancelled: true }, reason);
+            }
+        }
+    }
+    /**
+     * Creates an ExtensionUiHost interface for a conversation or subagent run.
+     */
+    createHost(conversationId, runId) {
+        const scoped = (request) => runId ? { ...request, requestId: `${runId}:${request.requestId}` } : request;
+        return {
+            notify: (request) => {
+                this.broadcaster.broadcast({ type: "extension.ui", conversationId, request: scoped(request) });
+            },
+            ask: (request) => new Promise((resolve) => {
+                const shown = scoped(request);
+                const key = this.uiKey(conversationId, shown.requestId);
+                const pending = { conversationId, request: shown, resolve };
+                if (shown.timeoutMs !== undefined) {
+                    pending.timer = setTimeout(() => {
+                        this.settleUi(key, { cancelled: true }, "timeout");
+                    }, shown.timeoutMs);
+                }
+                this.pendingUi.set(key, pending);
+                this.broadcaster.broadcast({ type: "extension.ui", conversationId, request: shown });
+            }),
+        };
+    }
+}

package/dist/server/application/run-service.d.ts

@@ -0,0 +1,115 @@
+import type { Store } from "../store.js";
+import type { AgentRuntime } from "../runtime.js";
+import type { SubagentRunRecorder } from "../subagent-runs.js";
+import type { Conversation, Message, MessageImage, PiQueueSnapshot, Workspace } from "../types.js";
+import type { EventBroadcaster } from "../server-context.js";
+import type { ExtensionUiService } from "./extension-ui-service.js";
+export interface SubagentDispatchRequestBody {
+    conversationId?: string;
+    subagent_type?: string;
+    prompt?: string;
+    depth?: number;
+    parentRunId?: string;
+    background?: boolean;
+    description?: string;
+    loopId?: string;
+    role?: string;
+}
+/**
+ * Service managing execution of conversation turns, message queueing,
+ * follow-ups, and sub-agent dispatching.
+ */
+export declare class RunService {
+    private readonly store;
+    private readonly runtime;
+    private readonly subagents;
+    private readonly broadcaster;
+    private readonly extensionUiService;
+    private readonly activeRuns;
+    constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService);
+    /**
+     * Resolves the conversation and workspace synchronously for a run.
+     */
+    turnContext(conversationId: string): {
+        conversation: Conversation;
+        workspace: Workspace;
+    };
+    /**
+     * Resolves conversation and workspace working directory for subagent dispatch.
+     */
+    dispatchContext(conversationId: string): {
+        conversation: Conversation;
+        cwd: string;
+    };
+    /**
+     * Checks whether a conversation has an active turn running.
+     */
+    isRunning(conversationId: string): boolean;
+    /**
+     * Aborts all active conversation runs and sub-agents.
+     */
+    abortAll(): void;
+    /**
+     * Stops an active turn run for a conversation.
+     */
+    stopRun(conversationId: string): Promise<void>;
+    /**
+     * Handles queue snapshot updates from Pi RPC.
+     */
+    onPiQueue(conversationId: string, snapshot: PiQueueSnapshot): void;
+    /**
+     * Opens a turn by creating user and assistant messages in store.
+     */
+    openTurn(conversationId: string, prompt?: string, images?: MessageImage[]): Promise<{
+        user: Message;
+        assistant: Message;
+    }>;
+    /**
+     * Streams a turn via AgentRuntime.
+     */
+    streamTurn(conversation: Conversation, workspace: Workspace, prompt: string, assistant: Message, controller: AbortController, userMessageId: string, images?: MessageImage[]): Promise<void>;
+    /**
+     * Loops running turns for as long as queued follow-ups exist.
+     */
+    runConversationTurns(conversation: Conversation, workspace: Workspace, prompt: string, controller: AbortController, initialImages?: MessageImage[]): Promise<void>;
+    /**
+     * Enqueues or starts execution for a user message.
+     */
+    enqueueAndRun(conversationId: string, content: string, images?: MessageImage[]): Promise<void>;
+    /**
+     * Steers a queued message into the in-flight turn.
+     */
+    steer(conversationId: string, queueId: string): Promise<void>;
+    /**
+     * Cancels a queued message.
+     */
+    cancelQueued(conversationId: string, queueId: string): Promise<void>;
+    /**
+     * Dispatches a subagent from client command (human dispatch).
+     */
+    dispatchSubagent(params: {
+        conversationId: string;
+        agentId: string;
+        task: string;
+    }): Promise<void>;
+    /**
+     * Dispatches a subagent task requested by the task tool HTTP endpoint.
+     */
+    dispatchTask(body: SubagentDispatchRequestBody): Promise<{
+        mode: "sync";
+        status: number;
+        body: unknown;
+    } | {
+        mode: "async";
+        status: number;
+        body: unknown;
+    }>;
+    /**
+     * Stops a specific subagent run by runId.
+     */
+    stopSubagent(runId: string): void;
+    /**
+     * Stops all subagent runs belonging to a conversation.
+     */
+    stopConversationSubagents(conversationId: string): number;
+}