openclaw-swarm-layer 0.1.0

package/dist/src/runtime/openclaw-exec-bridge.js

@@ -0,0 +1,498 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { buildPatchedBridgeModuleSource, resolveBridgeCompatibility, resolveInternalModuleSpec, } from "./bridge-manifest.js";
+import { buildMigrationChecklist, buildReplacementPlan, detectPublicApiAvailability } from "./public-api-seams.js";
+export function deriveDoctorRemediation(report) {
+    const steps = [];
+    const text = report.blockers.join("\n");
+    const warningText = report.warnings.join("\n");
+    if (/not in bridge allowlist/i.test(text)) {
+        steps.push("Update bridge.versionAllow to include the current OpenClaw version, or switch back to a tested version.");
+    }
+    if (/No internal bridge mapping is registered|mapping is stale/i.test(text)) {
+        steps.push("Refresh INTERNAL_MODULES_BY_VERSION for the installed OpenClaw build and re-run swarm doctor.");
+    }
+    if (/ACP runtime backend is currently unavailable|ACP runtime backend is not configured/i.test(text)) {
+        steps.push("Ensure the acpx plugin is enabled, ACP global config is enabled, and rerun `openclaw swarm doctor --json`.");
+    }
+    if (/subagent helpers|subagent patch/i.test(text)) {
+        steps.push("Refresh the bridge patch export list for subagent helpers before using the subagent bridge path.");
+    }
+    if (/versionAllow is empty/i.test(warningText)) {
+        steps.push("Pin bridge.versionAllow to the exact OpenClaw versions you have validated.");
+    }
+    if (/openclawRoot is not pinned/i.test(warningText)) {
+        steps.push("Set bridge.openclawRoot explicitly so bridge execution does not rely on install auto-detection.");
+    }
+    if (steps.length === 0 && !report.ok) {
+        steps.push("Inspect bridge.blockers and bridge.risks, then re-run doctor after correcting configuration or version drift.");
+    }
+    if (steps.length === 0 && report.ok && report.warnings.length > 0) {
+        steps.push("Address bridge warnings to reduce upgrade and compatibility risk before relying on bridge mode broadly.");
+    }
+    return steps;
+}
+export function deriveDoctorSeverity(report) {
+    if (report.blockers.length > 0) {
+        return "blocked";
+    }
+    if (report.warnings.length > 0 || report.risks.length > 0) {
+        return "warning";
+    }
+    return "healthy";
+}
+export function deriveDoctorNextAction(report) {
+    if (report.remediation.length > 0) {
+        return report.remediation[0];
+    }
+    if (!report.ok && report.blockers.length > 0) {
+        return "Resolve bridge blockers before retrying execution.";
+    }
+    if (report.ok) {
+        return "Bridge checks passed. You can proceed with bridge-backed execution smoke or normal runs.";
+    }
+    return "Inspect doctor output and resolve blockers before retrying.";
+}
+export function dedupeStrings(values) {
+    return [...new Set(values)];
+}
+function getRequire() {
+    return createRequire(import.meta.url);
+}
+function resolveOpenClawRoot(override) {
+    if (override) {
+        return path.resolve(override);
+    }
+    const require = getRequire();
+    const sdkEntryPath = require.resolve("openclaw/plugin-sdk");
+    let cursor = path.dirname(sdkEntryPath);
+    while (true) {
+        const packageJsonPath = path.join(cursor, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return cursor;
+        }
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            throw new Error("Unable to resolve openclaw package root from plugin-sdk entry");
+        }
+        cursor = parent;
+    }
+}
+async function resolveInternalModule(openclawRoot, versionAllow) {
+    const packageJson = JSON.parse(await fs.readFile(path.join(openclawRoot, "package.json"), "utf8"));
+    const version = packageJson.version;
+    if (versionAllow && versionAllow.length > 0 && !versionAllow.includes(version)) {
+        throw new Error(`OpenClaw version ${version} is not in bridge allowlist (${versionAllow.join(", ")})`);
+    }
+    const spec = resolveInternalModuleSpec(version);
+    if (!spec) {
+        throw new Error(`No internal bridge mapping is registered for OpenClaw ${version}`);
+    }
+    const modulePath = path.join(openclawRoot, spec.relativeModulePath);
+    const mod = await import(pathToFileURL(modulePath).href);
+    const loadConfig = mod[spec.exportAliases.loadConfig];
+    const getAcpSessionManager = mod[spec.exportAliases.getAcpSessionManager];
+    if (!loadConfig || !getAcpSessionManager) {
+        throw new Error(`Internal bridge mapping for OpenClaw ${version} is stale`);
+    }
+    return {
+        version,
+        spec,
+        loadConfig,
+        getAcpSessionManager,
+    };
+}
+async function resolvePatchedSubagentSpawner(openclawRoot, spec) {
+    const originalModulePath = path.join(openclawRoot, spec.relativeModulePath);
+    const patchedModulePath = path.join(openclawRoot, spec.patchedModulePath);
+    const source = await fs.readFile(originalModulePath, "utf8");
+    await fs.writeFile(patchedModulePath, buildPatchedBridgeModuleSource(source), "utf8");
+    const mod = await import(pathToFileURL(patchedModulePath).href);
+    const spawnSubagentDirect = mod[spec.patchedSubagentExports.spawn];
+    const findLatestSubagentRunByChildSession = mod[spec.patchedSubagentExports.findLatestRun];
+    const killSubagentRunByChildSession = mod[spec.patchedSubagentExports.killByChildSession];
+    const isSubagentSessionRunActive = mod[spec.patchedSubagentExports.isRunActive];
+    if (!spawnSubagentDirect || !findLatestSubagentRunByChildSession || !killSubagentRunByChildSession || !isSubagentSessionRunActive) {
+        throw new Error("Patched bridge module did not expose subagent helpers");
+    }
+    return {
+        spawnSubagentDirect,
+        findLatestSubagentRunByChildSession,
+        killSubagentRunByChildSession,
+        isSubagentSessionRunActive,
+    };
+}
+function mapSubagentRunState(entry, active) {
+    if (active) {
+        return "running";
+    }
+    const endedReason = typeof entry.endedReason === "string" ? entry.endedReason : "";
+    const outcome = entry.outcome;
+    if (endedReason === "killed" || outcome?.error === "killed") {
+        return "cancelled";
+    }
+    if (outcome?.status === "error") {
+        return "failed";
+    }
+    return "completed";
+}
+async function runBridgeDoctor(input) {
+    const openclawRoot = resolveOpenClawRoot(input.bridge?.openclawRoot);
+    const report = {
+        ok: false,
+        severity: "blocked",
+        openclawRoot,
+        compatibility: {
+            supportedRunners: [],
+            replacementCandidates: [],
+            notes: [],
+        },
+        publicApi: {
+            acpControlPlaneExport: false,
+            subagentSpawnExport: false,
+            readyReplacementPoints: [],
+        },
+        replacementPlan: [],
+        migrationChecklist: [],
+        checks: {
+            versionMapped: false,
+            versionAllowed: false,
+            internalModuleResolved: false,
+            acpBackendHealthy: false,
+            subagentPatchable: false,
+        },
+        blockers: [],
+        warnings: [],
+        risks: [
+            "bridge mode depends on internal OpenClaw bundle aliases and version pinning",
+            "bridge mode is experimental and may break on upstream packaging changes",
+        ],
+        remediation: [],
+        nextAction: "Resolve bridge blockers before using bridge-backed execution.",
+    };
+    if (!input.bridge?.versionAllow || input.bridge.versionAllow.length === 0) {
+        report.warnings.push("bridge.versionAllow is empty; version drift risk is high");
+    }
+    if (!input.bridge?.openclawRoot) {
+        report.warnings.push("bridge.openclawRoot is not pinned; bridge will rely on install auto-detection");
+    }
+    try {
+        const publicApi = await detectPublicApiAvailability();
+        report.publicApi = {
+            acpControlPlaneExport: publicApi.acpControlPlaneExport,
+            subagentSpawnExport: publicApi.subagentSpawnExport,
+            readyReplacementPoints: publicApi.readyReplacementPoints,
+        };
+        report.replacementPlan = buildReplacementPlan(publicApi);
+        report.migrationChecklist = buildMigrationChecklist(report.replacementPlan);
+        report.warnings.push(...publicApi.notes);
+    }
+    catch (error) {
+        report.warnings.push(`Unable to inspect public plugin SDK exports: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        const packageJson = JSON.parse(await fs.readFile(path.join(openclawRoot, "package.json"), "utf8"));
+        report.version = packageJson.version;
+        const compatibility = resolveBridgeCompatibility(packageJson.version);
+        if (compatibility) {
+            report.compatibility = {
+                strategy: compatibility.strategy,
+                testedAt: compatibility.testedAt,
+                supportedRunners: compatibility.supportedRunners,
+                replacementCandidates: Object.values(compatibility.replacementCandidates),
+                notes: compatibility.notes,
+            };
+        }
+        report.checks.versionAllowed =
+            !input.bridge?.versionAllow || input.bridge.versionAllow.length === 0 || input.bridge.versionAllow.includes(packageJson.version);
+        if (!report.checks.versionAllowed) {
+            report.blockers.push(`OpenClaw version ${packageJson.version} is not in bridge allowlist (${(input.bridge?.versionAllow ?? []).join(", ")})`);
+        }
+        report.checks.versionMapped = Boolean(resolveInternalModuleSpec(packageJson.version));
+        if (!report.checks.versionMapped) {
+            report.blockers.push(`No internal bridge mapping is registered for OpenClaw ${packageJson.version}`);
+            return report;
+        }
+        const { loadConfig, spec } = await resolveInternalModule(openclawRoot, input.bridge?.versionAllow);
+        report.checks.internalModuleResolved = true;
+        const cfg = loadConfig();
+        try {
+            await ensureAcpxBackendRegistered(openclawRoot, cfg);
+            report.checks.acpBackendHealthy = true;
+        }
+        catch (error) {
+            report.blockers.push(error instanceof Error ? error.message : String(error));
+        }
+        try {
+            await resolvePatchedSubagentSpawner(openclawRoot, spec);
+            report.checks.subagentPatchable = true;
+        }
+        catch (error) {
+            report.blockers.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    catch (error) {
+        report.blockers.push(error instanceof Error ? error.message : String(error));
+    }
+    report.ok = report.blockers.length === 0;
+    report.blockers = dedupeStrings(report.blockers);
+    report.warnings = dedupeStrings(report.warnings);
+    report.remediation = deriveDoctorRemediation(report);
+    report.remediation = dedupeStrings(report.remediation);
+    report.severity = deriveDoctorSeverity(report);
+    report.nextAction = deriveDoctorNextAction(report);
+    return report;
+}
+async function ensureAcpxBackendRegistered(openclawRoot, cfg) {
+    const serviceModulePath = pathToFileURL(path.join(openclawRoot, "extensions", "acpx", "src", "service.ts")).href;
+    const mod = await import(serviceModulePath);
+    const createAcpxRuntimeService = mod.createAcpxRuntimeService;
+    if (!createAcpxRuntimeService) {
+        throw new Error("Unable to load acpx runtime service for bridge bootstrap");
+    }
+    const workspaceDir = cfg?.agents?.defaults?.workspace ?? cfg?.workspace ?? path.join(openclawRoot, ".bridge-workspace");
+    const service = createAcpxRuntimeService({ pluginConfig: cfg?.plugins?.entries?.acpx?.config });
+    await service.start({
+        config: cfg,
+        workspaceDir,
+        stateDir: path.join(workspaceDir, ".openclaw-bridge-state"),
+        logger: {
+            debug() {
+                return;
+            },
+            info() {
+                return;
+            },
+            warn() {
+                return;
+            },
+            error() {
+                return;
+            },
+        },
+    });
+    const registryModulePath = pathToFileURL(path.join(openclawRoot, "dist", "plugin-sdk", "index.js")).href;
+    const registryModule = await import(registryModulePath);
+    await waitForAcpBackendHealthy(() => registryModule.getAcpRuntimeBackend?.(cfg?.acp?.backend ?? "acpx") ?? null, cfg?.acp?.backend ?? "acpx");
+}
+export async function waitForAcpBackendHealthy(getBackend, backendId, timeoutMs = 15_000, intervalMs = 250) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const backend = getBackend();
+        if (backend && (!backend.healthy || backend.healthy())) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`ACP runtime backend is currently unavailable. Try again in a moment. (backend: ${backendId})`);
+}
+function mapManagerState(state) {
+    if (state === "running") {
+        return "running";
+    }
+    if (state === "error") {
+        return "failed";
+    }
+    return "completed";
+}
+async function handleAcp(command, input) {
+    const openclawRoot = resolveOpenClawRoot(input.bridge?.openclawRoot);
+    if (command === "doctor") {
+        const report = await runBridgeDoctor(input);
+        return {
+            ok: true,
+            version: report.version ?? "unknown",
+            result: report,
+        };
+    }
+    const { loadConfig, getAcpSessionManager, version, spec } = await resolveInternalModule(openclawRoot, input.bridge?.versionAllow);
+    const cfg = loadConfig();
+    const params = input.params ?? {};
+    if (command === "subagent-spawn") {
+        const subagentHelpers = await resolvePatchedSubagentSpawner(openclawRoot, spec);
+        const subagentParams = params;
+        const result = await subagentHelpers.spawnSubagentDirect({
+            task: subagentParams.task,
+            label: subagentParams.label,
+            agentId: subagentParams.agentId,
+            mode: subagentParams.mode,
+            thread: subagentParams.thread,
+            runTimeoutSeconds: subagentParams.runTimeoutSeconds,
+            expectsCompletionMessage: false,
+        }, {
+            requesterAgentIdOverride: "main",
+        });
+        if (result.status !== "accepted") {
+            throw new Error(result.error ? String(result.error) : `Subagent spawn failed with status ${String(result.status)}`);
+        }
+        return {
+            ok: true,
+            version,
+            result: {
+                childSessionKey: result.childSessionKey,
+                runId: result.runId,
+                mode: result.mode ?? subagentParams.mode ?? "run",
+                acceptedAt: new Date().toISOString(),
+                note: result.note,
+            },
+        };
+    }
+    if (command === "subagent-status") {
+        const subagentHelpers = await resolvePatchedSubagentSpawner(openclawRoot, spec);
+        const statusParams = params;
+        const entry = subagentHelpers.findLatestSubagentRunByChildSession(statusParams.childSessionKey);
+        if (!entry) {
+            throw new Error(`Subagent run not found for ${statusParams.childSessionKey}`);
+        }
+        const active = subagentHelpers.isSubagentSessionRunActive(statusParams.childSessionKey);
+        return {
+            ok: true,
+            version,
+            result: {
+                childSessionKey: statusParams.childSessionKey,
+                runId: typeof entry.runId === "string" ? entry.runId : undefined,
+                state: mapSubagentRunState(entry, active),
+                checkedAt: new Date().toISOString(),
+                message: typeof entry.outcome?.error === "string"
+                    ? entry.outcome.error
+                    : typeof entry.frozenResultText === "string"
+                        ? entry.frozenResultText
+                        : undefined,
+                outputText: typeof entry.frozenResultText === "string" ? entry.frozenResultText : undefined,
+            },
+        };
+    }
+    if (command === "subagent-kill") {
+        const subagentHelpers = await resolvePatchedSubagentSpawner(openclawRoot, spec);
+        const killParams = params;
+        const entry = subagentHelpers.findLatestSubagentRunByChildSession(killParams.childSessionKey);
+        if (!entry) {
+            throw new Error(`Subagent run not found for ${killParams.childSessionKey}`);
+        }
+        await subagentHelpers.killSubagentRunByChildSession(cfg, killParams.childSessionKey);
+        return {
+            ok: true,
+            version,
+            result: {
+                childSessionKey: killParams.childSessionKey,
+                killedAt: new Date().toISOString(),
+                message: killParams.reason ?? "killed",
+            },
+        };
+    }
+    await ensureAcpxBackendRegistered(openclawRoot, cfg);
+    const manager = getAcpSessionManager();
+    if (command === "acp-spawn") {
+        const spawnParams = params;
+        const initialized = await manager.initializeSession({
+            cfg,
+            sessionKey: spawnParams.sessionKey,
+            agent: spawnParams.agentId,
+            mode: spawnParams.mode === "session" ? "persistent" : "oneshot",
+            cwd: spawnParams.cwd,
+            backendId: spawnParams.backendId,
+        });
+        void manager.runTurn({
+            cfg,
+            sessionKey: spawnParams.sessionKey,
+            text: spawnParams.task,
+            mode: "prompt",
+            requestId: spawnParams.requestId,
+        });
+        return {
+            ok: true,
+            version,
+            result: {
+                sessionKey: spawnParams.sessionKey,
+                backend: initialized.handle.backend,
+                backendSessionId: initialized.handle.backendSessionId,
+                agentSessionId: initialized.handle.agentSessionId,
+                acceptedAt: new Date().toISOString(),
+            },
+        };
+    }
+    if (command === "acp-status") {
+        const statusParams = params;
+        const status = await manager.getSessionStatus({ cfg, sessionKey: statusParams.sessionKey });
+        return {
+            ok: true,
+            version,
+            result: {
+                sessionKey: statusParams.sessionKey,
+                state: mapManagerState(status.state),
+                backend: status.backend,
+                backendSessionId: status.runtimeStatus?.backendSessionId ?? status.identity?.acpxSessionId,
+                agentSessionId: status.runtimeStatus?.agentSessionId ?? status.identity?.agentSessionId,
+                checkedAt: new Date().toISOString(),
+                message: status.lastError ?? status.runtimeStatus?.summary,
+            },
+        };
+    }
+    if (command === "acp-cancel") {
+        const cancelParams = params;
+        await manager.cancelSession({ cfg, sessionKey: cancelParams.sessionKey, reason: cancelParams.reason });
+        return {
+            ok: true,
+            version,
+            result: {
+                sessionKey: cancelParams.sessionKey,
+                cancelledAt: new Date().toISOString(),
+                message: cancelParams.reason,
+            },
+        };
+    }
+    if (command === "acp-close") {
+        const closeParams = params;
+        const closed = await manager.closeSession({
+            cfg,
+            sessionKey: closeParams.sessionKey,
+            reason: closeParams.reason ?? "closed by swarm bridge",
+        });
+        return {
+            ok: true,
+            version,
+            result: {
+                sessionKey: closeParams.sessionKey,
+                closedAt: new Date().toISOString(),
+                message: closed.runtimeNotice ?? closeParams.reason,
+            },
+        };
+    }
+    throw new Error(`Unsupported bridge command: ${command}`);
+}
+export async function runBridgeCommand(command, input) {
+    return handleAcp(command, input);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function main(argv) {
+    const command = argv[2];
+    if (!command) {
+        process.stderr.write("Missing bridge command\n");
+        return 1;
+    }
+    try {
+        const rawInput = await readStdin();
+        const parsed = rawInput.trim().length > 0 ? JSON.parse(rawInput) : {};
+        const result = await runBridgeCommand(command, parsed);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (isMain) {
+    const code = await main(process.argv);
+    process.exitCode = code;
+}

package/dist/src/runtime/openclaw-session-adapter.d.ts

@@ -0,0 +1,48 @@
+import type { AcpSpawnParams } from "./acp-mapping.js";
+export type AcpAcceptedSession = {
+    sessionKey: string;
+    backend?: string;
+    backendSessionId?: string;
+    agentSessionId?: string;
+    acceptedAt?: string;
+    outputText?: string;
+    threadId?: string;
+};
+export type AcpSessionStatus = {
+    sessionKey: string;
+    state: "accepted" | "running" | "completed" | "failed" | "cancelled" | "timed_out";
+    backend?: string;
+    backendSessionId?: string;
+    agentSessionId?: string;
+    checkedAt?: string;
+    message?: string;
+    outputText?: string;
+};
+export interface OpenClawSessionAdapter {
+    spawnAcpSession(params: AcpSpawnParams): Promise<AcpAcceptedSession>;
+    getAcpSessionStatus(sessionKey: string): Promise<AcpSessionStatus>;
+    cancelAcpSession(sessionKey: string, reason?: string): Promise<{
+        sessionKey: string;
+        cancelledAt?: string;
+        message?: string;
+    }>;
+    closeAcpSession(sessionKey: string, reason?: string): Promise<{
+        sessionKey: string;
+        closedAt?: string;
+        message?: string;
+    }>;
+}
+export declare class UnsupportedOpenClawSessionAdapter implements OpenClawSessionAdapter {
+    spawnAcpSession(_params: AcpSpawnParams): Promise<AcpAcceptedSession>;
+    getAcpSessionStatus(_sessionKey: string): Promise<AcpSessionStatus>;
+    cancelAcpSession(_sessionKey: string, _reason?: string): Promise<{
+        sessionKey: string;
+        cancelledAt?: string;
+        message?: string;
+    }>;
+    closeAcpSession(_sessionKey: string, _reason?: string): Promise<{
+        sessionKey: string;
+        closedAt?: string;
+        message?: string;
+    }>;
+}

package/dist/src/runtime/openclaw-session-adapter.js

@@ -0,0 +1,14 @@
+export class UnsupportedOpenClawSessionAdapter {
+    async spawnAcpSession(_params) {
+        throw new Error("ACP execution is not wired to a public OpenClaw session adapter yet. Finish M2.0 T2 before enabling real ACP runs.");
+    }
+    async getAcpSessionStatus(_sessionKey) {
+        throw new Error("ACP session status is not wired to a public OpenClaw session adapter yet. Finish M2.0 T5 before enabling operator status sync.");
+    }
+    async cancelAcpSession(_sessionKey, _reason) {
+        throw new Error("ACP session cancel is not wired to a public OpenClaw session adapter yet. Finish M2.0 T7 before enabling operator cancel.");
+    }
+    async closeAcpSession(_sessionKey, _reason) {
+        throw new Error("ACP session close is not wired to a public OpenClaw session adapter yet. Finish M2.0 T7 before enabling operator close.");
+    }
+}

package/dist/src/runtime/openclaw-subagent-adapter.d.ts

@@ -0,0 +1,42 @@
+export type SubagentAcceptedRun = {
+    childSessionKey: string;
+    runId: string;
+    mode: "run" | "session";
+    acceptedAt?: string;
+    note?: string;
+    outputText?: string;
+};
+export type SubagentRunStatus = {
+    childSessionKey: string;
+    runId?: string;
+    state: "accepted" | "running" | "completed" | "failed" | "cancelled";
+    checkedAt?: string;
+    message?: string;
+    outputText?: string;
+};
+export type SubagentSpawnParams = {
+    task: string;
+    label?: string;
+    agentId?: string;
+    mode: "run" | "session";
+    thread: boolean;
+    runTimeoutSeconds?: number;
+};
+export interface OpenClawSubagentAdapter {
+    spawnSubagent(params: SubagentSpawnParams): Promise<SubagentAcceptedRun>;
+    getSubagentRunStatus(childSessionKey: string): Promise<SubagentRunStatus>;
+    killSubagentRun(childSessionKey: string, reason?: string): Promise<{
+        childSessionKey: string;
+        killedAt?: string;
+        message?: string;
+    }>;
+}
+export declare class UnsupportedOpenClawSubagentAdapter implements OpenClawSubagentAdapter {
+    spawnSubagent(_params: SubagentSpawnParams): Promise<SubagentAcceptedRun>;
+    getSubagentRunStatus(_childSessionKey: string): Promise<SubagentRunStatus>;
+    killSubagentRun(_childSessionKey: string, _reason?: string): Promise<{
+        childSessionKey: string;
+        killedAt?: string;
+        message?: string;
+    }>;
+}

package/dist/src/runtime/openclaw-subagent-adapter.js

@@ -0,0 +1,11 @@
+export class UnsupportedOpenClawSubagentAdapter {
+    async spawnSubagent(_params) {
+        throw new Error("OpenClaw public plugin SDK does not expose a stable subagent spawn surface for plugins yet. A real subagent runner would require a future public export or an intentional private deep-import experiment.");
+    }
+    async getSubagentRunStatus(_childSessionKey) {
+        throw new Error("OpenClaw public plugin SDK does not expose a stable subagent status surface for plugins yet. A real subagent runner would require a future public export or an intentional private deep-import experiment.");
+    }
+    async killSubagentRun(_childSessionKey, _reason) {
+        throw new Error("OpenClaw public plugin SDK does not expose a stable subagent kill surface for plugins yet. A real subagent runner would require a future public export or an intentional private deep-import experiment.");
+    }
+}

package/dist/src/runtime/public-api-seams.d.ts

@@ -0,0 +1,23 @@
+export type PublicApiAvailability = {
+    acpControlPlaneExport: boolean;
+    subagentSpawnExport: boolean;
+    readyReplacementPoints: string[];
+    notes: string[];
+};
+export declare const ACP_PUBLIC_REPLACEMENT_EXPORT = "getAcpSessionManager";
+export declare const SUBAGENT_PUBLIC_REPLACEMENT_EXPORT = "spawnSubagentDirect";
+export type ReplacementPlanItem = {
+    runner: "acp" | "subagent";
+    publicExport: string;
+    available: boolean;
+    status: "ready" | "blocked";
+    currentImplementation: string;
+    targetImplementation: string;
+    affectedModules: string[];
+    nextStep: string;
+};
+export declare function buildMigrationChecklist(plan: ReplacementPlanItem[]): string[];
+type SdkExports = Record<string, unknown>;
+export declare function detectPublicApiAvailability(sdkLoader?: () => Promise<SdkExports>): Promise<PublicApiAvailability>;
+export declare function buildReplacementPlan(availability: PublicApiAvailability): ReplacementPlanItem[];
+export {};