@lensagent/core 0.1.0

package/dist/runtime/agent.js

@@ -0,0 +1,853 @@
+import { jsonValue } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+import { claimsConflict } from './capabilities.js';
+import { decidePolicy, policyPrompt } from './policy.js';
+import { planCache } from './cache.js';
+import { resolveReasoningEffort } from './profile.js';
+import { estimateTokens } from './tokenizer.js';
+import { derivePreparationDiagnostics } from './diagnostics.js';
+export class AgentRuntime {
+    store;
+    config;
+    context;
+    gateway;
+    registry;
+    calls;
+    reviewer;
+    events;
+    #controllers = new Map();
+    #running = new Map();
+    constructor(store, config, context, gateway, registry, calls, reviewer, events) {
+        this.store = store;
+        this.config = config;
+        this.context = context;
+        this.gateway = gateway;
+        this.registry = registry;
+        this.calls = calls;
+        this.reviewer = reviewer;
+        this.events = events;
+    }
+    wake(projectId, agentId) {
+        const key = `${projectId}:${agentId}`;
+        if (this.#running.has(key))
+            return;
+        const controller = new AbortController();
+        this.#controllers.set(key, controller);
+        const running = this.#runAvailable(projectId, agentId, controller.signal)
+            .catch((error) => {
+            if (!controller.signal.aborted)
+                this.#terminateCurrent(projectId, agentId, error);
+        })
+            .finally(() => {
+            this.#running.delete(key);
+            this.#controllers.delete(key);
+        });
+        this.#running.set(key, running);
+    }
+    cancel(projectId, agentId) {
+        for (const callId of this.store.activeCallIds(projectId, agentId)) {
+            const call = this.store.getCall(projectId, callId);
+            if (call.state !== 'TERMINAL')
+                this.calls.cancel(projectId, callId);
+        }
+        this.store.cancelAgent(projectId, agentId);
+        this.#controllers.get(`${projectId}:${agentId}`)?.abort(new Error('Agent cancelled.'));
+    }
+    async close() {
+        for (const controller of this.#controllers.values())
+            controller.abort(new Error('Agent runtime closed.'));
+        await Promise.allSettled(this.#running.values());
+    }
+    async compact(projectId, agentId, expectedContextRevision, pivotTurnGroupId, signal) {
+        const agent = this.store.getAgent(projectId, agentId);
+        if (agent.state !== 'IDLE')
+            fail('AGENT_BUSY', 409, 'The Agent must be idle before manual Compaction.');
+        const snapshot = this.config.current;
+        const selected = this.gateway.resolve(string(agent.model), snapshot.config);
+        const prepared = this.context.prepare(projectId, agentId, snapshot.config, selected.contextWindowTokens, selected.profile);
+        if (prepared.sourceRevision !== expectedContextRevision)
+            fail('REVISION_CONFLICT', 409, 'The Context changed before Compaction.');
+        const preserveFrom = pivotTurnGroupId === undefined ? undefined : preserveAfterGroup(prepared.source.items, pivotTurnGroupId);
+        return this.#compact(projectId, agentId, null, prepared, snapshot, signal, preserveFrom);
+    }
+    async createSubagent(projectId, input, signal) {
+        const parent = this.store.getAgent(projectId, input.parentAgentId);
+        const snapshot = this.config.current;
+        const role = snapshot.config.roles.subagent;
+        const model = input.model ?? role.model;
+        const modelReasoningEffort = input.modelReasoningEffort ?? role.modelReasoningEffort;
+        if (model === null || modelReasoningEffort === null || role.policyPreset === null)
+            fail('CONFIG_INVALID', 503, 'The subagent role is incomplete.');
+        const selected = this.gateway.resolve(model, snapshot.config);
+        resolveReasoningEffort(selected.profile, modelReasoningEffort);
+        const policies = snapshot.config.policyPresets[role.policyPreset]?.capabilities;
+        if (policies === undefined)
+            fail('POLICY_PRESET_MISSING', 409, 'The Subagent Policy preset does not exist.');
+        const capabilityIds = [...new Set([
+                ...this.registry.list().filter((definition) => definition.defaultAssignment === 'all_new_agents').map((definition) => definition.id),
+                ...role.capabilities
+            ])];
+        let compactSummary;
+        if (input.forkContext === 'compact') {
+            const parentModel = this.gateway.resolve(string(parent.model), snapshot.config);
+            const prepared = this.context.prepare(projectId, input.parentAgentId, snapshot.config, parentModel.contextWindowTokens, parentModel.profile);
+            compactSummary = await this.#summarize(projectId, input.parentAgentId, null, prepared, snapshot, signal);
+        }
+        const created = this.store.createSubagent(projectId, input.parentAgentId, {
+            name: input.name,
+            model,
+            modelReasoningEffort,
+            policyPreset: role.policyPreset,
+            capabilities: Object.fromEntries(capabilityIds.map((capabilityId) => {
+                const definition = this.registry.get(capabilityId);
+                return [capabilityId, policies[capabilityId] ?? (definition.effect === 'read_only' ? 'read_only' : 'ask')];
+            })),
+            loadedCapabilities: capabilityIds.filter((capabilityId) => this.registry.get(capabilityId).loadMode === 'eager'),
+            forkContext: input.forkContext,
+            ...(compactSummary === undefined ? {} : { compactSummary }),
+            ...(input.initialPrompt === undefined ? {} : { initialPrompt: input.initialPrompt }),
+            ...(input.initialMessage === undefined ? {} : { initialMessage: input.initialMessage }),
+            ...(input.ingress === undefined ? {} : { ingress: input.ingress })
+        });
+        const agent = created.agent;
+        if (jsonObject(agent) && typeof agent.id === 'string' && created.run !== null)
+            this.wake(projectId, agent.id);
+        return created;
+    }
+    async #runAvailable(projectId, agentId, signal) {
+        for (;;) {
+            const claimed = this.store.claimRun(projectId, agentId);
+            if (claimed === null)
+                return;
+            const pendingIds = claimed.pending.map((entry) => string(entry.id));
+            let stepId = string(claimed.step.id);
+            let pendingConsumed = false;
+            try {
+                for (let stepCount = 0; stepCount < 64; stepCount += 1) {
+                    signal.throwIfAborted();
+                    const agent = this.store.getAgent(projectId, agentId);
+                    const configSnapshot = this.config.current;
+                    const modelReference = string(agent.model);
+                    const resolved = this.gateway.resolve(modelReference, configSnapshot.config);
+                    let prepared = this.context.prepare(projectId, agentId, configSnapshot.config, resolved.contextWindowTokens, resolved.profile);
+                    if (prepared.estimate.safe > inputLimit(configSnapshot, resolved.contextWindowTokens)) {
+                        await this.#compact(projectId, agentId, stepId, prepared, configSnapshot, signal);
+                        prepared = this.context.prepare(projectId, agentId, configSnapshot.config, resolved.contextWindowTokens, resolved.profile);
+                        if (prepared.estimate.safe > inputLimit(configSnapshot, resolved.contextWindowTokens))
+                            fail('CONTEXT_TOO_LARGE', 413, 'Context remains over the model input limit after Compaction.');
+                    }
+                    if (!pendingConsumed) {
+                        for (const pendingId of pendingIds)
+                            this.store.consumePending(projectId, pendingId);
+                        pendingConsumed = true;
+                    }
+                    const sample = await this.#sample(projectId, agent, stepId, prepared, configSnapshot, signal);
+                    if (sample.text.length > 0)
+                        this.store.appendAssistantMessage(projectId, agentId, stepId, sample.text);
+                    if (sample.tools.length === 0) {
+                        this.store.finishStep(projectId, stepId, 'success');
+                        break;
+                    }
+                    this.store.appendToolCalls(projectId, agentId, stepId, sample.tools.map((entry) => ({
+                        id: entry.providerId,
+                        name: entry.name,
+                        arguments: entry.contextArguments ?? entry.arguments
+                    })));
+                    const callIds = await this.#materializeCalls(projectId, agent, stepId, sample, signal);
+                    await this.#executePartitions(projectId, callIds, signal);
+                    this.store.yieldResults(projectId, agentId, callIds);
+                    stepId = string(this.store.continueRun(projectId, stepId).id);
+                }
+                const run = this.store.getRun(projectId, string(claimed.run.id));
+                if (run.state === 'RUNNING' || run.state === 'WAITING')
+                    this.store.finishStep(projectId, stepId, 'failed', 'STEP_LIMIT_EXCEEDED');
+            }
+            catch (error) {
+                if (code(error) === 'COMPACTION_FAILED' && pendingConsumed) {
+                    for (const pending of [...claimed.pending].reverse())
+                        this.store.restorePending(projectId, pending);
+                }
+                const step = this.store.getStep(projectId, stepId);
+                if (step.state !== 'TERMINAL') {
+                    this.store.finishStep(projectId, stepId, signal.aborted ? 'cancelled' : 'failed', code(error), reason(error));
+                }
+                if (signal.aborted)
+                    return;
+            }
+        }
+    }
+    async #sample(projectId, agent, stepId, prepared, configSnapshot, signal, reactiveCompacted = false) {
+        const role = agent.parent_agent_id === null ? configSnapshot.config.roles.agent : configSnapshot.config.roles.subagent;
+        const primary = string(agent.model);
+        const candidates = [
+            ...Array.from({ length: role.providerRouting.retryMaxAttempts }, () => primary),
+            ...role.providerRouting.fallback
+        ];
+        const manifestTools = this.#modelTools(projectId, string(agent.id));
+        const cacheConfig = configSnapshot.config.providerPromptCache;
+        let lastError;
+        for (const model of candidates) {
+            signal.throwIfAborted();
+            const resolved = this.gateway.resolve(model, configSnapshot.config);
+            const ptcProfile = resolved.profile.value.ptc;
+            const ptcEnabled = resolved.programmaticToolCallingSupported
+                && ptcProfile?.enabledByDefault === true
+                && manifestTools.some((entry) => entry.id === 'programmatic_tool_run');
+            const tools = ptcEnabled ? manifestTools : manifestTools.filter((entry) => entry.id !== 'programmatic_tool_run');
+            const reasoningEffort = resolveReasoningEffort(resolved.profile, string(agent.model_reasoning_effort));
+            const maximumOutputTokens = configSnapshot.config.contextBudget?.outputReserveTokens ?? 4096;
+            const requestFrame = {
+                tools: tools,
+                reasoning_effort: reasoningEffort,
+                max_output_tokens: maximumOutputTokens,
+                provider_visible_options: {
+                    profile_id: resolved.profile.id,
+                    profile_version: resolved.profile.value.version
+                },
+                ...(ptcEnabled ? {
+                    programmatic_tool_calling: {
+                        capability_ids: tools.map((entry) => entry.id).filter((entry) => entry !== 'programmatic_tool_run' && entry !== 'capability_search'),
+                        max_tool_calls: ptcProfile.maxToolCalls,
+                        schema_version: ptcProfile.schemaVersion,
+                        instruction: ptcProfile.instruction
+                    }
+                } : {})
+            };
+            const candidateContext = this.context.prepareSource(prepared.source, configSnapshot.config, resolved.contextWindowTokens, resolved.profile, requestFrame);
+            if (candidateContext.estimate.safe > inputLimit(configSnapshot, resolved.contextWindowTokens)) {
+                lastError = new Error(`Context exceeds the input limit for ${model}.`);
+                if (!reactiveCompacted) {
+                    await this.#compact(projectId, string(agent.id), stepId, candidateContext, configSnapshot, signal);
+                    const nextModel = this.gateway.resolve(string(agent.model), configSnapshot.config);
+                    const next = this.context.prepare(projectId, string(agent.id), configSnapshot.config, nextModel.contextWindowTokens, nextModel.profile);
+                    return this.#sample(projectId, agent, stepId, next, configSnapshot, signal, true);
+                }
+                continue;
+            }
+            const messages = ptcEnabled
+                ? [...candidateContext.messages, { role: 'system', content: ptcProfile.instruction }]
+                : candidateContext.messages;
+            const cache = planCache(messages, tools, resolved.cacheSupported && (cacheConfig?.enabled ?? resolved.profile.value.cache.enabledByDefault), cacheConfig?.minimumEligiblePrefixTokens ?? resolved.profile.value.cache.minimumEligiblePrefixTokens, cacheConfig?.maximumBreakpoints ?? resolved.profile.value.cache.maximumBreakpoints, resolved.profile.value.cache.segmentStability);
+            const requestBase = {
+                model,
+                messages,
+                tools,
+                reasoningEffort,
+                maxOutputTokens: maximumOutputTokens,
+                signal
+            };
+            const ptc = ptcEnabled ? {
+                capabilityIds: tools.map((entry) => entry.id).filter((entry) => entry !== 'programmatic_tool_run' && entry !== 'capability_search'),
+                maxToolCalls: ptcProfile.maxToolCalls,
+                schemaVersion: ptcProfile.schemaVersion,
+                instruction: ptcProfile.instruction
+            } : null;
+            const attempt = this.store.createAttempt(projectId, {
+                agentId: string(agent.id),
+                stepId,
+                kind: 'agent',
+                model,
+                profileId: resolved.profile.id,
+                profileDigest: resolved.profile.digest,
+                profileVersion: resolved.profile.value.version,
+                configDigest: configSnapshot.digest,
+                contextRevision: candidateContext.sourceRevision,
+                request: frozenRequest(requestBase, ptc),
+                preparation: {
+                    context_digest: candidateContext.digest,
+                    token_estimate: candidateContext.estimate,
+                    projection_decisions: candidateContext.decisions,
+                    cache_plan: cache,
+                    ...derivePreparationDiagnostics(candidateContext.source, configSnapshot.config)
+                },
+                capabilities: tools.map((entry) => ({ id: entry.id, schema: entry.inputSchema }))
+            });
+            const attemptId = string(attempt.id);
+            for (const decision of candidateContext.decisions) {
+                this.store.appendProjectionDecision(projectId, string(agent.id), attemptId, decision.stage, decision.sourceTokens, decision.projectedTokens, { context_digest: candidateContext.digest });
+            }
+            const step = this.store.getStep(projectId, stepId);
+            const runId = string(step.run_id);
+            let streamSequence = 0;
+            const stream = (deltaType, detail) => {
+                this.events.emit(projectId, this.store.stateRevision(), 'stream.delta', {
+                    project_id: projectId,
+                    task_id: string(agent.task_id),
+                    session_id: string(agent.session_id),
+                    agent_id: string(agent.id),
+                    run_id: runId,
+                    step_id: stepId,
+                    attempt_id: attemptId,
+                    stream_sequence: ++streamSequence,
+                    delta_type: deltaType,
+                    ...detail
+                });
+            };
+            const ptcState = ptc === null ? null : {
+                attemptId,
+                stepId,
+                agent,
+                capabilityIds: ptc.capabilityIds,
+                maxToolCalls: ptc.maxToolCalls,
+                providerCalls: new Map(),
+                rootCallIds: new Set(),
+                nextOrdinal: 0,
+                nestedCount: 0
+            };
+            const request = ptcState === null ? requestBase : {
+                ...requestBase,
+                programmaticToolCalling: {
+                    capabilityIds: ptcState.capabilityIds,
+                    maxToolCalls: ptcState.maxToolCalls,
+                    execute: (input, executionSignal) => this.#executePtcNested(projectId, ptcState, input, executionSignal ?? signal)
+                }
+            };
+            this.store.transitionAttempt(projectId, attemptId, 'PREPARED', 'RUNNING');
+            let text = '';
+            const toolBlocks = [];
+            let usage = null;
+            let contentStarted = false;
+            try {
+                for await (const event of this.gateway.stream(request, configSnapshot.config)) {
+                    if (event.type === 'text') {
+                        contentStarted = true;
+                        text += event.text;
+                        stream('text', { text: event.text });
+                    }
+                    else if (event.type === 'thinking') {
+                        contentStarted = true;
+                        stream('thinking', { text: event.text });
+                    }
+                    else if (event.type === 'toolStart') {
+                        contentStarted = true;
+                        this.store.recordToolOrdinal(projectId, attemptId, event.ordinal, event.id, false);
+                        if (ptcState !== null)
+                            ptcState.nextOrdinal = Math.max(ptcState.nextOrdinal, event.ordinal + 1);
+                        stream('tool', { provider_call_id: event.id, capability_id: event.name, phase: 'start', call_ordinal: event.ordinal });
+                    }
+                    else if (event.type === 'tool') {
+                        contentStarted = true;
+                        this.store.recordToolOrdinal(projectId, attemptId, event.ordinal, event.id, true);
+                        if (ptcState !== null)
+                            ptcState.nextOrdinal = Math.max(ptcState.nextOrdinal, event.ordinal + 1);
+                        stream('tool', { provider_call_id: event.id, capability_id: event.name, phase: 'complete', call_ordinal: event.ordinal });
+                        if (event.programmaticCaller === true)
+                            continue;
+                        if (ptcState !== null && event.name === 'programmatic_tool_run' && event.providerExecuted === true) {
+                            const argumentsValue = ptcArguments(event.arguments, ptcState.capabilityIds);
+                            const callId = this.#createPtcRoot(projectId, ptcState, event.ordinal, event.id, argumentsValue);
+                            toolBlocks.push({
+                                ordinal: event.ordinal,
+                                providerId: event.id,
+                                name: event.name,
+                                arguments: argumentsValue,
+                                contextArguments: event.arguments,
+                                callId
+                            });
+                        }
+                        else {
+                            toolBlocks.push({ ordinal: event.ordinal, providerId: event.id, name: event.name, arguments: event.arguments });
+                        }
+                    }
+                    else if (event.type === 'toolResult' && ptcState !== null) {
+                        contentStarted = true;
+                        this.#completePtcRoot(projectId, ptcState, event.id, event.output);
+                    }
+                    else if (event.type === 'usage') {
+                        usage = { input_tokens: event.inputTokens, output_tokens: event.outputTokens };
+                    }
+                }
+                if (ptcState !== null)
+                    this.#failOpenPtcRoots(projectId, ptcState);
+                this.store.transitionAttempt(projectId, attemptId, 'RUNNING', 'TERMINAL', 'success', usage);
+                return { attemptId, text, tools: toolBlocks.sort((left, right) => left.ordinal - right.ordinal) };
+            }
+            catch (error) {
+                lastError = error;
+                if (ptcState !== null)
+                    this.#failOpenPtcRoots(projectId, ptcState);
+                this.store.transitionAttempt(projectId, attemptId, 'RUNNING', 'TERMINAL', signal.aborted ? 'cancelled' : 'failed', usage, code(error));
+                if (contentStarted || signal.aborted)
+                    throw error;
+                if (!reactiveCompacted && contextLimit(error)) {
+                    await this.#compact(projectId, string(agent.id), stepId, candidateContext, configSnapshot, signal);
+                    const nextModel = this.gateway.resolve(string(agent.model), configSnapshot.config);
+                    const next = this.context.prepare(projectId, string(agent.id), configSnapshot.config, nextModel.contextWindowTokens, nextModel.profile);
+                    return this.#sample(projectId, agent, stepId, next, configSnapshot, signal, true);
+                }
+            }
+        }
+        throw asError(lastError ?? new Error('All model routes failed.'));
+    }
+    #modelTools(projectId, agentId) {
+        return this.store.listCapabilities(projectId, agentId)
+            .filter((entry) => entry.loaded === true)
+            .flatMap((entry) => {
+            const definition = this.registry.find(string(entry.capability_id));
+            if (definition === undefined)
+                return [];
+            return definition.kind === 'skill' ? null : {
+                id: definition.id,
+                description: definition.description,
+                inputSchema: jsonValue(definition.inputSchema),
+                ...(definition.outputSchema === undefined ? {} : { outputSchema: jsonValue(definition.outputSchema) })
+            };
+        })
+            .filter((entry) => entry !== null);
+    }
+    async #materializeCalls(projectId, agent, stepId, sample, signal) {
+        const callIds = [];
+        let partitionId = null;
+        let partitionClaims = [];
+        const workspaceId = string(agent.workspace_id);
+        const workspacePaths = strings(this.store.getWorkspace(projectId, workspaceId).paths);
+        for (const block of sample.tools) {
+            if (block.callId !== undefined) {
+                callIds.push(block.callId);
+                partitionId = null;
+                partitionClaims = [];
+                continue;
+            }
+            let assignment;
+            let claims;
+            let effect;
+            try {
+                assignment = this.store.getCapabilityAssignment(projectId, string(agent.id), block.name);
+                if (assignment.loaded !== true)
+                    fail('CAPABILITY_NOT_LOADED', 403, `Capability ${block.name} is not loaded.`);
+                effect = this.registry.effect(block.name, block.arguments);
+                claims = this.registry.claims(block.name, { projectId, workspaceId, workspacePaths, arguments: block.arguments });
+            }
+            catch (error) {
+                const validationPartition = this.store.createPartition(projectId, stepId, 'serial');
+                const call = this.store.createCall(projectId, {
+                    workspaceId,
+                    agentId: string(agent.id),
+                    stepId,
+                    attemptId: sample.attemptId,
+                    partitionId: string(validationPartition.id),
+                    source: 'llm',
+                    capabilityId: block.name,
+                    providerCallId: block.providerId,
+                    callOrdinal: block.ordinal,
+                    arguments: block.arguments,
+                    effect: 'full',
+                    state: 'QUEUED'
+                });
+                const callId = string(call.id);
+                this.store.startCall(projectId, callId);
+                const errorCode = code(error);
+                this.store.completeCall(projectId, callId, 'failed', { error_code: errorCode }, errorCode, asError(error).message);
+                callIds.push(callId);
+                partitionId = null;
+                partitionClaims = [];
+                continue;
+            }
+            const conflict = partitionClaims.some((existing) => claimsConflict([existing], claims));
+            if (partitionId === null || conflict) {
+                const partition = this.store.createPartition(projectId, stepId, conflict ? 'serial' : 'parallel');
+                partitionId = string(partition.id);
+                partitionClaims = [];
+            }
+            partitionClaims.push(...claims);
+            const policy = policyValue(assignment.policy);
+            const decision = decidePolicy(policy, effect);
+            let call = this.store.createCall(projectId, {
+                workspaceId,
+                agentId: string(agent.id),
+                stepId,
+                attemptId: sample.attemptId,
+                partitionId,
+                source: 'llm',
+                capabilityId: block.name,
+                providerCallId: block.providerId,
+                callOrdinal: block.ordinal,
+                arguments: decision.state === 'WAITING' && !decision.autoReview
+                    ? { arguments: block.arguments, prompt: policyPrompt(block.name) }
+                    : block.arguments,
+                effect,
+                policy,
+                state: decision.state,
+                ...(decision.waitReason === undefined ? {} : { waitReason: decision.waitReason })
+            });
+            const callId = string(call.id);
+            callIds.push(callId);
+            if (decision.state === 'WAITING' && !decision.autoReview) {
+                this.events.emit(projectId, this.store.stateRevision(), 'attention.required', { code: 'CALL_WAITING_USER', entity_type: 'call', entity_id: callId, agent_id: agent.id ?? null });
+            }
+            if (decision.autoReview) {
+                const runId = string(this.store.getStep(projectId, stepId).run_id);
+                const goal = string(this.store.getRunGoal(projectId, runId).content);
+                const approved = await this.reviewer.review(goal, call, signal).catch(() => false);
+                call = this.store.reviewCall(projectId, callId, approved);
+                if (!approved)
+                    this.events.emit(projectId, this.store.stateRevision(), 'attention.required', { code: 'CALL_REVIEW_REQUIRED', entity_type: 'call', entity_id: callId, agent_id: agent.id ?? null });
+            }
+            if (conflict) {
+                partitionId = null;
+                partitionClaims = [];
+            }
+        }
+        return callIds;
+    }
+    async #executePartitions(projectId, callIds, signal) {
+        const partitions = [];
+        let currentId = null;
+        for (const callId of callIds) {
+            const call = this.store.getCall(projectId, callId);
+            const partitionId = string(call.partition_id);
+            if (partitionId !== currentId) {
+                partitions.push([]);
+                currentId = partitionId;
+            }
+            partitions[partitions.length - 1]?.push(callId);
+        }
+        for (const partition of partitions) {
+            for (const callId of partition) {
+                if (this.store.getCall(projectId, callId).state === 'QUEUED')
+                    this.calls.dispatch(projectId, callId, signal);
+            }
+            await this.calls.waitAll(projectId, partition, signal);
+        }
+    }
+    #createPtcRoot(projectId, state, ordinal, providerCallId, argumentsValue) {
+        const definition = this.registry.get('programmatic_tool_run');
+        const assignment = this.store.getCapabilityAssignment(projectId, string(state.agent.id), definition.id);
+        if (assignment.loaded !== true)
+            fail('CAPABILITY_NOT_LOADED', 403, 'Programmatic Tool Calling is not loaded for this Agent.');
+        const ptcWorkspaceId = string(state.agent.workspace_id);
+        this.registry.claims(definition.id, { projectId, workspaceId: ptcWorkspaceId, workspacePaths: strings(this.store.getWorkspace(projectId, ptcWorkspaceId).paths), arguments: argumentsValue });
+        const policy = policyValue(assignment.policy);
+        const decision = decidePolicy(policy, definition.effect);
+        const partition = this.store.createPartition(projectId, state.stepId, 'serial');
+        const call = this.store.createCall(projectId, {
+            workspaceId: string(state.agent.workspace_id),
+            agentId: string(state.agent.id),
+            stepId: state.stepId,
+            attemptId: state.attemptId,
+            partitionId: string(partition.id),
+            source: 'llm',
+            capabilityId: definition.id,
+            providerCallId,
+            callOrdinal: ordinal,
+            arguments: argumentsValue,
+            effect: definition.effect,
+            policy,
+            state: 'QUEUED'
+        });
+        const callId = string(call.id);
+        state.providerCalls.set(providerCallId, callId);
+        state.rootCallIds.add(callId);
+        this.store.startCall(projectId, callId);
+        if (decision.state !== 'QUEUED') {
+            this.store.completeCall(projectId, callId, 'failed', { error_code: 'POLICY_REQUIRES_DIRECT_CALL' }, 'POLICY_REQUIRES_DIRECT_CALL', 'The hosted program requires a Direct Call.');
+        }
+        return callId;
+    }
+    async #executePtcNested(projectId, state, input, signal) {
+        if (signal.aborted)
+            return { error_code: 'CALL_CANCELLED' };
+        if (input.parentProviderCallId === undefined)
+            return { error_code: 'POLICY_REQUIRES_DIRECT_CALL' };
+        if (input.capabilityId === 'programmatic_tool_run' || input.capabilityId === 'capability_search' || !state.capabilityIds.includes(input.capabilityId)) {
+            return { error_code: 'CAPABILITY_NOT_LOADED' };
+        }
+        const parentCallId = state.providerCalls.get(input.parentProviderCallId);
+        if (parentCallId === undefined || !state.rootCallIds.has(parentCallId) || this.store.getCall(projectId, parentCallId).state !== 'RUNNING') {
+            return { error_code: 'CALL_STATE_CONFLICT' };
+        }
+        const existing = state.providerCalls.get(input.providerCallId);
+        if (existing !== undefined)
+            return this.#ptcResult(projectId, existing, signal);
+        if (state.nestedCount >= state.maxToolCalls)
+            return { error_code: 'CALL_ARGUMENTS_INVALID', reason: 'PTC tool call limit exceeded.' };
+        state.nestedCount += 1;
+        const ordinal = Math.max(state.nextOrdinal, input.ordinal);
+        state.nextOrdinal = ordinal + 1;
+        const partition = this.store.createPartition(projectId, state.stepId, 'serial');
+        let definition = null;
+        let errorCode = null;
+        let effect = 'full';
+        let policy;
+        try {
+            definition = this.registry.get(input.capabilityId);
+            const assignment = this.store.getCapabilityAssignment(projectId, string(state.agent.id), input.capabilityId);
+            policy = policyValue(assignment.policy);
+            if (assignment.loaded !== true)
+                fail('CAPABILITY_NOT_LOADED', 403, `Capability ${input.capabilityId} is not loaded.`);
+            const hostedWorkspaceId = string(state.agent.workspace_id);
+            this.registry.claims(input.capabilityId, { projectId, workspaceId: hostedWorkspaceId, workspacePaths: strings(this.store.getWorkspace(projectId, hostedWorkspaceId).paths), arguments: input.arguments });
+            effect = this.registry.effect(input.capabilityId, input.arguments);
+            if (decidePolicy(policy, effect).state !== 'QUEUED')
+                errorCode = 'POLICY_REQUIRES_DIRECT_CALL';
+        }
+        catch (error) {
+            errorCode = code(error);
+        }
+        const call = this.store.createCall(projectId, {
+            workspaceId: string(state.agent.workspace_id),
+            agentId: string(state.agent.id),
+            stepId: state.stepId,
+            attemptId: state.attemptId,
+            partitionId: string(partition.id),
+            parentCallId,
+            source: 'program',
+            capabilityId: input.capabilityId,
+            providerCallId: input.providerCallId,
+            callOrdinal: ordinal,
+            arguments: input.arguments,
+            effect,
+            ...(policy === undefined ? {} : { policy }),
+            state: 'QUEUED'
+        });
+        const callId = string(call.id);
+        state.providerCalls.set(input.providerCallId, callId);
+        if (definition === null || errorCode !== null) {
+            this.store.startCall(projectId, callId);
+            this.store.completeCall(projectId, callId, 'failed', { error_code: errorCode ?? 'CAPABILITY_NOT_FOUND' }, errorCode ?? 'CAPABILITY_NOT_FOUND');
+        }
+        else {
+            this.calls.dispatch(projectId, callId, signal);
+        }
+        return this.#ptcResult(projectId, callId, signal);
+    }
+    async #ptcResult(projectId, callId, signal) {
+        await this.calls.waitAll(projectId, [callId], signal);
+        const call = this.store.getCall(projectId, callId);
+        const result = call.result;
+        if (!jsonObject(result))
+            return { error_code: 'RESULT_NOT_FOUND' };
+        return {
+            outcome: result.outcome ?? 'failed',
+            content: result.content ?? {},
+            error_code: result.error_code ?? null,
+            error_message: result.error_message ?? null
+        };
+    }
+    #completePtcRoot(projectId, state, providerCallId, output) {
+        const callId = state.providerCalls.get(providerCallId);
+        if (callId === undefined || !state.rootCallIds.has(callId))
+            return;
+        const call = this.store.getCall(projectId, callId);
+        if (call.state !== 'RUNNING')
+            return;
+        const failed = jsonObject(output) && output.status === 'incomplete';
+        this.store.completeCall(projectId, callId, failed ? 'failed' : 'success', output, failed ? 'MODEL_STREAM_FAILED' : null);
+    }
+    #failOpenPtcRoots(projectId, state) {
+        for (const callId of state.rootCallIds) {
+            let call = this.store.getCall(projectId, callId);
+            if (call.state === 'QUEUED')
+                call = this.store.startCall(projectId, callId);
+            if (call.state === 'RUNNING') {
+                this.store.completeCall(projectId, callId, 'failed', { error_code: 'MODEL_STREAM_FAILED' }, 'MODEL_STREAM_FAILED', 'The Provider ended the hosted program without a result.');
+            }
+        }
+    }
+    async #compact(projectId, agentId, stepId, prepared, configSnapshot, signal, preserveFromOverride) {
+        const summary = await this.#summarize(projectId, agentId, stepId, prepared, configSnapshot, signal);
+        const compaction = configSnapshot.config.compaction;
+        const preserveFrom = preserveFromOverride ?? preservedOrdinal(prepared.source.items, compaction?.preservedSegmentTokens ?? 16000, compaction?.preservedSegmentBytes ?? 262144);
+        return this.store.compactContext(projectId, agentId, summary, preserveFrom);
+    }
+    async #summarize(projectId, agentId, stepId, prepared, configSnapshot, signal) {
+        const role = configSnapshot.config.roles.compactor;
+        if (role.model === null)
+            fail('CONFIG_INVALID', 503, 'The compactor role requires a model.');
+        const primary = role.model;
+        const candidates = [
+            ...Array.from({ length: role.providerRouting.retryMaxAttempts }, () => primary),
+            ...role.providerRouting.fallback
+        ];
+        const source = prepared.messages.map((entry) => `${entry.role}: ${entry.content}`).join('\n\n');
+        const compaction = configSnapshot.config.compaction;
+        let lastError;
+        for (const model of candidates) {
+            signal.throwIfAborted();
+            const resolved = this.gateway.resolve(model, configSnapshot.config);
+            const request = {
+                model,
+                reasoningEffort: resolveReasoningEffort(resolved.profile, role.modelReasoningEffort),
+                maxOutputTokens: compaction?.summaryMaxTokens ?? 8192,
+                tools: [],
+                signal,
+                messages: [
+                    { role: 'system', content: resolved.profile.value.systemPrompt.content },
+                    { role: 'system', content: 'Summarize the durable facts, decisions, constraints, unfinished work, and tool outcomes. Return only the summary.' },
+                    { role: 'user', content: bounded(source, compaction?.preservedSegmentBytes ?? 262144) }
+                ]
+            };
+            const attempt = this.store.createAttempt(projectId, {
+                agentId,
+                stepId,
+                kind: 'compaction',
+                model,
+                profileId: resolved.profile.id,
+                profileDigest: resolved.profile.digest,
+                profileVersion: resolved.profile.value.version,
+                configDigest: configSnapshot.digest,
+                contextRevision: prepared.sourceRevision,
+                request: frozenRequest(request),
+                preparation: {
+                    context_digest: prepared.digest,
+                    token_estimate: prepared.estimate,
+                    projection_decisions: prepared.decisions,
+                    cache_plan: { status: 'unsupported', hints_applied: false }
+                },
+                capabilities: []
+            });
+            const attemptId = string(attempt.id);
+            this.store.transitionAttempt(projectId, attemptId, 'PREPARED', 'RUNNING');
+            let summary = '';
+            try {
+                for await (const event of this.gateway.stream(request, configSnapshot.config))
+                    if (event.type === 'text')
+                        summary += event.text;
+                if (summary.length === 0)
+                    throw new Error('The Compactor returned an empty summary.');
+                this.store.transitionAttempt(projectId, attemptId, 'RUNNING', 'TERMINAL', 'success');
+                return summary;
+            }
+            catch (error) {
+                lastError = error;
+                const current = this.store.getAttempt(projectId, attemptId);
+                if (current.state === 'RUNNING')
+                    this.store.transitionAttempt(projectId, attemptId, 'RUNNING', 'TERMINAL', signal.aborted ? 'cancelled' : 'failed', null, 'COMPACTION_FAILED');
+                if (signal.aborted)
+                    throw error;
+            }
+        }
+        fail('COMPACTION_FAILED', 503, 'All Compactor routes failed.', { reason: lastError instanceof Error ? lastError.message : String(lastError) });
+    }
+    #terminateCurrent(projectId, agentId, error) {
+        const runs = this.store.listRuns(projectId, agentId, { limit: 1 }).items;
+        const run = runs[0];
+        if (run === undefined || run.state === 'TERMINAL')
+            return;
+        const steps = this.store.listSteps(projectId, string(run.id), { limit: 1 }).items;
+        const step = steps[0];
+        if (step !== undefined && step.state !== 'TERMINAL')
+            this.store.finishStep(projectId, string(step.id), 'failed', code(error));
+    }
+}
+function preserveAfterGroup(items, turnGroupId) {
+    const group = items.filter((item) => item.turn_group_id === turnGroupId);
+    if (group.length === 0 || group.some((item) => item.locked === true))
+        fail('CONTEXT_GROUP_INVALID', 409, 'The Compaction pivot must be an unlocked TurnGroup.');
+    return Math.max(...group.map((item) => number(item.ordinal))) + 1;
+}
+function inputLimit(config, contextWindow) {
+    return contextWindow - (config.config.contextBudget?.outputReserveTokens ?? 4096) - (config.config.contextBudget?.safetyMarginTokens ?? 1024);
+}
+function frozenRequest(request, ptc = null) {
+    return {
+        model: request.model,
+        messages: request.messages,
+        tools: request.tools,
+        reasoning_effort: request.reasoningEffort,
+        max_output_tokens: request.maxOutputTokens ?? null,
+        programmatic_tool_calling: ptc === null ? null : {
+            enabled: true,
+            capability_ids: ptc.capabilityIds,
+            max_tool_calls: ptc.maxToolCalls,
+            schema_version: ptc.schemaVersion,
+            instruction: ptc.instruction
+        }
+    };
+}
+function preservedOrdinal(items, tokenLimit, byteLimit) {
+    let tokens = 0;
+    let bytes = 0;
+    let preserveFrom = items.length;
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const item = items[index];
+        if (item === undefined)
+            continue;
+        const content = string(item.content);
+        const nextTokens = tokens + estimateTokens(content).safe;
+        const nextBytes = bytes + Buffer.byteLength(content);
+        if (nextTokens > tokenLimit || nextBytes > byteLimit)
+            break;
+        tokens = nextTokens;
+        bytes = nextBytes;
+        preserveFrom = number(item.ordinal);
+    }
+    return preserveFrom;
+}
+function policyValue(value) {
+    if (value === 'read_only' || value === 'workspace_write' || value === 'external' || value === 'ask' || value === 'auto_approve' || value === 'full_access')
+        return value;
+    fail('DATABASE_CORRUPT', 503, 'Capability policy is invalid.');
+}
+function ptcArguments(value, capabilityIds) {
+    if (!jsonObject(value) || typeof value.code !== 'string' || typeof value.fingerprint !== 'string') {
+        fail('ADAPTER_PROTOCOL_ERROR', 503, 'The Provider returned an invalid Programmatic Tool Call.');
+    }
+    return { program: value.code, capabilityIds: [...capabilityIds] };
+}
+function string(value) {
+    if (typeof value !== 'string')
+        fail('DATABASE_CORRUPT', 503, 'A runtime field is invalid.');
+    return value;
+}
+function number(value) {
+    if (typeof value !== 'number')
+        fail('DATABASE_CORRUPT', 503, 'A numeric runtime field is invalid.');
+    return value;
+}
+function strings(value) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+        fail('DATABASE_CORRUPT', 503, 'Workspace paths are invalid.');
+    return value;
+}
+function bounded(value, maximum) {
+    const bytes = Buffer.from(value);
+    return bytes.byteLength <= maximum ? value : bytes.subarray(0, maximum).toString();
+}
+/**
+ * The documented error code for a failure. `RUNTIME_FAILED` is the catch-all and is not in 07's taxonomy;
+ * it was answering for a missing API key, an untrusted TLS chain, the wrong auth header, an unsupported
+ * reasoning effort and a Provider-rejected Tool block alike, so the one thing the reader could see said
+ * nothing about any of them.
+ *
+ * An AI SDK error carries its kind on `name` rather than `code`, which is why it fell through to the
+ * catch-all. A rejected request is `MODEL_STREAM_FAILED` (07: Provider stream failed, 502).
+ */
+function code(error) {
+    if (typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string')
+        return error.code;
+    if (isProviderError(error))
+        return 'MODEL_STREAM_FAILED';
+    return 'RUNTIME_FAILED';
+}
+function isProviderError(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const name = 'name' in error && typeof error.name === 'string' ? error.name : '';
+    return name.startsWith('AI_');
+}
+/**
+ * What the failure said, for `RunDetail.error.message`. The Provider's own text is the part that makes a
+ * failure actionable -- "The format of the value at messages.27.content.0.toolUse.input is invalid" names
+ * the fault, where `RUNTIME_FAILED` named nothing.
+ *
+ * Bounded, and never the whole error object: an AI SDK error can carry the entire request body, which
+ * includes the Context and could include an API key from the request headers.
+ */
+function reason(error) {
+    const message = error instanceof Error ? error.message : typeof error === 'string' ? error : null;
+    if (message === null)
+        return null;
+    const trimmed = message.trim();
+    return trimmed.length === 0 ? null : trimmed.slice(0, 500);
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function contextLimit(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /context.{0,20}(?:length|limit|window)|too many tokens|input.{0,20}too long/i.test(message);
+}
+function jsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}