@akira-tl/forgerelay 0.6.2 → 0.7.1

package/dist/server.js

@@ -54,8 +54,10 @@ import { shutdownHttpServer } from "./server-shutdown.js";
 import { formatPathForPrompt } from "./skills.js";
 import { createWorkspaceStore } from "./workspace-store.js";
 import { formatAgentsPath, WorkspaceRegistry } from "./workspaces.js";
-import { summarizeLocalAgentProfile } from "./local-agent-profiles.js";
-import { formatLocalAgentProviderAvailabilitySummary, getLocalAgentProviderAvailabilitySnapshot, } from "./local-agent-availability.js";
+import { formatAvailableSubagentProfile, summarizeSubagentProfile } from "./subagents/profiles.js";
+import { formatSubagentProviderAvailabilitySummary, formatUnavailableSubagentProvider, getSubagentProviderAvailabilitySnapshot, } from "./subagents/providers/availability.js";
+import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from "./subagents/sessions/mcp/audit.js";
+import { createSubagentMcpRuntime } from "./subagents/sessions/mcp/runtime.js";
 // Legacy MCP Streamable HTTP clients can reconnect without closing the previous
 // transport. Bound stale transport-session retention so abandoned transports do
 // not accumulate for the life of the process.
@@ -131,17 +133,6 @@ async function assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, wor
         "Apply these instructions, then retry this tool call. No mutation or command was executed.",
     ].join("\n"));
 }
-function formatVisibleAgent(agent) {
-    const model = agent.model ? `, model ${agent.model}` : "";
-    const thinking = agent.thinking ? `, thinking ${agent.thinking}` : "";
-    const availability = agent.providerAvailable === false
-        ? `, unavailable: ${agent.providerUnavailableReason ?? "provider unavailable"}`
-        : "";
-    return `${agent.name} (${agent.provider}${model}${thinking}${availability})`;
-}
-function formatUnavailableAgentProvider(provider) {
-    return `${provider.name} (${provider.reason ?? "unavailable"})`;
-}
 function resultOutputSchema(extra = {}) {
     return {
         result: z
@@ -228,9 +219,10 @@ const workspaceLocalAgentOutputSchema = z.object({
     providerAvailable: z.boolean().optional(),
     providerUnavailableReason: z.string().optional(),
 });
-const workspaceLocalAgentProviderOutputSchema = z.object({
+const workspaceSubagentProviderOutputSchema = z.object({
     name: z.string(),
     available: z.boolean(),
+    continuationSupported: z.boolean(),
     reason: z.string().optional(),
 });
 const workspaceAvailableAgentsFileOutputSchema = z.object({
@@ -999,7 +991,7 @@ function activityRequestFor(input, context) {
         member: context.activityMember,
     };
 }
-function runActivityTool(lifecycle, workspace, conversationScopeId, tool, request, operation, outcome = standardActivityOutcome, relation = {}) {
+function runActivityTool(lifecycle, workspace, conversationScopeId, tool, request, operation, outcome = standardActivityOutcome, relation = {}, auditResult) {
     return lifecycle.run({
         tool,
         workspace: workspaceActivitySnapshot(workspace),
@@ -1007,6 +999,7 @@ function runActivityTool(lifecycle, workspace, conversationScopeId, tool, reques
         request,
         operation,
         outcome,
+        ...(auditResult ? { auditResult } : {}),
         ...relation,
     });
 }
@@ -1195,7 +1188,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         }).then((result) => routing.present(result, target));
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, options = {}) {
     const connectionScopeId = `mcp-connection:${randomUUID()}`;
     const remoteWorkspaces = new RemoteWorkspaceRelay(config.configDir, config.stateDir);
     const compositeWorkspaces = new CompositeWorkspaceRegistry(config.stateDir);
@@ -1224,10 +1217,12 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             memberName: member.name,
         };
     };
+    const subagentMcp = createSubagentMcpRuntime(config, activityLifecycle, options);
     const presentExecutionResult = (result, target) => {
-        if (!target.compositeWorkspaceId || !target.memberName)
-            return result;
-        return remapCompositeToolResult(result, target.executionWorkspaceId, target.compositeWorkspaceId, target.memberName);
+        const presented = !target.compositeWorkspaceId || !target.memberName
+            ? result
+            : remapCompositeToolResult(result, target.executionWorkspaceId, target.compositeWorkspaceId, target.memberName);
+        return subagentMcp.decorateResult(target.executionWorkspaceId, presented);
     };
     const hostScopeIdFor = (requestMeta, transportSessionId) => hostConversationScopeId(requestMeta, transportSessionId, connectionScopeId);
     const prepareExecutionContext = async (target, requestMeta, signal, sessionId) => {
@@ -1252,6 +1247,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const batchExecuteAvailable = config.toolMode !== "codex";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
+        ...subagentMcp.registryDependencies,
         batchExecute: {
             available: batchExecuteAvailable,
             unavailableReason: batchExecuteAvailable
@@ -1804,7 +1800,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             const { workspaceId, name, arguments: capabilityArguments, file } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
             let changedPaths = [];
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor({ workspaceId, name, action: "run", arguments: capabilityArguments, file }, context), {
+            return runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
                 signal: context.signal,
                 tool: toolNames.capability,
                 invocation: workspaceHookInvocation(workspace),
@@ -1820,6 +1816,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                             requestMeta: context.requestMeta,
                             sessionId: context.sessionId,
                             batch: context.batch,
+                            activityId: activityContext.activityId,
                         });
                         changedPaths = execution.changedPaths ?? [];
                         const result = {
@@ -1872,7 +1869,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         return result;
                     }
                 },
-            }, activityRelationFor(context));
+            }), standardActivityOutcome, activityRelationFor(context), (result) => capabilityActivityAuditResult(name, result));
         },
     });
     batchExecutor = new BatchExecutor({
@@ -2108,7 +2105,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
             availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema).optional(),
             skills: z.array(workspaceSkillOutputSchema).optional(),
-            agentProviders: z.array(workspaceLocalAgentProviderOutputSchema).optional(),
+            agentProviders: z.array(workspaceSubagentProviderOutputSchema).optional(),
             agents: z.array(workspaceLocalAgentOutputSchema).optional(),
             skillDiagnostics: z.array(workspaceSkillDiagnosticOutputSchema).optional(),
             workspaces: z.array(workspaceInventoryEntryOutputSchema).optional(),
@@ -2546,9 +2543,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             path: formatPathForPrompt(guide.filePath),
         }));
         const capabilityCatalog = capabilityRegistry.catalog(capabilityContextFor(workspace));
