@akira-tl/forgerelay 0.6.1 → 0.7.1

package/dist/subagents/providers/adapters/pi.js

@@ -0,0 +1,232 @@
+import { spawn } from "node:child_process";
+import { removeDevspaceNodeModulesBinFromPath } from "../path.js";
+import { asRecord, assertPipedChild, errorMessage, readArray, readNestedString, requireFinalResponse, unwrapProviderPayload, } from "../shared.js";
+const PI_AGENT_TIMEOUT_MS = 120_000;
+export class PiRpcSubagentAdapter {
+    provider = "pi";
+    async run(input) {
+        const args = ["--mode", "rpc"];
+        if (input.model)
+            args.push("--model", input.model);
+        if (input.thinking)
+            args.push("--thinking", input.thinking);
+        if (input.providerSessionId)
+            args.push("--session", input.providerSessionId);
+        const child = spawn(process.env.PI_COMMAND ?? "pi", args, {
+            cwd: input.workspace,
+            env: piCommandEnvironment(process.env),
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        assertPipedChild(child);
+        const rpc = new JsonLineRpc(child);
+        let streamingText = "";
+        let streamingProviderError = "";
+        rpc.onEvent((event) => {
+            const text = extractPiStreamingText([event]);
+            if (text)
+                streamingText += text;
+            const providerError = extractPiProviderError(event);
+            if (providerError)
+                streamingProviderError = providerError;
+        });
+        try {
+            const state = await rpc.request({ type: "get_state" });
+            const providerSessionId = readNestedString(state, ["sessionId"]) ?? input.providerSessionId ?? null;
+            const done = rpc.waitForEvent((event) => asRecord(event)?.type === "agent_end", PI_AGENT_TIMEOUT_MS);
+            await rpc.request({ type: "prompt", message: input.prompt });
+            const agentEnd = await done;
+            const sessionMessages = await rpc.request({ type: "get_messages" });
+            const finalResponse = extractPiFinalResponse(agentEnd) ||
+                extractPiFinalResponse(sessionMessages) ||
+                streamingText.trim();
+            if (!finalResponse) {
+                const providerError = extractPiProviderError(agentEnd) ||
+                    extractPiProviderError(sessionMessages) ||
+                    streamingProviderError;
+                if (providerError)
+                    throw new Error(`Pi returned an error: ${providerError}`);
+            }
+            requireFinalResponse("Pi", finalResponse);
+            return {
+                provider: this.provider,
+                providerSessionId,
+                finalResponse,
+            };
+        }
+        finally {
+            child.kill();
+        }
+    }
+}
+export function piCommandEnvironment(env) {
+    if (env.PI_COMMAND)
+        return env;
+    const path = env.PATH;
+    if (!path)
+        return env;
+    return {
+        ...env,
+        PATH: removeDevspaceNodeModulesBinFromPath(path),
+    };
+}
+class JsonLineRpc {
+    child;
+    pending = new Map();
+    eventSubscribers = new Set();
+    buffer = "";
+    nextId = 1;
+    stderr = "";
+    fatalError;
+    constructor(child) {
+        this.child = child;
+        child.stdout.on("data", (chunk) => this.handleStdout(chunk.toString("utf8")));
+        child.stderr.on("data", (chunk) => {
+            this.stderr += chunk.toString("utf8");
+        });
+        child.on("exit", (code, signal) => {
+            this.failAll(new Error(`Pi RPC process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderr}`.trim()));
+        });
+    }
+    request(command) {
+        if (this.fatalError) {
+            return Promise.reject(this.fatalError);
+        }
+        const id = `req_${this.nextId}`;
+        this.nextId += 1;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.child.stdin.write(`${JSON.stringify({ ...command, id })}\n`);
+        });
+    }
+    onEvent(callback) {
+        this.eventSubscribers.add(callback);
+        return () => this.eventSubscribers.delete(callback);
+    }
+    waitForEvent(predicate, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                unsubscribe();
+                reject(new Error(`Pi RPC timed out waiting for agent completion\n${this.stderr}`.trim()));
+            }, timeoutMs);
+            const unsubscribe = this.onEvent((event) => {
+                if (!predicate(event))
+                    return;
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(event);
+            });
+        });
+    }
+    handleStdout(chunk) {
+        this.buffer += chunk;
+        for (;;) {
+            const newline = this.buffer.indexOf("\n");
+            if (newline === -1)
+                return;
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                this.stderr += `${line}\n`;
+                this.failAll(new Error(`Pi RPC emitted malformed JSON on stdout: ${line}`));
+                return;
+            }
+            if (message.type !== "response") {
+                for (const subscriber of this.eventSubscribers)
+                    subscriber(message);
+                continue;
+            }
+            const id = typeof message.id === "string" ? message.id : undefined;
+            if (!id)
+                continue;
+            const pending = this.pending.get(id);
+            if (!pending)
+                continue;
+            this.pending.delete(id);
+            if (message.success === false || message.error) {
+                pending.reject(new Error(errorMessage(message.error ?? `Pi RPC request failed: ${message.command ?? id}`)));
+            }
+            else {
+                pending.resolve(message.data ?? message.result ?? message);
+            }
+        }
+    }
+    failAll(error) {
+        this.fatalError = error;
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+export function extractPiFinalResponse(value) {
+    const root = unwrapProviderPayload(value);
+    const messages = Array.isArray(root) ? root : readArray(root, "messages");
+    if (!messages)
+        return "";
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = asRecord(messages[index]);
+        if (!message || message.role !== "assistant")
+            continue;
+        const text = extractPiAssistantMessageText(message);
+        if (text)
+            return text;
+    }
+    return "";
+}
+export function extractPiStreamingText(events) {
+    return events
+        .map((event) => {
+        const record = asRecord(event);
+        if (!record || record.type !== "message_update")
+            return "";
+        const update = asRecord(record.assistantMessageEvent);
+        if (!update || update.type !== "text_delta")
+            return "";
+        return typeof update.delta === "string" ? update.delta : "";
+    })
+        .filter(Boolean)
+        .join("")
+        .trim();
+}
+export function extractPiProviderError(value) {
+    const root = unwrapProviderPayload(value);
+    if (Array.isArray(root)) {
+        for (let index = root.length - 1; index >= 0; index -= 1) {
+            const error = extractPiProviderError(root[index]);
+            if (error)
+                return error;
+        }
+        return "";
+    }
+    const messages = readArray(root, "messages");
+    if (messages)
+        return extractPiProviderError(messages);
+    const message = asRecord(root)?.message ?? root;
+    const record = asRecord(message);
+    if (!record)
+        return "";
+    const error = record.errorMessage ?? record.error;
+    return typeof error === "string" ? error.trim() : "";
+}
+function extractPiAssistantMessageText(message) {
+    const content = message.content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        const partRecord = asRecord(part);
+        if (!partRecord || partRecord.type !== "text")
+            return "";
+        return typeof partRecord.text === "string" ? partRecord.text : "";
+    })
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+}

