@executioncontrolprotocol/runtime 0.3.0

package/dist/engine/runner.js

@@ -0,0 +1,852 @@
+/**
+ * ECP Execution Engine — the core runner that orchestrates a Context
+ * execution from start to finish.
+ *
+ * Slice 1: Single executor, seed mounts, model generation, schema validation.
+ * Slice 2 (added in Milestone 7): Controller-specialist delegation.
+ *
+ * @category Engine
+ */
+import { loadContext, resolveInputs } from "./context-loader.js";
+import { validateOutput } from "./schema-validator.js";
+import { DefaultMountHydrator } from "../mounts/hydrator.js";
+import { createPolicyEnforcer } from "../policies/enforcer.js";
+/**
+ * The ECP execution engine.
+ *
+ * Wires together the model provider, tool invoker, and agent transport
+ * to execute a Context manifest end-to-end.
+ *
+ * @category Engine
+ */
+export class ECPEngine {
+    modelProvider;
+    extensionRegistry;
+    modelProviderCache = new Map();
+    toolInvoker;
+    agentTransport;
+    config;
+    hydrator;
+    traceCollector;
+    constructor(modelProvider, toolInvoker, agentTransport, config = {}) {
+        this.modelProvider = modelProvider;
+        this.extensionRegistry = config.extensions?.registry;
+        this.toolInvoker = toolInvoker;
+        this.agentTransport = agentTransport;
+        this.config = config;
+        this.hydrator = new DefaultMountHydrator(toolInvoker);
+    }
+    /**
+     * Attach a trace collector to the engine.
+     * When attached, the engine emits structured trace spans during execution.
+     */
+    setTraceCollector(collector) {
+        this.traceCollector = collector;
+    }
+    /**
+     * Execute a Context manifest end-to-end.
+     *
+     * @param options - Run configuration.
+     * @returns The execution result.
+     */
+    async run(options) {
+        const startTime = Date.now();
+        const state = await this.initRunState(options);
+        try {
+            await this.connectToolServers(state);
+            const strategy = this.getStrategy(state.context);
+            if (strategy === "single") {
+                await this.runSingleExecutor(state, options.signal);
+            }
+            else if (strategy === "sequential" || strategy === "delegate" || strategy === "swarm") {
+                await this.runControllerSpecialist(state, options.signal);
+            }
+            else {
+                throw new Error(`Unsupported orchestration strategy: "${strategy}"`);
+            }
+            state.status = "completed";
+            state.endedAt = new Date().toISOString();
+            await this.emitProgress(state, { type: "phase", status: "completed" });
+        }
+        catch (err) {
+            state.status = "failed";
+            state.endedAt = new Date().toISOString();
+            await this.emitProgress(state, { type: "phase", status: "failed" });
+            this.log(state, "error", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            await this.toolInvoker.disconnectAll();
+        }
+        const result = this.buildResult(state, startTime);
+        if (this.traceCollector) {
+            const trace = this.traceCollector.buildTrace({
+                executionId: state.runId,
+                contextName: state.context.metadata.name,
+                contextVersion: state.context.metadata.version,
+                strategy: this.getStrategy(state.context),
+                startedAt: state.startedAt,
+                endedAt: state.endedAt ?? new Date().toISOString(),
+                durationMs: result.durationMs,
+                success: result.success,
+                error: result.error,
+            });
+            result.trace = trace;
+            await this.traceCollector.exportAll(trace);
+        }
+        return result;
+    }
+    // ---------------------------------------------------------------------------
+    // Slice 1: Single executor
+    // ---------------------------------------------------------------------------
+    async runSingleExecutor(state, signal) {
+        const entrypointName = this.getEntrypointName(state.context);
+        const executorState = state.executors.get(entrypointName);
+        if (!executorState) {
+            throw new Error(`Entrypoint executor "${entrypointName}" not found`);
+        }
+        state.status = "hydrating-seed";
+        await this.emitProgress(state, { type: "phase", status: "hydrating-seed" });
+        this.log(state, "info", `Hydrating seed mounts for "${entrypointName}"`);
+        await this.hydrateMounts(state, executorState, state.inputs, "seed");
+        state.status = "running-orchestrator";
+        await this.emitProgress(state, { type: "phase", status: "running-orchestrator" });
+        this.log(state, "info", `Running executor "${entrypointName}"`);
+        await this.runExecutor(executorState, state, signal);
+    }
+    // ---------------------------------------------------------------------------
+    // Slice 2: Controller-specialist
+    // ---------------------------------------------------------------------------
+    async runControllerSpecialist(state, signal) {
+        const entrypointName = this.getEntrypointName(state.context);
+        const orchestratorState = state.executors.get(entrypointName);
+        if (!orchestratorState) {
+            throw new Error(`Orchestrator executor "${entrypointName}" not found`);
+        }
+        // Phase 1: Hydrate orchestrator seed mounts
+        state.status = "hydrating-seed";
+        await this.emitProgress(state, { type: "phase", status: "hydrating-seed" });
+        this.log(state, "info", `Hydrating seed mounts for orchestrator "${entrypointName}"`);
+        await this.hydrateMounts(state, orchestratorState, state.inputs, "seed");
+        // Phase 2: Run orchestrator to produce plan
+        state.status = "running-orchestrator";
+        await this.emitProgress(state, { type: "phase", status: "running-orchestrator" });
+        this.log(state, "info", `Running orchestrator "${entrypointName}"`);
+        await this.runExecutor(orchestratorState, state, signal);
+        if (!orchestratorState.output) {
+            throw new Error("Orchestrator did not produce an output");
+        }
+        const plan = orchestratorState.output;
+        const delegations = (plan.delegate ?? []);
+        if (delegations.length === 0) {
+            this.log(state, "info", "No delegations in plan, execution complete");
+            return;
+        }
+        // Phase 3: Hydrate focus mounts for specialists and delegate tasks
+        state.status = "delegating";
+        await this.emitProgress(state, { type: "phase", status: "delegating" });
+        this.log(state, "info", `Delegating ${delegations.length} task(s) to specialists`);
+        for (const delegation of delegations) {
+            const specialistState = state.executors.get(delegation.executor);
+            if (!specialistState) {
+                this.log(state, "warn", `Specialist "${delegation.executor}" not found, skipping`);
+                continue;
+            }
+            // Hydrate focus mounts using plan output as selector source
+            state.status = "hydrating-focus";
+            await this.emitProgress(state, { type: "phase", status: "hydrating-focus" });
+            await this.hydrateMounts(state, specialistState, state.inputs, "focus", plan);
+            state.status = "hydrating-deep";
+            await this.emitProgress(state, { type: "phase", status: "hydrating-deep" });
+            await this.hydrateMounts(state, specialistState, state.inputs, "deep", plan);
+            // Run specialist (locally or via A2A)
+            state.status = "running-specialist";
+            await this.emitProgress(state, { type: "phase", status: "running-specialist" });
+            const endpoint = this.config.agentEndpoints?.[delegation.executor];
+            if (endpoint) {
+                await this.delegateViaA2A(specialistState, delegation, endpoint, state);
+            }
+            else {
+                this.log(state, "info", `Running specialist "${delegation.executor}" locally`);
+                await this.runExecutor(specialistState, state, signal, delegation.task);
+            }
+        }
+        // Phase 4: Merge outputs if there's a publisher/merger executor
+        const producesSchema = state.context.orchestration?.produces;
+        if (producesSchema) {
+            state.status = "merging";
+            await this.emitProgress(state, { type: "phase", status: "merging" });
+            await this.mergeOutputs(state, producesSchema, signal);
+        }
+    }
+    async delegateViaA2A(specialistState, delegation, endpoint, state) {
+        this.log(state, "info", `Delegating to "${delegation.executor}" via A2A at ${endpoint}`);
+        const stepNum = this.nextStep(state);
+        await this.emitProgress(state, {
+            type: "step_start",
+            step: stepNum,
+            kind: "delegation",
+            executorName: delegation.executor,
+            description: `Delegate to ${delegation.executor}`,
+        });
+        const startDel = Date.now();
+        const agentRef = {
+            name: delegation.executor,
+            endpoint,
+        };
+        const task = {
+            id: `${state.runId}-${delegation.executor}`,
+            executorName: delegation.executor,
+            task: delegation.task,
+            context: {
+                mountData: specialistState.mountOutputs.map((m) => ({
+                    name: m.mountName,
+                    data: m.data,
+                })),
+            },
+            hints: delegation.hints,
+        };
+        const result = await this.agentTransport.delegate(agentRef, task);
+        await this.emitProgress(state, {
+            type: "step_complete",
+            step: this.nextCompleteStep(state),
+            kind: "delegation",
+            executorName: delegation.executor,
+            description: `Delegate to ${delegation.executor}`,
+            durationMs: Date.now() - startDel,
+        });
+        specialistState.status = result.success ? "completed" : "failed";
+        specialistState.output = result.output;
+        specialistState.error = result.error;
+    }
+    async mergeOutputs(state, producesSchemaName, signal) {
+        const executorNames = [...state.executors.keys()];
+        const mergerName = executorNames.find((name) => {
+            const ex = state.executors.get(name);
+            const ref = ex.executor.outputSchemaRef?.replace("#/schemas/", "");
+            return ref === producesSchemaName && name !== this.getEntrypointName(state.context);
+        });
+        if (mergerName) {
+            const mergerState = state.executors.get(mergerName);
+            this.log(state, "info", `Running merger "${mergerName}"`);
+            const priorOutputs = {};
+            for (const [name, es] of state.executors) {
+                if (es.output && name !== mergerName) {
+                    priorOutputs[name] = es.output;
+                }
+            }
+            mergerState.mountOutputs.push({
+                mountName: "__prior_outputs",
+                stage: "seed",
+                data: priorOutputs,
+                itemCount: Object.keys(priorOutputs).length,
+            });
+            await this.runExecutor(mergerState, state, signal);
+            return;
+        }
+        this.log(state, "info", "No dedicated merger executor; orchestrator output is final");
+    }
+    // ---------------------------------------------------------------------------
+    // Executor runner (shared by all strategies)
+    // ---------------------------------------------------------------------------
+    async runExecutor(executorState, state, signal, taskOverride) {
+        const executor = executorState.executor;
+        executorState.status = "running";
+        const executorStepNum = this.nextStep(state);
+        await this.emitProgress(state, {
+            type: "step_start",
+            step: executorStepNum,
+            kind: "executor",
+            executorName: executor.name,
+            description: `Executor ${executor.name}`,
+        });
+        const modelProvider = this.resolveModelProvider(executor, state.context);
+        const enforcer = createPolicyEnforcer(executor.policies ?? {});
+        const startTime = Date.now();
+        const executorSpanId = this.traceCollector?.startSpan({
+            type: "executor",
+            executorName: executor.name,
+        });
+        const messages = this.buildMessages(executor, executorState, state.inputs, taskOverride);
+        const tools = await this.getAvailableTools(executor, modelProvider, enforcer, state);
+        const model = this.config.modelOverride ?? executor.model?.name ?? this.config.defaultModel ?? "gpt-4o";
+        const outputSchema = this.getOutputSchema(executor, state.context);
+        const currentMessages = [...messages];
+        const maxRounds = 10;
+        let lastTokenUsage = {
+            prompt: 0,
+            completion: 0,
+            total: 0,
+        };
+        let lastModel = model;
+        for (let round = 0; round < maxRounds; round++) {
+            const budgetCheck = enforcer.checkBudget(executorState.budgetUsage);
+            if (!budgetCheck.withinBudget) {
+                this.log(state, "warn", `Budget exceeded for "${executor.name}": ${budgetCheck.message}`);
+                break;
+            }
+            const modelStepNum = this.nextStep(state);
+            await this.emitProgress(state, {
+                type: "step_start",
+                step: modelStepNum,
+                kind: "model",
+                executorName: executor.name,
+                description: `Executor ${executor.name} — ${model}`,
+            });
+            const genSpanId = this.traceCollector?.startSpan({
+                type: "model-generation",
+                executorName: executor.name,
+                parentId: executorSpanId,
+                model,
+            });
+            const genStart = Date.now();
+            const result = await modelProvider.generate({
+                messages: currentMessages,
+                model,
+                tools: tools.length > 0 ? tools : undefined,
+                temperature: this.config.defaultTemperature,
+                responseFormat: outputSchema ? {
+                    type: "json-schema",
+                    schema: this.schemaToJsonSchema(outputSchema, executor),
+                } : undefined,
+                signal,
+            });
+            const reasoning = result.finishReason === "tool-calls" ? result.content || undefined : undefined;
+            if (reasoning) {
+                await this.emitProgress(state, {
+                    type: "executor_reasoning",
+                    executorName: executor.name,
+                    reasoning,
+                });
+            }
+            if (genSpanId) {
+                this.traceCollector?.endSpan(genSpanId, {
+                    tokens: {
+                        prompt: result.usage.promptTokens,
+                        completion: result.usage.completionTokens,
+                        total: result.usage.totalTokens,
+                    },
+                    reasoning: reasoning ?? undefined,
+                    output: result.finishReason !== "tool-calls" ? this.tryParseJson(result.content) : undefined,
+                });
+            }
+            lastTokenUsage = {
+                prompt: lastTokenUsage.prompt + result.usage.promptTokens,
+                completion: lastTokenUsage.completion + result.usage.completionTokens,
+                total: lastTokenUsage.total + result.usage.totalTokens,
+            };
+            lastModel = model;
+            await this.emitProgress(state, {
+                type: "step_complete",
+                step: this.nextCompleteStep(state),
+                kind: "model",
+                executorName: executor.name,
+                description: `Executor ${executor.name} — ${model}`,
+                durationMs: Date.now() - genStart,
+                reasoning: reasoning ?? undefined,
+            });
+            if (result.finishReason === "tool-calls" && result.toolCalls.length > 0) {
+                currentMessages.push({
+                    role: "assistant",
+                    content: result.content,
+                });
+                const toolResults = await this.executeToolCalls(result.toolCalls, executor, enforcer, executorState, state, executorSpanId);
+                for (const tr of toolResults) {
+                    currentMessages.push(tr);
+                }
+                continue;
+            }
+            executorState.budgetUsage.runtimeSeconds = (Date.now() - startTime) / 1000;
+            if (result.content) {
+                try {
+                    const parsed = JSON.parse(result.content);
+                    executorState.output = typeof parsed === "object" && parsed !== null
+                        ? parsed
+                        : { result: parsed };
+                }
+                catch {
+                    executorState.output = { result: result.content };
+                }
+            }
+            break;
+        }
+        if (executorState.output && outputSchema) {
+            const validation = validateOutput(executorState.output, outputSchema);
+            if (!validation.valid) {
+                this.log(state, "warn", `Output validation failed for "${executor.name}": ${validation.errors.join(", ")}`);
+            }
+        }
+        executorState.status = executorState.output ? "completed" : "failed";
+        executorState.error = executorState.output ? undefined : "No output produced";
+        await this.emitProgress(state, {
+            type: "step_complete",
+            step: this.nextExecutorStep(state),
+            kind: "executor",
+            executorName: executor.name,
+            description: `Executor ${executor.name}`,
+            durationMs: Date.now() - startTime,
+            output: executorState.output,
+            tokens: lastTokenUsage.total > 0 ? lastTokenUsage : undefined,
+            model: lastModel,
+        });
+        if (executorSpanId) {
+            this.traceCollector?.endSpan(executorSpanId, {
+                output: executorState.output,
+                error: executorState.error,
+            });
+        }
+        this.log(state, "info", `Executor "${executor.name}" ${executorState.status} (${executorState.budgetUsage.runtimeSeconds.toFixed(1)}s)`);
+    }
+    async executeToolCalls(toolCalls, _executor, enforcer, executorState, state, parentSpanId) {
+        const results = [];
+        for (const tc of toolCalls) {
+            executorState.budgetUsage.toolCalls++;
+            const [serverName, toolName] = this.parseToolName(tc.name);
+            const accessCheck = enforcer.checkToolAccess(tc.name);
+            if (!accessCheck.allowed) {
+                this.log(state, "warn", `Tool call denied: ${tc.name} — ${accessCheck.reason}`);
+                results.push({
+                    role: "tool",
+                    toolCallId: tc.id,
+                    content: JSON.stringify({ error: accessCheck.reason }),
+                });
+                continue;
+            }
+            const toolStepNum = this.nextStep(state);
+            await this.emitProgress(state, {
+                type: "step_start",
+                step: toolStepNum,
+                kind: "tool",
+                executorName: executorState.executor.name,
+                description: `Tool ${tc.name}`,
+            });
+            const toolStart = Date.now();
+            const toolSpanId = this.traceCollector?.startSpan({
+                type: "tool-call",
+                executorName: executorState.executor.name,
+                parentId: parentSpanId,
+                toolName: tc.name,
+                toolArgs: tc.arguments,
+            });
+            try {
+                const result = await this.toolInvoker.callTool(serverName, toolName, tc.arguments);
+                this.log(state, "debug", `Tool ${tc.name} returned (isError: ${result.isError})`);
+                if (toolSpanId) {
+                    this.traceCollector?.endSpan(toolSpanId, {
+                        toolResult: result.content,
+                        toolIsError: result.isError,
+                    });
+                }
+                await this.emitProgress(state, {
+                    type: "step_complete",
+                    step: this.nextCompleteStep(state),
+                    kind: "tool",
+                    executorName: executorState.executor.name,
+                    description: `Tool ${tc.name}`,
+                    durationMs: Date.now() - toolStart,
+                });
+                results.push({
+                    role: "tool",
+                    toolCallId: tc.id,
+                    content: typeof result.content === "string"
+                        ? result.content
+                        : JSON.stringify(result.content),
+                });
+            }
+            catch (err) {
+                if (toolSpanId) {
+                    this.traceCollector?.endSpan(toolSpanId, {
+                        error: err instanceof Error ? err.message : String(err),
+                        toolIsError: true,
+                    });
+                }
+                await this.emitProgress(state, {
+                    type: "step_complete",
+                    step: this.nextCompleteStep(state),
+                    kind: "tool",
+                    executorName: executorState.executor.name,
+                    description: `Tool ${tc.name}`,
+                    durationMs: Date.now() - toolStart,
+                });
+                results.push({
+                    role: "tool",
+                    toolCallId: tc.id,
+                    content: JSON.stringify({
+                        error: err instanceof Error ? err.message : String(err),
+                    }),
+                });
+            }
+        }
+        return results;
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    async initRunState(options) {
+        const context = options.context ?? loadContext(options.contextPath);
+        const inputs = resolveInputs(context, options.inputs ?? {});
+        const state = {
+            runId: `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            context,
+            inputs,
+            status: "loading",
+            executors: new Map(),
+            log: [],
+            startedAt: new Date().toISOString(),
+        };
+        for (const executor of this.getExecutionObjects(context)) {
+            state.executors.set(executor.name, {
+                executor,
+                status: "pending",
+                mountOutputs: [],
+                budgetUsage: { toolCalls: 0, runtimeSeconds: 0 },
+            });
+        }
+        this.log(state, "info", `Loaded Context "${context.metadata.name}" v${context.metadata.version} ` +
+            `(${state.executors.size} execution objects, strategy: ${this.getStrategy(context)})`);
+        state.progressStepCounter = 0;
+        state.progressCompleteCounter = 0;
+        state.progressExecutorStepCounter = 0;
+        await this.emitProgress(state, { type: "phase", status: "loading" });
+        return state;
+    }
+    async emitProgress(_state, event) {
+        const callbacks = this.config.onProgress
+            ? Array.isArray(this.config.onProgress)
+                ? this.config.onProgress
+                : [this.config.onProgress]
+            : [];
+        for (const cb of callbacks) {
+            try {
+                await cb(event);
+            }
+            catch {
+                // Ignore progress callback errors so they do not break the run.
+            }
+        }
+    }
+    nextStep(state) {
+        state.progressStepCounter = (state.progressStepCounter ?? 0) + 1;
+        return state.progressStepCounter;
+    }
+    /** Return the next completion step number (1, 2, 3...) for step_complete events. */
+    nextCompleteStep(state) {
+        state.progressCompleteCounter = (state.progressCompleteCounter ?? 0) + 1;
+        return state.progressCompleteCounter;
+    }
+    /** Return the next executor step number (1, 2, 3...) for executor step_complete only. */
+    nextExecutorStep(state) {
+        state.progressExecutorStepCounter = (state.progressExecutorStepCounter ?? 0) + 1;
+        return state.progressExecutorStepCounter;
+    }
+    async connectToolServers(state) {
+        const servers = this.config.toolServers ?? {};
+        for (const [name, config] of Object.entries(servers)) {
+            try {
+                await this.toolInvoker.connect({ name, transport: config.transport });
+                this.log(state, "info", `Connected to tool server "${name}"`);
+            }
+            catch (err) {
+                this.log(state, "warn", `Failed to connect to tool server "${name}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    async hydrateMounts(state, executorState, inputs, stage, planOutput) {
+        const mounts = executorState.executor.mounts ?? [];
+        const executorName = executorState.executor.name;
+        for (const mount of mounts) {
+            if (mount.stage !== stage)
+                continue;
+            const stepNum = this.nextStep(state);
+            await this.emitProgress(state, {
+                type: "step_start",
+                step: stepNum,
+                kind: "mount",
+                executorName,
+                description: `Mount ${mount.name} (${stage})`,
+            });
+            const mountSpanId = this.traceCollector?.startSpan({
+                type: "mount-hydration",
+                executorName: executorState.executor.name,
+                mountName: mount.name,
+                mountStage: stage,
+            });
+            const startMount = Date.now();
+            const outputs = await this.hydrator.hydrateStage([mount], stage, inputs, planOutput);
+            executorState.mountOutputs.push(...outputs);
+            const durationMs = Date.now() - startMount;
+            if (mountSpanId) {
+                const totalItems = outputs.reduce((sum, o) => sum + o.itemCount, 0);
+                this.traceCollector?.endSpan(mountSpanId, { mountItemCount: totalItems });
+            }
+            await this.emitProgress(state, {
+                type: "step_complete",
+                step: this.nextCompleteStep(state),
+                kind: "mount",
+                executorName,
+                description: `Mount ${mount.name} (${stage})`,
+                durationMs,
+            });
+        }
+    }
+    buildMessages(executor, executorState, inputs, taskOverride) {
+        const messages = [];
+        if (executor.instructions) {
+            messages.push({
+                role: "system",
+                content: executor.instructions,
+            });
+        }
+        const mountContext = executorState.mountOutputs
+            .filter((m) => m.itemCount > 0)
+            .map((m) => `## ${m.mountName} (${m.stage}, ${m.itemCount} items)\n${JSON.stringify(m.data, null, 2)}`)
+            .join("\n\n");
+        const inputsBlock = Object.keys(inputs).length > 0
+            ? `Context inputs:\n${JSON.stringify(inputs, null, 2)}\n\n`
+            : "";
+        const userContent = taskOverride
+            ? `Task: ${taskOverride}\n\n${inputsBlock}Available data:\n${mountContext}`
+            : `${inputsBlock}Execute your role using the following data:\n\n${mountContext}`.trim();
+        messages.push({
+            role: "user",
+            content: userContent,
+        });
+        return messages;
+    }
+    async getAvailableTools(executor, modelProvider, _enforcer, _state) {
+        if (!modelProvider.supportsToolCalling())
+            return [];
+        const allowed = executor.policies?.toolAccess?.allow ?? [];
+        if (allowed.length === 0)
+            return [];
+        const tools = [];
+        for (const toolRef of allowed) {
+            const [serverName, toolName] = this.parseToolName(toolRef);
+            try {
+                const serverTools = await this.toolInvoker.listTools(serverName);
+                const match = serverTools.find((t) => t.name === toolName);
+                if (match) {
+                    tools.push({
+                        name: toolRef,
+                        description: match.description,
+                        parameters: match.inputSchema,
+                    });
+                }
+            }
+            catch {
+                // ignore: server not connected or tool not found
+            }
+        }
+        return tools;
+    }
+    getOutputSchema(executor, context) {
+        if (executor.outputSchema) {
+            return executor.outputSchema;
+        }
+        if (!executor.outputSchemaRef)
+            return undefined;
+        const schemaName = executor.outputSchemaRef.replace("#/schemas/", "");
+        return context.schemas?.[schemaName];
+    }
+    schemaToJsonSchema(schema, _executor) {
+        return {
+            type: schema.type,
+            properties: schema.properties ?? {},
+            required: schema.required ?? [],
+            additionalProperties: true,
+        };
+    }
+    tryParseJson(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            return content || undefined;
+        }
+    }
+    parseToolName(qualifiedName) {
+        const colonIdx = qualifiedName.indexOf(":");
+        if (colonIdx === -1) {
+            return ["default", qualifiedName];
+        }
+        return [qualifiedName.slice(0, colonIdx), qualifiedName.slice(colonIdx + 1)];
+    }
+    log(state, level, message) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+        };
+        state.log.push(entry);
+        if (this.config.debug || level === "error") {
+            const prefix = level.toUpperCase().padEnd(5);
+            console.error(`[ECP ${prefix}] ${message}`);
+        }
+    }
+    buildResult(state, startTime) {
+        const executorOutputs = {};
+        const totalBudget = { toolCalls: 0, runtimeSeconds: 0 };
+        for (const [name, es] of state.executors) {
+            if (es.output) {
+                executorOutputs[name] = es.output;
+            }
+            totalBudget.toolCalls += es.budgetUsage.toolCalls;
+            totalBudget.runtimeSeconds += es.budgetUsage.runtimeSeconds;
+        }
+        const producesSchema = state.context.orchestration?.produces;
+        let finalOutput;
+        if (producesSchema) {
+            for (const [, es] of state.executors) {
+                const ref = es.executor.outputSchemaRef?.replace("#/schemas/", "");
+                if (ref === producesSchema && es.output) {
+                    finalOutput = es.output;
+                    break;
+                }
+            }
+        }
+        if (!finalOutput) {
+            const entrypoint = this.getEntrypointName(state.context);
+            finalOutput = state.executors.get(entrypoint)?.output;
+        }
+        const failed = state.status === "failed";
+        const errorEntries = state.log.filter((e) => e.level === "error");
+        return {
+            success: !failed,
+            runId: state.runId,
+            contextName: state.context.metadata.name,
+            contextVersion: state.context.metadata.version,
+            output: finalOutput,
+            executorOutputs,
+            totalBudgetUsage: totalBudget,
+            log: state.log,
+            durationMs: Date.now() - startTime,
+            error: failed ? errorEntries.map((e) => e.message).join("; ") : undefined,
+        };
+    }
+    getEntrypointName(context) {
+        const entrypoint = context.orchestrator?.name ?? context.orchestration?.entrypoint;
+        if (!entrypoint) {
+            throw new Error("Context entrypoint is not defined. Set orchestrator.name or orchestration.entrypoint.");
+        }
+        return entrypoint;
+    }
+    getStrategy(context) {
+        const strategy = context.orchestration?.strategy ?? context.orchestrator?.strategy;
+        if (!strategy) {
+            throw new Error("Context strategy is not defined. Set orchestration.strategy or orchestrator.strategy.");
+        }
+        return strategy;
+    }
+    getExecutionObjects(context) {
+        const executionObjects = new Map();
+        const addExecutionObject = (executor) => {
+            if (!executionObjects.has(executor.name)) {
+                executionObjects.set(executor.name, executor);
+            }
+        };
+        const visitOrchestrator = (orchestrator) => {
+            addExecutionObject(orchestrator);
+            for (const executor of orchestrator.executors ?? []) {
+                addExecutionObject(executor);
+            }
+            for (const child of orchestrator.orchestrators ?? []) {
+                visitOrchestrator(child);
+            }
+        };
+        if (context.orchestrator) {
+            visitOrchestrator(context.orchestrator);
+        }
+        for (const executor of context.executors ?? []) {
+            addExecutionObject(executor);
+        }
+        return [...executionObjects.values()];
+    }
+    resolveModelProvider(executor, context) {
+        const providerSelector = executor.model?.provider;
+        if (!providerSelector || !this.extensionRegistry) {
+            return this.modelProvider;
+        }
+        const providerRef = this.normalizeProviderSelector(providerSelector);
+        this.assertModelProviderAllowed(providerRef, context);
+        const registration = this.extensionRegistry.getModelProviderRegistration(providerRef.name);
+        if (!registration) {
+            throw new Error(`Model provider extension "${providerRef.name}" is not registered.`);
+        }
+        if (registration.sourceType !== providerRef.type) {
+            throw new Error(`Model provider "${providerRef.name}" expected source type "${providerRef.type}", got "${registration.sourceType}".`);
+        }
+        if (registration.version !== providerRef.version) {
+            throw new Error(`Model provider "${providerRef.name}" version mismatch: expected "${providerRef.version}", got "${registration.version}".`);
+        }
+        const cacheKey = `${providerRef.type}:${providerRef.name}:${providerRef.version}`;
+        const cached = this.modelProviderCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const providerConfig = context.extensions?.config?.[providerRef.name];
+        const created = this.extensionRegistry.createModelProvider(providerRef.name, providerConfig);
+        this.modelProviderCache.set(cacheKey, created);
+        return created;
+    }
+    normalizeProviderSelector(selector) {
+        if (typeof selector === "string") {
+            return {
+                name: selector,
+                type: "builtin",
+                version: "0.3.0",
+            };
+        }
+        return selector;
+    }
+    assertModelProviderAllowed(provider, context) {
+        const security = this.getEffectiveExtensionSecurity(context);
+        if (security.allowKinds?.length && !security.allowKinds.includes("model-provider")) {
+            throw new Error(`Model provider "${provider.name}" denied: kind "model-provider" is not allowed.`);
+        }
+        if (security.allowSourceTypes?.length &&
+            !security.allowSourceTypes.includes(provider.type)) {
+            throw new Error(`Model provider "${provider.name}" denied: source type "${provider.type}" is not allowed.`);
+        }
+        if (security.allowIds?.length && !security.allowIds.includes(provider.name)) {
+            throw new Error(`Model provider "${provider.name}" denied: provider is not in extensions allowIds.`);
+        }
+        if (security.denyIds?.includes(provider.name)) {
+            throw new Error(`Model provider "${provider.name}" denied: provider is listed in extensions denyIds.`);
+        }
+        const runtimeEnable = this.config.extensions?.enable;
+        const allowEnable = this.config.extensions?.allowEnable;
+        if (allowEnable !== undefined && allowEnable.length > 0) {
+            if (!allowEnable.includes(provider.name)) {
+                throw new Error(`Model provider "${provider.name}" denied: not in system config allow-list (allowEnable).`);
+            }
+        }
+        if (runtimeEnable !== undefined && runtimeEnable.length > 0) {
+            if (!runtimeEnable.includes(provider.name)) {
+                throw new Error(`Model provider "${provider.name}" denied: provider is not enabled for this run (extensions.enable).`);
+            }
+        }
+        else {
+            const contextProviderIds = new Set(context.extensions?.providers?.map((p) => p.name) ?? []);
+            if (contextProviderIds.size > 0 && !contextProviderIds.has(provider.name)) {
+                throw new Error(`Model provider "${provider.name}" denied: provider is not declared in context.extensions.providers.`);
+            }
+        }
+    }
+    getEffectiveExtensionSecurity(context) {
+        const contextPolicy = context.extensions?.security;
+        const systemPolicy = this.config.extensions?.security;
+        const allowKinds = systemPolicy?.allowKinds ?? contextPolicy?.allowKinds;
+        const allowSourceTypes = systemPolicy?.allowSourceTypes ?? contextPolicy?.allowSourceTypes;
+        return {
+            ...contextPolicy,
+            ...systemPolicy,
+            allowKinds,
+            // Default: allow all builtin extensions when not specified
+            allowSourceTypes: allowSourceTypes !== undefined && allowSourceTypes.length > 0
+                ? allowSourceTypes
+                : ["builtin"],
+            allowIds: systemPolicy?.allowIds ?? contextPolicy?.allowIds,
+            denyIds: systemPolicy?.denyIds ?? contextPolicy?.denyIds,
+        };
+    }
+}
+//# sourceMappingURL=runner.js.map