-        const cardAgentProviders = config.subagents ? localAgentProviders : [];
+        const cardAgentProviders = config.subagents ? subagentProviders : [];
         const cardAgents = workspace.agentProfiles.map((profile) => {
-            const summary = summarizeLocalAgentProfile(profile);
+            const summary = summarizeSubagentProfile(profile);
             const availability = cardAgentProviders.find((provider) => provider.name === summary.provider);
             return {
                 ...summary,
@@ -2626,10 +2623,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         ? `Available subagent providers: ${visibleAgentProviders.filter((provider) => provider.available).map((provider) => provider.name).join(", ")}`
                         : undefined,
                     visibleAgentProviders.some((provider) => !provider.available)
-                        ? `Unavailable subagent providers: ${visibleAgentProviders.filter((provider) => !provider.available).map(formatUnavailableAgentProvider).join(", ")}`
+                        ? `Unavailable subagent providers: ${visibleAgentProviders.filter((provider) => !provider.available).map(formatUnavailableSubagentProvider).join(", ")}`
                         : undefined,
                     visibleAgents.length > 0
-                        ? `Available subagent profiles: ${visibleAgents.map(formatVisibleAgent).join(", ")}`
+                        ? `Available subagent profiles: ${visibleAgents.map(formatAvailableSubagentProfile).join(", ")}`
                         : undefined,
                     knownWorktrees.length > 0
                         ? `Known worktrees: ${knownWorktrees.map((worktree) => `${worktree.path} [${worktree.workspaceId}]${worktree.branch ? ` branch=${worktree.branch}` : ""}${worktree.targetBranch ? ` target=${worktree.targetBranch}` : ""}${worktree.current ? " (current)" : ""}`).join(", ")}`
@@ -3673,8 +3670,8 @@ export function createServer(config = loadConfig(), options = {}) {
     const reviewCheckpoints = createReviewCheckpointManager();
     const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
     const codeIntelligence = new CodeIntelligenceManager(config);
-    const localAgentProviders = config.subagents
-        ? getLocalAgentProviderAvailabilitySnapshot()
+    const subagentProviders = config.subagents
+        ? getSubagentProviderAvailabilitySnapshot()
         : [];
     const logTransportCloseResults = (reason, results) => {
         let closedCount = 0;
@@ -3857,7 +3854,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
                 await server.connect(transport);
             }
             else {
@@ -3880,7 +3877,7 @@ export function createServer(config = loadConfig(), options = {}) {
     return {
         app,
         config,
-        localAgentProviders,
+        subagentProviders,
         close: () => {
             closePromise ??= (async () => {
                 clearInterval(transportCleanupTimer);
@@ -3906,7 +3903,7 @@ async function isMainModule() {
     return modulePath === entrypointPath;
 }
 if (await isMainModule()) {
-    const { app, config, close, localAgentProviders } = createServer();
+    const { app, config, close, subagentProviders } = createServer();
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
         console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
@@ -3922,7 +3919,7 @@ if (await isMainModule()) {
                 : `unsupported on ${process.platform}`;
         console.log(`native artifact download: ${artifactDownloadStatus}`);
         if (config.subagents) {
-            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+            console.log(`subagent providers: ${formatSubagentProviderAvailabilitySummary(subagentProviders)}`);
         }
     });
     let shuttingDown = false;

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");