package/dist/{local-agent-availability.js → subagents/providers/availability.js}

@@ -1,11 +1,12 @@
 import { spawnSync } from "node:child_process";
 import { delimiter, resolve } from "node:path";
-import { removeDevspaceNodeModulesBinFromPath } from "./local-agent-path.js";
-import { LOCAL_AGENT_PROVIDERS, } from "./local-agent-profiles.js";
-export function getLocalAgentProviderAvailabilitySnapshot(env = process.env) {
-    return LOCAL_AGENT_PROVIDERS.map((provider) => checkLocalAgentProviderAvailability(provider, env));
+import { subagentProviderContinuationSupported } from "./continuation.js";
+import { removeDevspaceNodeModulesBinFromPath } from "./path.js";
+import { SUBAGENT_PROVIDERS, } from "../profiles.js";
+export function getSubagentProviderAvailabilitySnapshot(env = process.env) {
+    return SUBAGENT_PROVIDERS.map((provider) => checkSubagentProviderAvailability(provider, env));
 }
-export function checkLocalAgentProviderAvailability(provider, env = process.env) {
+export function checkSubagentProviderAvailability(provider, env = process.env) {
     switch (provider) {
         case "codex":
             return packageAvailability(provider, "@openai/codex-sdk");
@@ -23,13 +24,16 @@ export function checkLocalAgentProviderAvailability(provider, env = process.env)
             return commandAvailability(provider, "copilot");
     }
 }
-export function assertLocalAgentProviderAvailable(provider, env = process.env) {
-    const availability = checkLocalAgentProviderAvailability(provider, env);
+export function assertSubagentProviderAvailable(provider, env = process.env) {
+    const availability = checkSubagentProviderAvailability(provider, env);
     if (availability.available)
         return;
     throw new Error(`${provider} provider is not available: ${availability.reason ?? "provider preflight failed"}`);
 }
-export function formatLocalAgentProviderAvailabilitySummary(providers) {
+export function formatUnavailableSubagentProvider(provider) {
+    return `${provider.name} (${provider.reason ?? "unavailable"})`;
+}
+export function formatSubagentProviderAvailabilitySummary(providers) {
     const available = providers
         .filter((provider) => provider.available)
         .map((provider) => provider.name);
@@ -44,12 +48,17 @@ export function formatLocalAgentProviderAvailabilitySummary(providers) {
 function packageAvailability(provider, packageName) {
     try {
         import.meta.resolve(packageName);
-        return { name: provider, available: true };
+        return {
+            name: provider,
+            available: true,
+            continuationSupported: subagentProviderContinuationSupported(provider),
+        };
     }
     catch {
         return {
             name: provider,
             available: false,
+            continuationSupported: subagentProviderContinuationSupported(provider),
             reason: `${packageName} package not found`,
         };
     }
@@ -60,10 +69,15 @@ function commandAvailability(provider, command, options = {}) {
         return {
             name: provider,
             available: false,
+            continuationSupported: subagentProviderContinuationSupported(provider),
             reason: `${command} executable not found`,
         };
     }
-    return { name: provider, available: true };
+    return {
+        name: provider,
+        available: true,
+        continuationSupported: subagentProviderContinuationSupported(provider),
+    };
 }
 function resolveCommand(command, env = process.env) {
     const commandHasPath = command.includes("/") || command.includes("\\");

package/dist/subagents/providers/continuation.js

@@ -0,0 +1,11 @@
+const CONTINUATION_SUPPORT = {
+    codex: true,
+    claude: true,
+    opencode: true,
+    pi: true,
+    cursor: false,
+    copilot: false,
+};
+export function subagentProviderContinuationSupported(provider) {
+    return CONTINUATION_SUPPORT[provider];
+}

package/dist/subagents/providers/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/subagents/providers/registry.js

@@ -0,0 +1,26 @@
+import { AcpSubagentAdapter } from "./adapters/acp.js";
+import { ClaudeSubagentAdapter } from "./adapters/claude.js";
+import { CodexSubagentAdapter } from "./adapters/codex.js";
+import { extractOpenCodeFinalResponse, OpencodeSubagentAdapter } from "./adapters/opencode.js";
+import { extractPiFinalResponse, PiRpcSubagentAdapter, } from "./adapters/pi.js";
+export async function runSubagentProvider(provider, input) {
+    return createSubagentProviderAdapter(provider).run(input);
+}
+export function createSubagentProviderAdapter(provider) {
+    switch (provider) {
+        case "codex":
+            return new CodexSubagentAdapter();
+        case "claude":
+            return new ClaudeSubagentAdapter();
+        case "opencode":
+            return new OpencodeSubagentAdapter();
+        case "pi":
+            return new PiRpcSubagentAdapter();
+        case "cursor":
+        case "copilot":
+            return new AcpSubagentAdapter(provider);
+    }
+}
+export function extractSubagentResponseText(value) {
+    return extractOpenCodeFinalResponse(value) || extractPiFinalResponse(value);
+}

package/dist/subagents/providers/shared.js

@@ -0,0 +1,40 @@
+export function directString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function assertPipedChild(child) {
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("Agent process did not expose stdio pipes.");
+    }
+}
+export function unwrapProviderPayload(value) {
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    return record.data ?? record.result ?? value;
+}
+export function readArray(record, key) {
+    const value = asRecord(record)?.[key];
+    return Array.isArray(value) ? value : undefined;
+}
+export function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+export function readNestedString(value, path) {
+    let current = value;
+    for (const key of path) {
+        current = asRecord(current)?.[key];
+    }
+    return typeof current === "string" ? current : undefined;
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function requireFinalResponse(provider, response) {
+    const trimmed = response.trim();
+    if (!trimmed) {
+        throw new Error(`${provider} did not return a final assistant response.`);
+    }
+    return trimmed;
+}

package/dist/subagents/sessions/capability.js

@@ -0,0 +1,214 @@
+import { CapabilityError, } from "../../capability-registry.js";
+import { isSubagentProvider } from "../profiles.js";
+import { subagentProviderContinuationSupported } from "../providers/continuation.js";
+import { SubagentDeliveryMailbox } from "./delivery-mailbox.js";
+import { executeSubagentRun, } from "./execution.js";
+import { SubagentSessionError, SubagentSessionManager, } from "./manager.js";
+export class SubagentSessionCapability {
+    config;
+    activityLifecycle;
+    mailbox;
+    providerRunner;
+    constructor(config, activityLifecycle, options = {}) {
+        this.config = config;
+        this.activityLifecycle = activityLifecycle;
+        this.mailbox = new SubagentDeliveryMailbox(config.stateDir);
+        this.providerRunner = options.providerRunner ?? defaultProviderRunner;
+    }
+    async run(input, context, options) {
+        const manager = new SubagentSessionManager(this.config, {
+            launch: (request) => this.launch(request),
+        });
+        try {
+            switch (input.operation) {
+                case "start": {
+                    const started = await manager.start({
+                        workspaceId: context.workspaceId,
+                        workspaceRoot: context.workspaceRoot,
+                        target: input.target,
+                        prompt: input.prompt,
+                        model: input.model,
+                        thinking: input.thinking,
+                        activityId: options.activityId,
+                    });
+                    return {
+                        value: {
+                            operation: "start",
+                            session: publicSession(started.session),
+                            run: publicRun(started.run),
+                        },
+                    };
+                }
+                case "resume": {
+                    const resumed = manager.resume({
+                        sessionId: input.sessionId,
+                        prompt: input.prompt,
+                        activityId: options.activityId,
+                    }, { workspaceId: context.workspaceId });
+                    return {
+                        value: {
+                            operation: "resume",
+                            session: publicSession(resumed.session),
+                            run: publicRun(resumed.run),
+                        },
+                    };
+                }
+                case "status": {
+                    const session = manager.get(input.sessionId, { workspaceId: context.workspaceId });
+                    if (!session) {
+                        throw new SubagentSessionError("subagent.session_not_found", `Unknown Subagent Session in this Workspace: ${input.sessionId}`);
+                    }
+                    return {
+                        value: {
+                            operation: "status",
+                            session: publicSession(session),
+                            ...(session.activeRun ? { activeRun: publicRun(session.activeRun) } : {}),
+                            ...(session.latestRun ? { latestRun: publicRun(session.latestRun) } : {}),
+                        },
+                    };
+                }
+                case "list":
+                    return {
+                        value: {
+                            operation: "list",
+                            sessions: manager.list({ workspaceId: context.workspaceId }).map(publicSessionSummary),
+                        },
+                    };
+            }
+        }
+        catch (error) {
+            if (error instanceof SubagentSessionError) {
+                throw new CapabilityError(error.code, error.message);
+            }
+            throw error;
+        }
+        finally {
+            manager.close();
+        }
+    }
+    decorateResult(workspaceId, result) {
+        if (typeof result !== "object" || result === null)
+            return result;
+        const content = result.content;
+        if (!Array.isArray(content))
+            return result;
+        const excludeRunId = currentRunId(result);
+        const deliveries = this.mailbox.claimWorkspace(workspaceId, excludeRunId);
+        if (deliveries.length === 0)
+            return result;
+        return {
+            ...result,
+            content: [
+                ...content,
+                ...deliveries.map((delivery) => ({ type: "text", text: deliveryText(delivery) })),
+            ],
+        };
+    }
+    launch(request) {
+        void executeSubagentRun(this.config, request, this.providerRunner)
+            .then((completion) => this.recordCompletion(completion))
+            .catch(() => {
+            // The worker writes durable Session/mailbox state for provider failures.
+            // An unexpected orchestration failure must not become an unhandled rejection.
+        });
+    }
+    recordCompletion(completion) {
+        if (!completion.activityId)
+            return;
+        this.activityLifecycle.recordLinked({
+            sourceActivityId: completion.activityId,
+            tool: "subagent_result",
+            request: {
+                sessionId: completion.sessionId,
+                runId: completion.runId,
+            },
+            result: {
+                sessionId: completion.sessionId,
+                runId: completion.runId,
+                provider: completion.provider,
+                status: completion.outcome,
+            },
+            outcome: completion.outcome === "failed"
+                ? { type: "failed", error: "Subagent Run failed." }
+                : { type: "succeeded" },
+        });
+    }
+}
+function publicSession(session) {
+    const continuationSupported = sessionContinuationSupported(session);
+    return {
+        id: session.id,
+        status: session.status,
+        profileName: session.profileName,
+        provider: session.provider,
+        continuationSupported,
+        resumable: continuationSupported && session.status === "idle" && Boolean(session.providerSessionId),
+        ...(session.model ? { model: session.model } : {}),
+        ...(session.thinking ? { thinking: session.thinking } : {}),
+        ...(session.activeRun ? { activeRun: publicRun(session.activeRun) } : {}),
+        ...(session.latestRun ? { latestRun: publicRun(session.latestRun) } : {}),
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+    };
+}
+function publicSessionSummary(session) {
+    const continuationSupported = sessionContinuationSupported(session);
+    return {
+        id: session.id,
+        status: session.status,
+        profileName: session.profileName,
+        provider: session.provider,
+        continuationSupported,
+        resumable: continuationSupported && session.status === "idle" && Boolean(session.providerSessionId),
+        ...(session.model ? { model: session.model } : {}),
+        ...(session.thinking ? { thinking: session.thinking } : {}),
+        ...(session.activeRun ? { activeRunId: session.activeRun.id } : {}),
+        ...(session.latestRun ? {
+            latestRun: {
+                id: session.latestRun.id,
+                status: session.latestRun.status,
+            },
+        } : {}),
+        updatedAt: session.updatedAt,
+    };
+}
+function sessionContinuationSupported(session) {
+    return isSubagentProvider(session.provider)
+        ? subagentProviderContinuationSupported(session.provider)
+        : false;
+}
+function publicRun(run) {
+    return {
+        id: run.id,
+        status: run.status,
+        ...(run.startedAt ? { startedAt: run.startedAt } : {}),
+        ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+    };
+}
+function currentRunId(result) {
+    if (typeof result !== "object" || result === null)
+        return undefined;
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return undefined;
+    const capabilityResult = structured.result;
+    if (typeof capabilityResult !== "object" || capabilityResult === null)
+        return undefined;
+    const run = capabilityResult.run;
+    if (typeof run !== "object" || run === null)
+        return undefined;
+    const id = run.id;
+    return typeof id === "string" ? id : undefined;
+}
+function deliveryText(delivery) {
+    const header = `Subagent ${delivery.sessionId} Run ${delivery.runId} ${delivery.outcome}.`;
+    const body = delivery.outcome === "succeeded"
+        ? delivery.finalResponse
+        : delivery.error;
+    const suffix = delivery.truncated ? "\n[Subagent result truncated for delivery.]" : "";
+    return body ? `${header}\n${body}${suffix}` : `${header}${suffix}`;
+}
+async function defaultProviderRunner(provider, input) {
+    const { runSubagentProvider } = await import("../providers/registry.js");
+    return runSubagentProvider(provider, input);
+}