@akira-tl/forgerelay 0.6.1 → 0.7.1

package/dist/{local-agent-targets.js → subagents/cli-target.js}

@@ -1,5 +1,5 @@
-import { isLocalAgentProvider, LOCAL_AGENT_PROVIDERS, } from "./local-agent-profiles.js";
-export function parseLocalAgentRunArgs(args) {
+import { isSubagentProvider, SUBAGENT_PROVIDERS, } from "./profiles.js";
+export function parseSubagentRunArgs(args) {
     const [target, ...rest] = args;
     if (!target) {
         throw new Error('Usage: forgerelay agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] "<prompt>"');
@@ -47,7 +47,7 @@ export function parseLocalAgentRunArgs(args) {
     }
     return { target, prompt, model, thinking };
 }
-export function resolveLocalAgentTarget(target, profiles, modelOverride, thinkingOverride) {
+export function resolveSubagentTarget(target, profiles, modelOverride, thinkingOverride) {
     const profile = profiles.find((candidate) => candidate.name === target);
     if (profile) {
         return {
@@ -59,7 +59,7 @@ export function resolveLocalAgentTarget(target, profiles, modelOverride, thinkin
             profile,
         };
     }
-    if (isLocalAgentProvider(target)) {
+    if (isSubagentProvider(target)) {
         return {
             kind: "provider",
             name: target,
@@ -70,11 +70,11 @@ export function resolveLocalAgentTarget(target, profiles, modelOverride, thinkin
     }
     return undefined;
 }
-export function formatAvailableLocalAgentTargets(profiles) {
+export function formatAvailableSubagentTargets(profiles) {
     const profileNames = profiles.map((profile) => profile.name);
     const parts = [
         profileNames.length > 0 ? `profiles: ${profileNames.join(", ")}` : undefined,
-        `providers: ${LOCAL_AGENT_PROVIDERS.join(", ")}`,
+        `providers: ${SUBAGENT_PROVIDERS.join(", ")}`,
     ].filter(Boolean);
     return parts.join("; ");
 }

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

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
-export const LOCAL_AGENT_PROVIDERS = [
+export const SUBAGENT_PROVIDERS = [
     "codex",
     "claude",
     "opencode",
@@ -11,8 +11,8 @@ export const LOCAL_AGENT_PROVIDERS = [
     "copilot",
 ];
 const FRONTMATTER_DELIMITER = "---";
-const PROVIDERS = new Set(LOCAL_AGENT_PROVIDERS);
-export async function loadLocalAgentProfiles(config, workspaceRoot) {
+const PROVIDERS = new Set(SUBAGENT_PROVIDERS);
+export async function loadSubagentProfiles(config, workspaceRoot) {
     if (!config.subagents)
         return [];
     const profileDirs = [
@@ -30,7 +30,7 @@ export async function loadLocalAgentProfiles(config, workspaceRoot) {
         .filter((profile) => !profile.disabled)
         .sort((a, b) => a.name.localeCompare(b.name));
 }
-export function summarizeLocalAgentProfile(profile) {
+export function summarizeSubagentProfile(profile) {
     return {
         name: profile.name,
         description: profile.description,
@@ -39,6 +39,14 @@ export function summarizeLocalAgentProfile(profile) {
         thinking: profile.thinking,
     };
 }
+export function formatAvailableSubagentProfile(profile) {
+    const model = profile.model ? `, model ${profile.model}` : "";
+    const thinking = profile.thinking ? `, thinking ${profile.thinking}` : "";
+    const availability = profile.providerAvailable === false
+        ? `, unavailable: ${profile.providerUnavailableReason ?? "provider unavailable"}`
+        : "";
+    return `${profile.name} (${profile.provider}${model}${thinking}${availability})`;
+}
 async function loadProfilesFromDirectory(directory) {
     const resolvedDirectory = resolve(directory);
     if (!existsSync(resolvedDirectory))
@@ -121,7 +129,7 @@ function readProvider(frontmatter, filePath) {
     }
     return provider;
 }
-export function isLocalAgentProvider(value) {
+export function isSubagentProvider(value) {
     return PROVIDERS.has(value);
 }
 function readString(frontmatter, key) {

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

@@ -0,0 +1,148 @@
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import { asRecord, assertPipedChild, directString, errorMessage, readArray, } from "../shared.js";
+const ACP_COMMANDS = {
+    cursor: ["cursor-agent", "acp"],
+    copilot: ["copilot", "--acp"],
+};
+export class AcpSubagentAdapter {
+    provider;
+    command;
+    constructor(provider, command = ACP_COMMANDS[provider]) {
+        this.provider = provider;
+        this.command = command;
+    }
+    async run(input) {
+        const { client } = await import("@agentclientprotocol/sdk");
+        const { methods } = await import("@agentclientprotocol/sdk");
+        const { ndJsonStream } = await import("@agentclientprotocol/sdk");
+        const [command, ...args] = this.command;
+        const child = spawn(command, args, {
+            cwd: input.workspace,
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        assertPipedChild(child);
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        try {
+            let providerSessionId = input.providerSessionId ?? null;
+            const finalResponse = await client({ name: "ForgeRelay" })
+                .onRequest(methods.client.session.requestPermission, (context) => {
+                const selected = selectAcpAllowPermissionOption(context.params.options);
+                return selected
+                    ? { outcome: { outcome: "selected", optionId: selected.optionId } }
+                    : { outcome: { outcome: "cancelled" } };
+            })
+                .connectWith(stream, async (context) => {
+                const session = await context.buildSession(input.workspace).start();
+                providerSessionId = session.sessionId;
+                try {
+                    if (input.model) {
+                        const config = resolveAcpModelConfigUpdate(session, input.model, this.provider);
+                        await context.request(methods.agent.session.setConfigOption, config);
+                    }
+                    if (input.thinking) {
+                        const config = resolveAcpThinkingConfigUpdate(session, input.thinking, this.provider);
+                        await context.request(methods.agent.session.setConfigOption, config);
+                    }
+                    const prompt = session.prompt(input.prompt);
+                    const textParts = [];
+                    for (;;) {
+                        const message = await session.nextUpdate();
+                        if (message.kind === "stop") {
+                            await prompt;
+                            return textParts.join("").trim();
+                        }
+                        const update = message.update;
+                        if (update.sessionUpdate !== "agent_message_chunk")
+                            continue;
+                        const content = update.content;
+                        if (content.type === "text")
+                            textParts.push(content.text);
+                    }
+                }
+                finally {
+                    session.dispose();
+                }
+            });
+            return {
+                provider: this.provider,
+                providerSessionId,
+                finalResponse: finalResponse.trim(),
+            };
+        }
+        catch (error) {
+            throw new Error(`${this.provider} ACP run failed: ${errorMessage(error)}${stderr ? `\n${stderr.trim()}` : ""}`);
+        }
+        finally {
+            child.kill();
+        }
+    }
+}
+export function resolveAcpModelConfigUpdate(session, model, provider) {
+    return resolveAcpSelectConfigUpdate(session, {
+        category: "model",
+        label: "model",
+        provider,
+        value: model,
+    });
+}
+export function resolveAcpThinkingConfigUpdate(session, thinking, provider) {
+    return resolveAcpSelectConfigUpdate(session, {
+        category: "thought_level",
+        label: "thinking option",
+        provider,
+        value: thinking,
+    });
+}
+function resolveAcpSelectConfigUpdate(session, options) {
+    const record = asRecord(session);
+    if (!record)
+        throw new Error(`${options.provider} ACP session did not return session metadata.`);
+    const sessionId = typeof record.sessionId === "string" ? record.sessionId : undefined;
+    if (!sessionId)
+        throw new Error(`${options.provider} ACP session did not return a session id.`);
+    const response = asRecord(record.newSessionResponse);
+    const configOptions = response ? readArray(response, "configOptions") ?? [] : [];
+    const config = configOptions
+        .map(asRecord)
+        .find((option) => option?.type === "select" && option.category === options.category);
+    if (!config) {
+        throw new Error(`${options.provider} ACP server does not expose a ${options.label}.`);
+    }
+    const configId = directString(config.id);
+    if (!configId)
+        throw new Error(`${options.provider} ACP ${options.label} is missing an id.`);
+    const available = flattenAcpSelectValues(config);
+    if (!available.includes(options.value)) {
+        const suffix = available.length > 0 ? ` Available values: ${available.join(", ")}.` : "";
+        throw new Error(`${options.provider} ACP ${options.label} does not support '${options.value}'.${suffix}`);
+    }
+    return { sessionId, configId, value: options.value };
+}
+function flattenAcpSelectValues(option) {
+    const values = [];
+    for (const item of readArray(option, "options") ?? []) {
+        const record = asRecord(item);
+        const value = directString(record?.value);
+        if (value) {
+            values.push(value);
+            continue;
+        }
+        for (const nested of readArray(record, "options") ?? []) {
+            const nestedValue = directString(asRecord(nested)?.value);
+            if (nestedValue)
+                values.push(nestedValue);
+        }
+    }
+    return values;
+}
+function selectAcpAllowPermissionOption(options) {
+    return (options.find((option) => option.kind === "allow_once") ??
+        options.find((option) => option.kind === "allow_always"));
+}

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

@@ -0,0 +1,75 @@
+import { spawnSync } from "node:child_process";
+import { directString, requireFinalResponse } from "../shared.js";
+export class ClaudeSubagentAdapter {
+    provider = "claude";
+    async run(input) {
+        const { query } = await import("@anthropic-ai/claude-agent-sdk");
+        const claudeExecutable = process.env.CLAUDE_COMMAND ?? resolveExecutable("claude");
+        const messages = query({
+            prompt: input.prompt,
+            options: {
+                cwd: input.workspace,
+                model: input.model,
+                ...(input.thinking ? { thinking: { type: "adaptive" }, effort: input.thinking } : {}),
+                resume: input.providerSessionId,
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                env: claudeCommandEnvironment(process.env),
+                ...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
+            },
+        });
+        let providerSessionId = input.providerSessionId ?? null;
+        let finalResponse = "";
+        for await (const message of messages) {
+            const record = message;
+            if (typeof record.session_id === "string")
+                providerSessionId = record.session_id;
+            if (record.type === "result" && typeof record.result === "string") {
+                const resultError = claudeResultError(record);
+                if (resultError)
+                    throw new Error(resultError);
+                finalResponse = record.result;
+            }
+        }
+        finalResponse = requireFinalResponse("Claude", finalResponse);
+        return {
+            provider: this.provider,
+            providerSessionId,
+            finalResponse,
+        };
+    }
+}
+function claudeResultError(record) {
+    const subtype = typeof record.subtype === "string" ? record.subtype : undefined;
+    const isError = record.is_error === true || subtype?.startsWith("error");
+    if (!isError)
+        return undefined;
+    const message = directString(record.error) ??
+        directString(record.message) ??
+        directString(record.result) ??
+        subtype ??
+        "Claude returned an error result.";
+    return `Claude returned an error result: ${message}`;
+}
+function resolveExecutable(command) {
+    const result = spawnSync(process.platform === "win32" ? "where.exe" : "command", [
+        ...(process.platform === "win32" ? [command] : ["-v", command]),
+    ], {
+        encoding: "utf8",
+        shell: process.platform !== "win32",
+    });
+    const executable = result.stdout?.split(/\r?\n/).find((line) => line.trim());
+    return executable?.trim() || undefined;
+}
+export function claudeCommandEnvironment(env) {
+    const next = { ...env };
+    for (const key of [
+        "CLAUDECODE",
+        "CLAUDE_CODE_ENTRYPOINT",
+        "CLAUDE_CODE_SSE_PORT",
+        "CLAUDE_AGENT_SDK_VERSION",
+    ]) {
+        delete next[key];
+    }
+    return next;
+}

package/dist/{local-agent-runtime.js → subagents/providers/adapters/codex.js}

@@ -18,7 +18,7 @@ function threadOptionsFor(input) {
         modelReasoningEffort: input.thinking,
     };
 }
-export class CodexSdkLocalAgentRuntime {
+export class CodexSdkSubagentRuntime {
     provider = "codex";
     codex;
     constructor(codex) {
@@ -34,13 +34,19 @@ export class CodexSdkLocalAgentRuntime {
             provider: this.provider,
             providerSessionId: thread.id,
             finalResponse: turn.finalResponse,
-            items: turn.items,
         };
     }
 }
-export async function createCodexSdkLocalAgentRuntime(options, codexFactory) {
+export async function createCodexSdkSubagentRuntime(options, codexFactory) {
     const factory = codexFactory ?? (await defaultCodexFactory());
-    return new CodexSdkLocalAgentRuntime(factory(options));
+    return new CodexSdkSubagentRuntime(factory(options));
+}
+export class CodexSubagentAdapter {
+    provider = "codex";
+    async run(input) {
+        const runtime = await createCodexSdkSubagentRuntime();
+        return runtime.run(input);
+    }
 }
 async function defaultCodexFactory() {
     const module = await import("@openai/codex-sdk");

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