open-multi-agent-kit 0.78.0

package/dist/runtime/codex-runtime.js

@@ -0,0 +1,264 @@
+/**
+ * CodexRuntime — Codex CLI runtime adapter.
+ *
+ * Spawns the `codex` CLI subprocess and bridges AgentTask / AgentResult.
+ */
+import { capsuleToTask } from "./context-broker-converter.js";
+import { runShell, runShellStreaming, checkCommand } from "../util/shell.js";
+import { sanitizeUserVisibleOutput } from "../util/user-visible-output.js";
+import { buildChildEnv } from "./child-env.js";
+import { contextPreflightErrorMessage, preflightProviderInput, } from "../providers/context-preflight.js";
+import { createRuntimeSandboxProfile } from "./sandbox-profile.js";
+export class CodexRuntime {
+    id = "codex-cli";
+    kind = "cli";
+    priority = 60;
+    capabilities = {
+        read: true,
+        write: true,
+        shell: true,
+        mcp: false,
+        patch: true,
+        review: true,
+        merge: false,
+        vision: false,
+        supportsStreaming: false,
+        supportsStructuredOutput: false,
+        supportsToolCalling: true,
+    };
+    cwd;
+    bin;
+    model;
+    timeoutMs;
+    contextWindow;
+    reservedOutputTokens;
+    safetyMarginTokens;
+    constructor(options = {}) {
+        this.cwd = options.cwd ?? process.cwd();
+        this.bin = options.bin ?? process.env.CODEX_BIN ?? "codex";
+        this.model = options.model;
+        this.timeoutMs = options.timeoutMs ?? 120_000;
+        this.contextWindow = options.contextWindow;
+        this.reservedOutputTokens = options.reservedOutputTokens;
+        this.safetyMarginTokens = options.safetyMarginTokens;
+    }
+    supports(capsule) {
+        const routing = capsule.node.routing;
+        if (routing?.requiresMcp === true)
+            return false;
+        if (routing?.requiresToolCalling === true && this.capabilities.supportsToolCalling !== true)
+            return false;
+        for (const capability of routing?.assignedProviderCapabilities ?? []) {
+            if (capability === "read" && this.capabilities.read !== true)
+                return false;
+            if (capability === "write" && this.capabilities.write !== true)
+                return false;
+            if (capability === "shell" && this.capabilities.shell !== true)
+                return false;
+            if (capability === "mcp" && this.capabilities.mcp !== true)
+                return false;
+            if (capability === "patch" && this.capabilities.patch !== true)
+                return false;
+            if (capability === "review" && this.capabilities.review !== true)
+                return false;
+            if (capability === "merge" && this.capabilities.merge !== true)
+                return false;
+            if (capability === "vision" && this.capabilities.vision !== true)
+                return false;
+        }
+        return true;
+    }
+    async health() {
+        const available = await checkCommand(this.bin).catch(() => false);
+        return {
+            runtimeId: this.id,
+            available,
+            reason: available ? undefined : "codex CLI is not available on PATH",
+            checkedAt: new Date().toISOString(),
+        };
+    }
+    async runNode(capsule, signal) {
+        try {
+            const task = await capsuleToTask(capsule, signal);
+            const result = await this.execute(task);
+            return {
+                success: result.exitCode === 0,
+                exitCode: result.exitCode,
+                stdout: result.output,
+                stderr: "",
+                metadata: {
+                    runtime: this.id,
+                    ...(result.thinking && { thinking: result.thinking }),
+                    ...(result.metadata && { ...result.metadata }),
+                },
+            };
+        }
+        catch (err) {
+            const errorMsg = String(err);
+            return {
+                success: false,
+                exitCode: 1,
+                stdout: "",
+                stderr: errorMsg,
+                metadata: { runtime: this.id, error: errorMsg },
+            };
+        }
+    }
+    async execute(task) {
+        const prompt = this.buildPrompt(task);
+        const model = task.context.providerModel ?? task.context.env?.OMK_PROVIDER_MODEL ?? this.model ?? process.env.OMK_PROVIDER_MODEL;
+        const preflight = await preflightProviderInput(prompt, {
+            provider: "codex",
+            model,
+            contextWindow: this.contextWindow,
+            reservedOutputTokens: this.reservedOutputTokens,
+            safetyMarginTokens: this.safetyMarginTokens,
+            runId: task.context.runId,
+            nodeId: task.context.nodeId,
+            projectRoot: task.context.env?.OMK_PROJECT_ROOT ?? task.context.cwd ?? this.cwd,
+        });
+        if (!preflight.ok) {
+            return {
+                output: "",
+                exitCode: 1,
+                metadata: {
+                    runtime: this.id,
+                    error: contextPreflightErrorMessage(preflight.report),
+                    contextPreflight: preflight.report,
+                },
+            };
+        }
+        const providerPrompt = preflight.input;
+        const env = buildChildEnv({
+            overrideEnv: {
+                ...(task.context.env ?? {}),
+                OMK_RUN_ID: task.context.runId,
+                OMK_NODE_ID: task.context.nodeId,
+                OMK_ROLE: task.context.role ?? "",
+                OMK_GOAL: task.context.goal ?? "",
+                OMK_NODE_SKILLS: task.tools.skills?.join(",") ?? "",
+                OMK_NODE_MCP_SERVERS: task.tools.mcpServers?.join(",") ?? "",
+                OMK_NODE_TOOLS: task.tools.available.map((tool) => tool.name).join(","),
+                OMK_NODE_HOOKS: task.tools.hooks?.join(",") ?? "",
+                OMK_APPROVAL_POLICY: task.context.approvalPolicy ?? task.context.env?.OMK_APPROVAL_POLICY ?? "",
+                OMK_SANDBOX_MODE: task.context.sandboxMode ?? task.context.env?.OMK_SANDBOX_MODE ?? "",
+                OMK_TASK_RISK: task.context.risk ?? "",
+                ...(model ? { OMK_PROVIDER_MODEL: model } : {}),
+            },
+        });
+        const sandboxMode = task.context.sandboxMode === "read-only" || task.context.sandboxMode === "workspace-write"
+            ? task.context.sandboxMode
+            :
+                task.capabilities.write || task.capabilities.patch || task.capabilities.shell
+                    ? "workspace-write"
+                    : "read-only";
+        const approvalPolicy = codexApprovalPolicy(task.context.approvalPolicy ?? task.context.env?.OMK_APPROVAL_POLICY, sandboxMode);
+        const sandboxProfile = createRuntimeSandboxProfile({
+            cwd: this.cwd,
+            mode: sandboxMode,
+            enforcement: "provider-native",
+            writableRoots: sandboxMode === "workspace-write" ? [this.cwd] : [],
+            readableRoots: [this.cwd],
+            network: "unspecified",
+            secretEnvPolicy: "drop-by-default",
+            notes: [
+                "OMK sanitizes child env.",
+                "Codex CLI receives provider-native sandbox flags.",
+                "OMK does not yet enforce OS-level filesystem or network isolation.",
+            ],
+        });
+        const args = [
+            "exec",
+            "--sandbox", sandboxMode,
+            "--ask-for-approval", approvalPolicy,
+            "--cd", this.cwd,
+            "--color", "never",
+            "-",
+        ];
+        if (model && model !== "codex-cli") {
+            args.splice(1, 0, "--model", model);
+        }
+        try {
+            const useStreaming = typeof task.context.onOutput === "function";
+            const shellFn = useStreaming ? runShellStreaming : runShell;
+            const shellOptions = {
+                cwd: this.cwd,
+                input: providerPrompt,
+                timeout: this.timeoutMs,
+                signal: task.context.abortSignal,
+                inheritEnv: false,
+                env,
+            };
+            if (useStreaming && task.context.onOutput) {
+                shellOptions.onStdout = (line) => {
+                    task.context.onOutput?.(sanitizeUserVisibleOutput(line));
+                };
+            }
+            const shellResult = await shellFn(this.bin, args, shellOptions);
+            if (task.context.abortSignal?.aborted) {
+                return {
+                    output: shellResult.stdout,
+                    exitCode: 130,
+                    metadata: { error: "Request aborted" },
+                };
+            }
+            return {
+                output: shellResult.stdout,
+                exitCode: shellResult.exitCode,
+                metadata: {
+                    runtime: this.id,
+                    sandbox: sandboxMode,
+                    sandboxProfile,
+                    approvalPolicy,
+                    stderr: shellResult.stderr,
+                    failed: shellResult.failed,
+                    ...(preflight.report.compacted ? { contextPreflight: preflight.report } : {}),
+                },
+            };
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                return {
+                    output: "",
+                    exitCode: 130,
+                    metadata: { error: "Request aborted" },
+                };
+            }
+            return {
+                output: "",
+                exitCode: 1,
+                metadata: { error: String(err) },
+            };
+        }
+    }
+    buildPrompt(task) {
+        const parts = [];
+        if (task.context.system) {
+            parts.push("<system>");
+            parts.push(task.context.system);
+            parts.push("</system>");
+            parts.push("");
+        }
+        if (task.context.goal) {
+            parts.push(`Goal: ${task.context.goal}`);
+            parts.push("");
+        }
+        if (task.context.files && task.context.files.length > 0) {
+            parts.push("Relevant files:");
+            for (const file of task.context.files) {
+                parts.push(`- ${file}`);
+            }
+            parts.push("");
+        }
+        parts.push(task.prompt);
+        return parts.join("\n");
+    }
+}
+function codexApprovalPolicy(value, sandboxMode) {
+    if (sandboxMode !== "read-only")
+        return "on-request";
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "never" || normalized === "yolo")
+        return "never";
+    return "on-request";
+}

