@akira-tl/forgerelay 0.6.2 → 0.7.1

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

@@ -0,0 +1,137 @@
+import { asRecord, readArray, readNestedString, requireFinalResponse, unwrapProviderPayload, } from "../shared.js";
+export class OpencodeSubagentAdapter {
+    provider = "opencode";
+    async run(input) {
+        const { createOpencode } = await import("@opencode-ai/sdk/v2");
+        const { client, server } = await createOpencode();
+        try {
+            const sessionId = input.providerSessionId ?? await createOpencodeSession(client, input);
+            const promptResult = await promptOpencodeSession(client, sessionId, input);
+            await waitForOpencodeSession(client, sessionId);
+            const messages = await readOpencodeMessages(client, sessionId);
+            const finalResponse = requireFinalResponse("OpenCode", extractOpenCodeFinalResponse(messages) || extractOpenCodeFinalResponse(promptResult));
+            return {
+                provider: this.provider,
+                providerSessionId: sessionId,
+                finalResponse,
+            };
+        }
+        finally {
+            server.close();
+        }
+    }
+}
+async function createOpencodeSession(client, input) {
+    const sessionClient = client;
+    const result = await sessionClient.session.create({
+        directory: input.workspace,
+        location: { directory: input.workspace },
+        ...(input.model ? { model: parseOpencodeModel(input.model) } : {}),
+    }, { throwOnError: true });
+    const id = readNestedString(result, ["id"]) ??
+        readNestedString(result, ["data", "id"]) ??
+        readNestedString(result, ["session", "id"]) ??
+        readNestedString(result, ["data", "session", "id"]);
+    if (typeof id !== "string") {
+        throw new Error("OpenCode did not return a session id.");
+    }
+    return id;
+}
+async function promptOpencodeSession(client, sessionId, input) {
+    const session = client.session;
+    const promptInput = {
+        sessionID: sessionId,
+        directory: input.workspace,
+        prompt: { parts: [{ type: "text", text: input.prompt }] },
+        parts: [{ type: "text", text: input.prompt }],
+        ...(input.model ? { model: parseOpencodeModel(input.model) } : {}),
+        ...(input.thinking ? { variant: input.thinking } : {}),
+    };
+    return session.prompt(promptInput, { throwOnError: true });
+}
+async function waitForOpencodeSession(client, sessionId) {
+    const session = client.session;
+    if (!session?.wait)
+        return;
+    await session.wait({ sessionID: sessionId }, { throwOnError: true });
+}
+async function readOpencodeMessages(client, sessionId) {
+    const session = client.session;
+    if (!session?.messages)
+        return undefined;
+    return session.messages({ sessionID: sessionId, order: "asc", limit: 100 }, { throwOnError: true });
+}
+function parseOpencodeModel(model) {
+    const separator = model.indexOf("/");
+    if (separator === -1)
+        return { providerID: "opencode", modelID: model };
+    return {
+        providerID: model.slice(0, separator),
+        modelID: model.slice(separator + 1),
+    };
+}
+export function extractOpenCodeFinalResponse(value) {
+    const root = unwrapProviderPayload(value);
+    const messages = Array.isArray(root) ? root : readArray(root, "messages");
+    if (messages)
+        return extractLastOpenCodeAssistantMessageText(messages);
+    return extractOpenCodeAssistantMessageText(root);
+}
+function extractLastOpenCodeAssistantMessageText(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = asRecord(messages[index]);
+        if (!message)
+            continue;
+        const info = asRecord(message.info);
+        const role = typeof info?.role === "string" ? info.role : message.role;
+        const type = typeof message.type === "string" ? message.type : undefined;
+        if (role !== "assistant" && type !== "assistant")
+            continue;
+        const text = extractOpenCodeAssistantMessageText(message);
+        if (text)
+            return text;
+    }
+    return "";
+}
+function extractOpenCodeAssistantMessageText(value) {
+    const message = asRecord(value);
+    if (!message)
+        return "";
+    const content = readArray(message, "content");
+    if (content) {
+        const text = content
+            .map((part) => {
+            const partRecord = asRecord(part);
+            if (!partRecord || partRecord.type !== "text")
+                return "";
+            return typeof partRecord.text === "string" ? partRecord.text : "";
+        })
+            .filter(Boolean)
+            .join("");
+        if (text.trim())
+            return text.trim();
+    }
+    const parts = readArray(message, "parts");
+    if (parts) {
+        const text = parts
+            .map((part) => {
+            const partRecord = asRecord(part);
+            if (!partRecord || partRecord.type !== "text")
+                return "";
+            return typeof partRecord.text === "string" ? partRecord.text : "";
+        })
+            .filter(Boolean)
+            .join("");
+        if (text.trim())
+            return text.trim();
+    }
+    const info = asRecord(message.info) ?? message;
+    return stringifyStructuredAssistantMessage(info.structured);
+}
+function stringifyStructuredAssistantMessage(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value.trim();
+    return JSON.stringify(value);
+}

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;
+}