package/dist/runtime/command-bus.d.ts

@@ -0,0 +1,13 @@
+import type { CommandEnvelope, OmkEvent } from "./contracts/command-envelope.js";
+export interface CommandBusResult {
+    readonly handled: boolean;
+    readonly events: readonly OmkEvent[];
+    readonly output: string;
+}
+export type CommandHandler = (envelope: CommandEnvelope) => Promise<CommandBusResult>;
+export interface CommandBus {
+    dispatch(envelope: CommandEnvelope): Promise<CommandBusResult>;
+    registerHandler(command: string, handler: CommandHandler): void;
+    listCommands(): readonly string[];
+}
+export declare function createCommandBus(): CommandBus;

package/dist/runtime/command-bus.js

@@ -0,0 +1,57 @@
+import { classifyRisk } from "./debloat-nlp.js";
+function emitEvent(type, payload) {
+    return { type: type, timestamp: new Date().toISOString(), data: payload };
+}
+function isSlashCommand(text) {
+    return text.trimStart().startsWith("/");
+}
+function extractSlashCommand(text) {
+    const match = text.trimStart().match(/^\/([a-zA-Z0-9_-]+)/);
+    return match?.[1]?.toLowerCase() ?? "";
+}
+function resolveRisk(intent, raw) {
+    if (intent === "chat")
+        return classifyRisk("chat", raw);
+    return classifyRisk(intent, raw);
+}
+export function createCommandBus() {
+    const handlers = new Map();
+    const dispatch = async (envelope) => {
+        const events = [];
+        const text = envelope.rawText;
+        events.push(emitEvent("command:received", { text: text.slice(0, 120) }));
+        if (isSlashCommand(text)) {
+            const command = extractSlashCommand(text);
+            events.push(emitEvent("command:identified", { command, type: "slash" }));
+            const handler = handlers.get(command);
+            if (handler) {
+                events.push(emitEvent("command:dispatching", { command }));
+                const result = await handler(envelope);
+                return {
+                    ...result,
+                    events: [...events, ...result.events],
+                };
+            }
+            events.push(emitEvent("command:unhandled", { command }));
+            return {
+                handled: false,
+                events,
+                output: `Unknown command: /${command}. Use /help for available commands.`,
+            };
+        }
+        const risk = resolveRisk("chat", text);
+        events.push(emitEvent("command:fallback", { risk, intent: "chat" }));
+        return {
+            handled: false,
+            events,
+            output: "",
+        };
+    };
+    const registerHandler = (command, handler) => {
+        handlers.set(command.toLowerCase(), handler);
+    };
+    const listCommands = () => {
+        return [...handlers.keys()];
+    };
+    return { dispatch, registerHandler, listCommands };
+}

package/dist/runtime/context-broker-converter.d.ts

@@ -0,0 +1,9 @@
+import type { ContextCapsule } from "./context-capsule.js";
+import type { AgentTask } from "./agent-runtime.js";
+export declare function capsuleToTask(capsule: ContextCapsule, options?: AbortSignal | CapsuleToTaskOptions): Promise<AgentTask>;
+export interface CapsuleToTaskOptions {
+    readonly signal?: AbortSignal;
+    readonly cwd?: string;
+    readonly env?: Record<string, string>;
+    readonly fallbackChain?: readonly string[];
+}

package/dist/runtime/context-broker-converter.js

@@ -0,0 +1,96 @@
+export async function capsuleToTask(capsule, options = {}) {
+    const taskOptions = isAbortSignal(options)
+        ? { signal: options }
+        : options;
+    const node = capsule.node;
+    const routing = node.routing;
+    const context = {
+        runId: capsule.runId,
+        nodeId: capsule.nodeId,
+        role: node.role,
+        goal: capsule.goal,
+        system: capsule.system,
+        files: capsule.relevantFiles.map((f) => f.path),
+        memory: capsule.graphMemory.map((m) => ({
+            key: m.key,
+            source: m.kind,
+            summary: m.value,
+        })),
+        abortSignal: taskOptions.signal,
+        cwd: taskOptions.cwd,
+        env: taskOptions.env,
+        providerModel: routing?.providerModel,
+        risk: routing?.risk,
+        approvalPolicy: routing?.approvalPolicy ?? routing?.executionPrompt,
+        sandboxMode: routing?.sandboxMode,
+    };
+    const toolNames = routing?.tools ?? routing?.assignedCapabilities?.tools ?? [];
+    const mcpServers = routing?.mcpServers ?? routing?.assignedCapabilities?.mcpServers ?? [];
+    const skills = routing?.skills ?? routing?.assignedCapabilities?.skills ?? [];
+    const hooks = routing?.hooks ?? routing?.assignedCapabilities?.hooks ?? [];
+    const tools = {
+        available: toolNames.map((name) => ({
+            name,
+            description: "",
+            inputSchema: {},
+        })),
+        mcpServers,
+        skills,
+        hooks,
+    };
+    const preferredProviders = [];
+    if (routing?.provider && routing.provider !== "auto") {
+        preferredProviders.push(routing.provider);
+    }
+    if (routing?.candidateProviders?.length) {
+        preferredProviders.push(...routing.candidateProviders);
+    }
+    const fallbackChain = [...(taskOptions.fallbackChain ?? [])];
+    if (routing?.fallbackProvider && !fallbackChain.includes(routing.fallbackProvider)) {
+        fallbackChain.push(routing.fallbackProvider);
+    }
+    const providerPolicy = {
+        strategy: "priority-first",
+        preferredProviders,
+        fallbackChain,
+        maxCost: undefined,
+        maxLatencyMs: undefined,
+    };
+    const capabilities = capabilitiesFromNode(capsule);
+    const task = {
+        prompt: capsule.task,
+        context,
+        tools,
+        providerPolicy,
+        capabilities,
+    };
+    return task;
+}
+function isAbortSignal(value) {
+    return "aborted" in value && typeof value.addEventListener === "function";
+}
+function capabilitiesFromNode(capsule) {
+    const node = capsule.node;
+    const routing = node.routing;
+    const role = node.role?.toLowerCase() ?? "";
+    const gates = node.outputs?.map((output) => output.gate).filter(Boolean) ?? [];
+    const assigned = new Set(routing?.assignedProviderCapabilities ?? []);
+    const merge = assigned.has("merge") || role === "merger" || role === "integrator" || role === "orchestrator";
+    const write = assigned.has("write") || merge || role === "coder" || role === "executor" || role === "refactorer";
+    const shell = assigned.has("shell") || routing?.requiresToolCalling === true || gates.includes("command-pass") || gates.includes("test-pass");
+    const review = assigned.has("review") || role === "reviewer" || role === "qa" || role === "tester" || gates.includes("review-pass");
+    const mcp = assigned.has("mcp") || routing?.requiresMcp === true;
+    const vision = assigned.has("vision");
+    return {
+        read: true,
+        write: routing?.readOnly === true ? false : write,
+        shell,
+        mcp,
+        patch: routing?.readOnly === true ? false : write,
+        review,
+        merge,
+        vision,
+        toolCalling: routing?.requiresToolCalling === true || assigned.has("toolCalling"),
+        maxTokens: capsule.budget.maxInputTokens,
+    };
+}

package/dist/runtime/context-broker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ContextBroker — builds ContextCapsule from DAG state.
+ *
+ * Collects dependency outputs, graph memory, prior attempts,
+ * evidence requirements into a bounded capsule.
+ *
+ * Integrates ContextBudgetOptimizer for priority-based trimming.
+ */
+import type { DagNode } from "../orchestration/dag.js";
+import type { RunState } from "../contracts/orchestration.js";
+import { type ContextCapsule } from './context-capsule.js';
+import type { ContextAdjustment } from "../evidence/attempt-record.js";
+import { type ContextBudgetReport } from "./context-budget-optimizer.js";
+export interface ContextBrokerOptions {
+    readonly projectRoot?: string;
+    readonly graphMemoryPath?: string;
+    readonly goal?: string;
+    readonly system?: string;
+}
+export declare function createContextBroker(options?: ContextBrokerOptions): {
+    buildCapsule: (node: DagNode, state?: RunState, adjustment?: ContextAdjustment) => Promise<{
+        capsule: ContextCapsule;
+        report: ContextBudgetReport;
+    }>;
+};