actoviq-agent-sdk 0.4.6 → 0.4.7

package/dist/src/runtime-v2/agentRuntime.js

@@ -0,0 +1,1341 @@
+import { randomUUID } from 'node:crypto';
+import { RunError, UsageAccumulator, assertJsonValue, emptyUsage, } from '../core/index.js';
+import { EventDispatcher, RunEventSequencer, SensitiveDataRedactionProcessor, createRootTraceContext, } from '../events/index.js';
+import { AsyncQueue } from '../runtime/asyncQueue.js';
+import { SessionTurnCoordinator } from '../runtime/sessionTurnCoordinator.js';
+import { MiddlewarePipeline, MiddlewareRegistry, MiddlewareStage, buildMiddlewarePipeline, } from './middleware/index.js';
+import { RuntimeServices } from './services.js';
+import { ToolExecutionError, ToolInterruptionRequiredError, ToolRegistry, ToolRunner, toolEffect, } from './tools.js';
+/** Raised when ordinary middleware attempts to replace a reserved runtime boundary. */
+export class MiddlewareInvariantViolationError extends RunError {
+    stage;
+    constructor(stage, runId, message, cause) {
+        super(message, {
+            code: 'MIDDLEWARE_INVARIANT_VIOLATION',
+            runId,
+            phase: stage === MiddlewareStage.WrapToolCall
+                ? 'tool_call'
+                : stage === MiddlewareStage.BeforeHandoff
+                    ? 'handoff'
+                    : 'model_call',
+            cause,
+            details: { stage },
+        });
+        this.stage = stage;
+    }
+}
+const DEFAULT_LIMITS = Object.freeze({
+    maxTurns: 32,
+    runDeadlineMs: 15 * 60_000,
+    modelCallTimeoutMs: 120_000,
+    toolTimeoutMs: 120_000,
+    hookTimeoutMs: 30_000,
+    maxParallelTools: 10,
+    maxSubagentDepth: 1,
+    maxSubagentFanout: 8,
+    streamBufferSize: 256,
+    maxInputTokens: 1_000_000,
+    maxOutputTokens: 64_000,
+    maxTotalTokens: 1_000_000,
+    maxCostUsd: 100,
+});
+const DEFAULT_MAX_CONCURRENT_RUNS = 64;
+export class AgentRuntime {
+    models;
+    defaultModel;
+    tools;
+    toolRunner;
+    hasToolPolicy;
+    services;
+    middleware;
+    middlewareRegistry;
+    events;
+    checkpointStore;
+    defaultLimits;
+    runConcurrency;
+    agents = new Map();
+    activeRuns = new Map();
+    activeSettlements = new Map();
+    agentPipelines = new WeakMap();
+    sessionTurns = new SessionTurnCoordinator();
+    closed = false;
+    constructor(options) {
+        this.models = options.models;
+        this.runConcurrency = new RunConcurrencyGate(options.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS);
+        this.defaultModel = options.defaultModel;
+        this.tools = options.tools ?? new ToolRegistry();
+        this.toolRunner = new ToolRunner({ registry: this.tools, policy: options.toolPolicy });
+        this.hasToolPolicy = options.toolPolicy !== undefined;
+        this.services = options.services ?? new RuntimeServices();
+        this.middleware = options.middleware instanceof MiddlewarePipeline
+            ? options.middleware
+            : buildMiddlewarePipeline(options.middleware ?? []);
+        this.middlewareRegistry = options.middlewareRegistry ?? new MiddlewareRegistry();
+        this.events = new EventDispatcher({
+            processors: [new SensitiveDataRedactionProcessor(), ...(options.eventProcessors ?? [])],
+            sinks: options.eventSinks,
+            failureMode: options.eventFailureMode,
+        });
+        this.checkpointStore = options.checkpointStore;
+        this.defaultLimits = resolveLimits(DEFAULT_LIMITS, options.defaultLimits);
+        for (const agent of options.agents ?? [])
+            this.registerAgent(agent);
+    }
+    registerAgent(agent) {
+        assertAgentSpec(agent);
+        const current = this.agents.get(agent.id);
+        if (current && current !== agent)
+            throw new Error(`Agent "${agent.id}" is already registered.`);
+        this.agents.set(agent.id, agent);
+        return this;
+    }
+    async run(agent, input, options = {}) {
+        this.assertOpen();
+        const seed = this.createSeed(agent, input, options);
+        const controller = this.claimRun(seed.state.runId, options.signal);
+        let current = seed.state;
+        const execution = this.executeWithSessionLock(seed, controller.signal, {
+            emit: event => this.events.dispatch(event).then(() => undefined),
+            update: state => { current = state; },
+        });
+        this.trackSettlement(seed.state.runId, execution);
+        try {
+            return await execution;
+        }
+        finally {
+            this.releaseRun(seed.state.runId, controller);
+            void current;
+        }
+    }
+    stream(agent, input, options = {}) {
+        this.assertOpen();
+        const seed = this.createSeed(agent, input, options);
+        const limits = resolveLimits(this.defaultLimits, agent.limits);
+        const queue = createEventQueue(limits.streamBufferSize);
+        const controller = this.claimRun(seed.state.runId, options.signal);
+        let current = seed.state;
+        const result = Promise.resolve().then(() => this.executeWithSessionLock(seed, controller.signal, {
+            emit: async (event) => {
+                const processed = await this.events.dispatch(event);
+                if (processed)
+                    queue.push(processed);
+            },
+            update: state => { current = state; },
+            streamModel: true,
+        })).finally(() => {
+            queue.close();
+            this.releaseRun(seed.state.runId, controller);
+        });
+        void result.catch(() => undefined);
+        this.trackSettlement(seed.state.runId, result);
+        return new RuntimeRunHandle(seed.state.runId, result, queue, controller, () => cloneState(current));
+    }
+    resume(state, decisions = []) {
+        this.assertOpen();
+        validateSerializedState(state);
+        const agent = this.agents.get(state.agentId);
+        if (!agent) {
+            throw new RunError(`Cannot resume run ${state.runId}: agent "${state.agentId}" is not registered.`, {
+                code: 'AGENT_NOT_REGISTERED',
+                runId: state.runId,
+                phase: 'runtime',
+            });
+        }
+        if (state.agentConfigDigest !== agentDigest(agent)) {
+            throw new RunError(`Cannot resume run ${state.runId}: agent configuration changed.`, {
+                code: 'AGENT_CONFIG_MISMATCH',
+                runId: state.runId,
+                phase: 'runtime',
+            });
+        }
+        const input = cloneItems(state.input);
+        const options = {
+            runId: state.runId,
+            sessionId: state.sessionId,
+            tenantId: state.tenantId,
+            expectedSessionRevision: state.expectedSessionRevision,
+            workspaceId: state.workspaceId,
+            metadata: state.metadata,
+        };
+        const seed = {
+            agent: agent,
+            input,
+            options,
+            state: cloneState({ ...state, status: 'running' }),
+            decisions,
+        };
+        const limits = resolveLimits(this.defaultLimits, agent.limits);
+        const queue = createEventQueue(limits.streamBufferSize);
+        const controller = this.claimRun(state.runId);
+        let current = seed.state;
+        const result = Promise.resolve().then(() => this.executeWithSessionLock(seed, controller.signal, {
+            emit: async (event) => {
+                const processed = await this.events.dispatch(event);
+                if (processed)
+                    queue.push(processed);
+            },
+            update: next => { current = next; },
+            streamModel: true,
+        })).finally(() => {
+            queue.close();
+            this.releaseRun(state.runId, controller);
+        });
+        void result.catch(() => undefined);
+        this.trackSettlement(state.runId, result);
+        return new RuntimeRunHandle(state.runId, result, queue, controller, () => cloneState(current));
+    }
+    inspectMiddleware(agent) {
+        return (agent ? this.pipelineFor(agent) : this.middleware).format();
+    }
+    /**
+     * Run the explicit handoff lifecycle stage before orchestration transfers
+     * conversation ownership. This keeps orchestration host-driven while making
+     * the runtime middleware contract effective on the real handoff path.
+     */
+    async beforeHandoff(request) {
+        this.assertOpen();
+        if (!request.sourceAgentId.trim())
+            throw new TypeError('Handoff sourceAgentId must not be empty.');
+        if (!request.handoffId.trim())
+            throw new TypeError('Handoff id must not be empty.');
+        if (!request.parentRunId.trim())
+            throw new TypeError('Handoff parentRunId must not be empty.');
+        assertAgentSpec(request.targetAgent);
+        request.signal.throwIfAborted();
+        const sourceAgent = this.agents.get(request.sourceAgentId);
+        const pipeline = sourceAgent ? this.pipelineFor(sourceAgent) : this.middleware;
+        const deadline = request.deadline === undefined
+            ? undefined
+            : { expiresAt: request.deadline, scope: `handoff:${request.handoffId}` };
+        const context = {
+            runtime: this,
+            services: this.services,
+            sourceAgent,
+            targetAgent: request.targetAgent,
+            sourceAgentId: request.sourceAgentId,
+            parentRunId: request.parentRunId,
+            handoffId: request.handoffId,
+            input: cloneItems(request.input),
+            metadata: request.metadata,
+            signal: request.signal,
+            deadline,
+        };
+        const prepared = await pipeline.runWithErrorStage(MiddlewareStage.BeforeHandoff, context, stageContext => stageContext.input);
+        if (!Array.isArray(prepared)) {
+            throw new MiddlewareInvariantViolationError(MiddlewareStage.BeforeHandoff, request.parentRunId, 'beforeHandoff middleware must return canonical input items.');
+        }
+        return cloneItems(prepared);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const controller of this.activeRuns.values()) {
+            controller.abort(abortError('AgentRuntime closed.'));
+        }
+        await Promise.allSettled([...this.activeSettlements.values()]);
+        this.activeRuns.clear();
+        const results = await Promise.allSettled([this.events.close(), this.services.close()]);
+        const failures = results
+            .filter((result) => result.status === 'rejected')
+            .map(result => result.reason);
+        if (failures.length > 0)
+            throw new AggregateError(failures, 'AgentRuntime close failed.');
+    }
+    createSeed(agent, input, options) {
+        assertAgentSpec(agent);
+        this.registerAgent(agent);
+        const runId = options.runId ?? randomUUID();
+        const trace = options.parentTrace && options.parentRunId
+            ? childTrace(runId, options.parentRunId, options.parentTrace)
+            : createRootTraceContext(runId);
+        const startedAt = new Date().toISOString();
+        const limits = resolveLimits(this.defaultLimits, agent.limits);
+        const normalizedInput = normalizeInput(input);
+        return {
+            agent,
+            input: normalizedInput,
+            options,
+            state: {
+                schemaVersion: 1,
+                runId,
+                agentId: agent.id,
+                agentConfigDigest: agentDigest(agent),
+                status: 'running',
+                trace,
+                startedAt,
+                deadlineAt: new Date(Date.now() + limits.runDeadlineMs).toISOString(),
+                turn: 0,
+                input: cloneItems(normalizedInput),
+                transcript: cloneItems(normalizedInput),
+                generatedItems: [],
+                usage: emptyUsage(),
+                sessionId: options.sessionId,
+                tenantId: options.tenantId,
+                expectedSessionRevision: options.expectedSessionRevision,
+                workspaceId: options.workspaceId,
+                childRunIds: [],
+                metadata: options.metadata ?? {},
+            },
+        };
+    }
+    async execute(seed, parentSignal, observer) {
+        const { agent, options } = seed;
+        const pipeline = this.pipelineFor(agent);
+        const limits = resolveLimits(this.defaultLimits, agent.limits);
+        const persistedDeadline = seed.state.deadlineAt === undefined
+            ? undefined
+            : Date.parse(seed.state.deadlineAt);
+        if (persistedDeadline !== undefined && !Number.isFinite(persistedDeadline)) {
+            throw new RunError('Serialized run deadline is invalid.', {
+                code: 'RUN_DEADLINE_INVALID', runId: seed.state.runId, phase: 'runtime',
+            });
+        }
+        const runTimeoutMs = persistedDeadline === undefined
+            ? limits.runDeadlineMs
+            : Math.max(0, persistedDeadline - Date.now());
+        const boundary = createBoundary(parentSignal, runTimeoutMs, 'Run deadline exceeded.');
+        const signal = boundary.signal;
+        const usage = new UsageAccumulator(seed.state.usage);
+        let state = cloneState(seed.state);
+        let lastResponse;
+        const sequencer = new RunEventSequencer(state.trace);
+        const runContext = {
+            runId: state.runId,
+            agentId: agent.id,
+            context: options.context,
+            signal,
+            startedAt: state.startedAt,
+            deadlineAt: state.deadlineAt,
+            sessionId: state.sessionId,
+            metadata: state.metadata,
+            usage,
+        };
+        const deadline = {
+            expiresAt: Date.parse(state.deadlineAt ?? new Date(Date.now() + limits.runDeadlineMs).toISOString()),
+            scope: `run:${state.runId}`,
+        };
+        const emit = async (type, data) => {
+            await observer.emit(sequencer.next(type, data));
+        };
+        const update = async (patch = {}) => {
+            state = cloneState({ ...state, ...patch, usage: usage.snapshot() });
+            observer.update(state);
+            await this.checkpointStore?.save(state);
+        };
+        const middlewareContext = (extra = {}) => ({
+            runtime: this,
+            services: this.services,
+            agent: agent,
+            run: runContext,
+            state,
+            signal,
+            deadline,
+            ...extra,
+        });
+        await emit(seed.decisions ? 'run.resumed' : 'run.started', { agentId: agent.id });
+        try {
+            let preparedInput = await pipeline.runWithErrorStage(MiddlewareStage.PrepareInput, middlewareContext({ input: seed.input }), context => Promise.resolve(context.input ?? seed.input));
+            if (state.turn === 0 && state.sessionId) {
+                const sessionStore = await this.resolveSessionStore(state.runId);
+                const loaded = await sessionStore.load({
+                    tenantId: state.tenantId ?? 'default',
+                    sessionId: state.sessionId,
+                });
+                preparedInput = [...loaded.items, ...preparedInput];
+                await update({ expectedSessionRevision: loaded.revision });
+                await emit('session.loaded', {
+                    sessionId: state.sessionId,
+                    revision: loaded.revision,
+                    itemCount: loaded.items.length,
+                });
+            }
+            if (state.turn > 0 && state.sessionId) {
+                const sessionStore = await this.resolveSessionStore(state.runId);
+                const current = await sessionStore.load({
+                    tenantId: state.tenantId ?? 'default',
+                    sessionId: state.sessionId,
+                });
+                if (state.expectedSessionRevision !== current.revision) {
+                    throw new RunError(`Session "${state.sessionId}" changed while run "${state.runId}" was interrupted.`, {
+                        code: 'SESSION_REVISION_CONFLICT',
+                        runId: state.runId,
+                        phase: 'runtime',
+                        details: {
+                            expectedRevision: state.expectedSessionRevision ?? null,
+                            actualRevision: current.revision,
+                        },
+                    });
+                }
+            }
+            const instructions = await resolveInstructions(agent, runContext);
+            if (instructions) {
+                preparedInput = [
+                    { type: 'text', role: 'system', text: instructions },
+                    ...preparedInput,
+                ];
+            }
+            if (state.turn === 0 && state.generatedItems.length === 0) {
+                await runInputGuardrails(agent, runContext, preparedInput);
+                await update({ transcript: cloneItems(preparedInput) });
+                await pipeline.runWithErrorStage(MiddlewareStage.BeforeRun, middlewareContext({ input: preparedInput }), () => undefined);
+            }
+            const pendingBeforeResume = state.pendingTool;
+            const resumed = await this.resumePendingTool(seed.decisions ?? [], state, runContext, update, emit);
+            if (resumed)
+                state = resumed;
+            const approval = pendingBeforeResume?.interruptionId
+                ? seed.decisions?.find(item => item.interruptionId === pendingBeforeResume.interruptionId)
+                : undefined;
+            if (state.pendingTool?.status === 'prepared' && approval?.outcome === 'approve') {
+                await this.executeToolCall(state.pendingTool.call, state, runContext, limits, pipeline, middlewareContext, update, emit, approval);
+                await update({ pendingTool: undefined });
+            }
+            while (state.turn < limits.maxTurns) {
+                signal.throwIfAborted();
+                const model = agent.model ?? this.defaultModel;
+                if (!model) {
+                    throw new RunError(`Agent "${agent.id}" does not declare a model and no default model exists.`, {
+                        code: 'MODEL_REQUIRED', runId: state.runId, phase: 'model_call',
+                    });
+                }
+                const request = this.createModelRequest(agent, model, state.transcript, limits);
+                await emit('model.requested', { turn: state.turn + 1, model });
+                const modelBoundary = createBoundary(signal, limits.modelCallTimeoutMs, 'Model call deadline exceeded.');
+                let response;
+                let modelTerminalCompleted = false;
+                try {
+                    response = await pipeline.runWithErrorStage(MiddlewareStage.WrapModelCall, { ...middlewareContext({ modelRequest: request }), signal: modelBoundary.signal }, async () => {
+                        const value = await raceWithSignal(this.callModel(request, {
+                            runId: state.runId,
+                            traceId: state.trace.traceId,
+                            spanId: state.trace.spanId,
+                            signal: modelBoundary.signal,
+                            deadline: Math.min(deadline.expiresAt, Date.now() + limits.modelCallTimeoutMs),
+                        }, observer, emit), modelBoundary.signal);
+                        modelTerminalCompleted = true;
+                        return value;
+                    });
+                }
+                finally {
+                    modelBoundary.dispose();
+                }
+                if (!modelTerminalCompleted) {
+                    throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapModelCall, state.runId, 'wrapModelCall middleware cannot replace the provider/capability boundary; call next().');
+                }
+                response = validateModelResponse(response, state.runId);
+                usage.add(response.usage.requests > 0 ? response.usage : { ...response.usage, requests: 1 });
+                enforceUsageLimits(usage, limits, state.runId);
+                response = await pipeline.runWithErrorStage(MiddlewareStage.AfterModelResponse, middlewareContext({ modelRequest: request, modelResponse: response }), context => context.modelResponse);
+                response = validateModelResponse(response, state.runId);
+                lastResponse = response;
+                const nextGenerated = [...state.generatedItems, ...response.output];
+                const nextTranscript = [...state.transcript, ...response.output];
+                await update({
+                    turn: state.turn + 1,
+                    generatedItems: nextGenerated,
+                    transcript: nextTranscript,
+                });
+                await emit('model.completed', {
+                    turn: state.turn,
+                    finishReason: response.finishReason,
+                    usage: response.usage,
+                });
+                const toolCalls = response.output.filter((item) => item.type === 'tool_call');
+                if (toolCalls.length === 0)
+                    break;
+                for (let index = 0; index < toolCalls.length;) {
+                    const call = toolCalls[index];
+                    if (this.canParallelizeReadTool(call) && limits.maxParallelTools > 1) {
+                        const batch = [];
+                        while (index < toolCalls.length
+                            && batch.length < limits.maxParallelTools
+                            && this.canParallelizeReadTool(toolCalls[index])) {
+                            batch.push(toolCalls[index]);
+                            index += 1;
+                        }
+                        const results = await Promise.all(batch.map(item => this.executeReadToolCall(item, state, runContext, limits, pipeline, middlewareContext, emit)));
+                        await update({
+                            generatedItems: [...state.generatedItems, ...results],
+                            transcript: [...state.transcript, ...results],
+                        });
+                        continue;
+                    }
+                    await this.executeToolCall(call, state, runContext, limits, pipeline, middlewareContext, update, emit);
+                    await update({ pendingTool: undefined });
+                    index += 1;
+                }
+                await pipeline.runWithErrorStage(MiddlewareStage.AfterTurn, middlewareContext(), () => undefined);
+            }
+            if (!lastResponse && state.status !== 'running') {
+                return this.interruptedResult(agent, state);
+            }
+            if (!lastResponse) {
+                throw new RunError('Run has no model response.', {
+                    code: 'EMPTY_MODEL_RESPONSE', runId: state.runId, phase: 'finalize_output',
+                });
+            }
+            if (state.turn >= limits.maxTurns && lastResponse.output.some(item => item.type === 'tool_call')) {
+                throw new RunError(`Run exceeded maxTurns=${limits.maxTurns}.`, {
+                    code: 'MAX_TURNS_EXCEEDED', runId: state.runId, phase: 'runtime',
+                });
+            }
+            let output = await pipeline.runWithErrorStage(MiddlewareStage.FinalizeOutput, middlewareContext({ modelResponse: lastResponse }), () => finalizeOutput(agent, lastResponse));
+            await runOutputGuardrails(agent, runContext, output);
+            if (state.sessionId) {
+                const sessionStore = await this.resolveSessionStore(state.runId);
+                const committed = await sessionStore.append({
+                    tenantId: state.tenantId ?? 'default',
+                    sessionId: state.sessionId,
+                    items: [...state.input, ...state.generatedItems],
+                    expectedRevision: state.expectedSessionRevision ?? '0',
+                });
+                await update({ expectedSessionRevision: committed.revision });
+                await emit('session.committed', {
+                    sessionId: state.sessionId,
+                    revision: committed.revision,
+                });
+            }
+            const completedAt = new Date().toISOString();
+            let result = {
+                runId: state.runId,
+                agentId: agent.id,
+                status: 'completed',
+                output,
+                items: state.generatedItems,
+                usage: usage.snapshot(),
+                startedAt: state.startedAt,
+                completedAt,
+                sessionId: state.sessionId,
+                metadata: state.metadata,
+            };
+            result = await pipeline.runWithErrorStage(MiddlewareStage.AfterRun, middlewareContext({ result }), context => context.result);
+            await update({ status: 'completed' });
+            await emit('run.completed', { status: result.status, usage: result.usage });
+            await this.checkpointStore?.delete(state.runId);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof ToolInterruptionRequiredError) {
+                await update({ status: 'interrupted' });
+                await emit('run.interrupted', {
+                    interruptionId: error.decision.interruptionId,
+                    reason: error.decision.reason,
+                });
+                return this.interruptedResult(agent, state);
+            }
+            if (signal.aborted) {
+                await update({ status: 'cancelled' });
+                await emit('run.cancelled', { reason: errorMessage(signal.reason ?? error) });
+                return {
+                    ...this.interruptedResult(agent, state),
+                    status: 'cancelled',
+                };
+            }
+            await update({ status: 'failed' });
+            await emit('run.failed', { error: serializeError(error) });
+            throw error;
+        }
+        finally {
+            boundary.dispose();
+        }
+    }
+    createModelRequest(agent, model, input, limits) {
+        const tools = [];
+        for (const ref of agent.tools ?? []) {
+            const name = typeof ref === 'string' ? ref : ref.id;
+            const tool = this.tools.resolve(name);
+            if (!tool)
+                throw new RunError(`Agent "${agent.id}" references unknown tool "${name}".`, {
+                    code: 'TOOL_NOT_FOUND', phase: 'before_run',
+                });
+            tools.push({
+                name: tool.descriptor.name,
+                description: tool.descriptor.description,
+                inputSchema: (tool.descriptor.input.jsonSchema ?? {}),
+            });
+        }
+        return {
+            model,
+            input,
+            tools: tools.length > 0 ? tools : undefined,
+            toolPolicy: tools.length > 0 ? 'auto' : 'none',
+            outputSchema: agent.output
+                ? {
+                    name: agent.output.name,
+                    schema: agent.output.schema,
+                    description: agent.output.description,
+                    strict: agent.output.strict,
+                }
+                : undefined,
+            maxOutputTokens: Math.min(limits.maxOutputTokens, 64_000),
+        };
+    }
+    async callModel(request, context, observer, emit) {
+        if (!observer.streamModel)
+            return this.models.generate(request, context);
+        const stream = this.models.stream(request, context);
+        const onAbort = () => stream.cancel(context.signal?.reason);
+        context.signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            for await (const event of stream) {
+                await emitModelStreamEvent(event, emit);
+            }
+            return await stream.finalResponse();
+        }
+        finally {
+            context.signal?.removeEventListener('abort', onAbort);
+            if (context.signal?.aborted)
+                stream.cancel(context.signal.reason);
+        }
+    }
+    async executeToolCall(call, state, runContext, limits, pipeline, middlewareContext, update, emit, approval) {
+        const definition = this.tools.resolve(call.name);
+        const effect = definition ? toolEffect(definition.descriptor) : 'side-effect';
+        const pending = { call, effect, status: 'prepared' };
+        await update({ pendingTool: pending });
+        await pipeline.runWithErrorStage(MiddlewareStage.BeforeToolCall, middlewareContext({ toolCall: call }), () => undefined);
+        await update({ pendingTool: { ...pending, status: 'started' } });
+        await emit('tool.started', { callId: call.id, name: call.name, effect });
+        try {
+            let toolTerminalCompleted = false;
+            let toolTerminalOutput;
+            const output = await pipeline.runWithErrorStage(MiddlewareStage.WrapToolCall, middlewareContext({ toolCall: call }), async () => {
+                const value = await this.toolRunner.execute(call.name, call.input, {
+                    runId: state.runId,
+                    callId: call.id,
+                    signal: runContext.signal,
+                    deadline: Date.now() + limits.toolTimeoutMs,
+                    context: runContext.context,
+                    idempotencyKey: effect === 'idempotent-write' ? `${state.runId}:${call.id}` : undefined,
+                    approval: approval
+                        ? {
+                            interruptionId: approval.interruptionId,
+                            outcome: 'approve',
+                            metadata: approval.metadata,
+                        }
+                        : undefined,
+                    workspaceId: state.workspaceId,
+                    metadata: state.metadata,
+                });
+                toolTerminalOutput = freezeToolOutput(validateToolTerminalOutput(definition, value, call, state.runId));
+                toolTerminalCompleted = true;
+                return toolTerminalOutput;
+            });
+            if (!toolTerminalCompleted) {
+                throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapToolCall, state.runId, 'wrapToolCall middleware cannot replace ToolRunner policy/schema validation; call next().');
+            }
+            if (output !== toolTerminalOutput) {
+                throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapToolCall, state.runId, 'wrapToolCall middleware must return the validated ToolRunner output unchanged.');
+            }
+            const validatedOutput = output;
+            const normalizedOutput = toJsonValue(validatedOutput.value, call.name);
+            const result = {
+                type: 'tool_result',
+                callId: call.id,
+                name: call.name,
+                status: 'success',
+                output: normalizedOutput,
+            };
+            await pipeline.runWithErrorStage(MiddlewareStage.AfterToolCall, middlewareContext({ toolCall: call, toolOutput: validatedOutput }), () => undefined);
+            await update({
+                pendingTool: { ...pending, status: 'committed', result },
+                generatedItems: [...state.generatedItems, result],
+                transcript: [...state.transcript, result],
+            });
+            await emit('tool.completed', {
+                callId: call.id,
+                name: call.name,
+                artifacts: validatedOutput.artifacts,
+            });
+        }
+        catch (error) {
+            if (error instanceof ToolInterruptionRequiredError) {
+                await update({
+                    pendingTool: {
+                        ...pending,
+                        status: 'awaiting_approval',
+                        interruptionId: error.decision.interruptionId,
+                    },
+                });
+                throw error;
+            }
+            if (!(error instanceof ToolExecutionError))
+                throw error;
+            const result = {
+                type: 'tool_result',
+                callId: call.id,
+                name: call.name,
+                status: 'error',
+                output: {
+                    kind: error.failure.kind,
+                    message: this.toolRunner.formatFailure(error),
+                    retryable: error.failure.retryable,
+                },
+            };
+            await update({
+                pendingTool: { ...pending, status: 'committed', result },
+                generatedItems: [...state.generatedItems, result],
+                transcript: [...state.transcript, result],
+            });
+            await emit('tool.failed', { callId: call.id, name: call.name, failure: error.failure });
+        }
+    }
+    canParallelizeReadTool(call) {
+        if (this.hasToolPolicy)
+            return false;
+        const tool = this.tools.resolve(call.name);
+        return tool !== undefined
+            && toolEffect(tool.descriptor) === 'read'
+            && tool.descriptor.behavior?.requiresApproval !== true;
+    }
+    async executeReadToolCall(call, state, runContext, limits, pipeline, middlewareContext, emit) {
+        const definition = this.tools.resolve(call.name);
+        await pipeline.runWithErrorStage(MiddlewareStage.BeforeToolCall, middlewareContext({ toolCall: call }), () => undefined);
+        await emit('tool.started', { callId: call.id, name: call.name, effect: 'read' });
+        try {
+            let toolTerminalCompleted = false;
+            let toolTerminalOutput;
+            const output = await pipeline.runWithErrorStage(MiddlewareStage.WrapToolCall, middlewareContext({ toolCall: call }), async () => {
+                const value = await this.toolRunner.execute(call.name, call.input, {
+                    runId: state.runId,
+                    callId: call.id,
+                    signal: runContext.signal,
+                    deadline: Date.now() + limits.toolTimeoutMs,
+                    context: runContext.context,
+                    workspaceId: state.workspaceId,
+                    metadata: state.metadata,
+                });
+                toolTerminalOutput = freezeToolOutput(validateToolTerminalOutput(definition, value, call, state.runId));
+                toolTerminalCompleted = true;
+                return toolTerminalOutput;
+            });
+            if (!toolTerminalCompleted) {
+                throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapToolCall, state.runId, 'wrapToolCall middleware cannot replace ToolRunner schema validation; call next().');
+            }
+            if (output !== toolTerminalOutput) {
+                throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapToolCall, state.runId, 'wrapToolCall middleware must return the validated ToolRunner output unchanged.');
+            }
+            const validatedOutput = output;
+            await pipeline.runWithErrorStage(MiddlewareStage.AfterToolCall, middlewareContext({ toolCall: call, toolOutput: validatedOutput }), () => undefined);
+            const result = {
+                type: 'tool_result',
+                callId: call.id,
+                name: call.name,
+                status: 'success',
+                output: toJsonValue(validatedOutput.value, call.name),
+            };
+            await emit('tool.completed', {
+                callId: call.id,
+                name: call.name,
+                artifacts: validatedOutput.artifacts,
+            });
+            return result;
+        }
+        catch (error) {
+            if (!(error instanceof ToolExecutionError))
+                throw error;
+            const result = toolFailureResult(call, error, this.toolRunner.formatFailure(error));
+            await emit('tool.failed', { callId: call.id, name: call.name, failure: error.failure });
+            return result;
+        }
+    }
+    async resumePendingTool(decisions, state, runContext, update, emit) {
+        const pending = state.pendingTool;
+        if (!pending)
+            return undefined;
+        if (pending.status === 'committed' && pending.result) {
+            const alreadyPresent = state.transcript.some(item => item.type === 'tool_result' && item.callId === pending.call.id);
+            if (!alreadyPresent) {
+                const next = cloneState({
+                    ...state,
+                    transcript: [...state.transcript, pending.result],
+                    generatedItems: [...state.generatedItems, pending.result],
+                    pendingTool: undefined,
+                });
+                await update(next);
+                return next;
+            }
+            await update({ pendingTool: undefined });
+            return cloneState({ ...state, pendingTool: undefined });
+        }
+        if (pending.status === 'started' && pending.effect === 'side-effect') {
+            throw new ToolInterruptionRequiredError({
+                type: 'interrupt',
+                interruptionId: pending.interruptionId ?? `${state.runId}:${pending.call.id}:reconcile`,
+                reason: `Side-effect tool "${pending.call.name}" may have started; manual reconciliation is required.`,
+            }, pending.call.name, pending.call.id);
+        }
+        if (pending.status !== 'awaiting_approval' || !pending.interruptionId)
+            return undefined;
+        const decision = decisions.find(item => item.interruptionId === pending.interruptionId);
+        if (!decision) {
+            throw new ToolInterruptionRequiredError({
+                type: 'interrupt',
+                interruptionId: pending.interruptionId,
+                reason: `Tool "${pending.call.name}" still requires a decision.`,
+            }, pending.call.name, pending.call.id);
+        }
+        if (decision.outcome === 'reject') {
+            const result = {
+                type: 'tool_result', callId: pending.call.id, name: pending.call.name, status: 'error',
+                output: { kind: 'denied', message: decision.reason ?? 'Approval rejected.', retryable: false },
+            };
+            const next = cloneState({
+                ...state,
+                pendingTool: undefined,
+                transcript: [...state.transcript, result],
+                generatedItems: [...state.generatedItems, result],
+            });
+            await update(next);
+            await emit('tool.rejected', { callId: pending.call.id, name: pending.call.name });
+            return next;
+        }
+        await update({ pendingTool: { ...pending, status: 'prepared' } });
+        void runContext;
+        return cloneState({ ...state, pendingTool: { ...pending, status: 'prepared' } });
+    }
+    interruptedResult(agent, state) {
+        return {
+            runId: state.runId,
+            agentId: agent.id,
+            status: state.status === 'cancelled' ? 'cancelled' : 'interrupted',
+            output: '',
+            items: state.generatedItems,
+            usage: state.usage,
+            startedAt: state.startedAt,
+            completedAt: new Date().toISOString(),
+            sessionId: state.sessionId,
+            metadata: state.metadata,
+        };
+    }
+    claimRun(runId, externalSignal) {
+        if (this.activeRuns.has(runId))
+            throw new Error(`Run "${runId}" is already active.`);
+        const controller = new AbortController();
+        if (externalSignal?.aborted)
+            controller.abort(externalSignal.reason);
+        else
+            externalSignal?.addEventListener('abort', () => controller.abort(externalSignal.reason), { once: true });
+        this.activeRuns.set(runId, controller);
+        return controller;
+    }
+    releaseRun(runId, controller) {
+        if (this.activeRuns.get(runId) === controller)
+            this.activeRuns.delete(runId);
+    }
+    trackSettlement(runId, operation) {
+        const settlement = operation.then(() => undefined, () => undefined);
+        this.activeSettlements.set(runId, settlement);
+        void settlement.then(() => {
+            if (this.activeSettlements.get(runId) === settlement) {
+                this.activeSettlements.delete(runId);
+            }
+        });
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('AgentRuntime is closed.');
+    }
+    executeWithSessionLock(seed, signal, observer) {
+        const execute = () => this.runConcurrency.run(() => this.execute(seed, signal, observer), signal);
+        if (!seed.state.sessionId)
+            return execute();
+        const key = `${seed.state.tenantId ?? 'default'}\u0000${seed.state.sessionId}`;
+        // Serialize a session before taking a global run permit. Otherwise many
+        // turns for one busy session could occupy every permit while waiting for
+        // the same session lock and starve unrelated sessions.
+        return this.sessionTurns.runExclusive(key, execute);
+    }
+    pipelineFor(agent) {
+        if (!agent.middleware || agent.middleware.length === 0)
+            return this.middleware;
+        const cached = this.agentPipelines.get(agent);
+        if (cached)
+            return cached;
+        const pipeline = buildMiddlewarePipeline([
+            ...this.middleware.definitions(),
+            ...this.middlewareRegistry.resolve(agent.middleware),
+        ]);
+        this.agentPipelines.set(agent, pipeline);
+        return pipeline;
+    }
+    async resolveSessionStore(runId) {
+        if (!this.services.has('sessions')) {
+            throw new RunError('A sessionId was provided but no sessions service is registered.', {
+                code: 'SESSION_SERVICE_REQUIRED', runId, phase: 'runtime',
+            });
+        }
+        return this.services.resolve('sessions');
+    }
+}
+class RuntimeRunHandle {
+    runId;
+    result;
+    queue;
+    controller;
+    snapshotState;
+    constructor(runId, result, queue, controller, snapshotState) {
+        this.runId = runId;
+        this.result = result;
+        this.queue = queue;
+        this.controller = controller;
+        this.snapshotState = snapshotState;
+    }
+    cancel(reason) {
+        if (!this.controller.signal.aborted)
+            this.controller.abort(abortError(reason ?? 'Run cancelled.'));
+    }
+    snapshot() {
+        return Promise.resolve(this.snapshotState());
+    }
+    [Symbol.asyncIterator]() {
+        const iterator = this.queue[Symbol.asyncIterator]();
+        return {
+            next: () => iterator.next(),
+            return: async () => {
+                try {
+                    await iterator.return?.();
+                }
+                finally {
+                    this.cancel('Run event consumer stopped.');
+                }
+                return { done: true, value: undefined };
+            },
+            throw: async (error) => {
+                try {
+                    await iterator.throw?.(error);
+                }
+                finally {
+                    this.cancel('Run event consumer failed.');
+                }
+                throw error;
+            },
+        };
+    }
+}
+function createEventQueue(capacity) {
+    return new AsyncQueue({
+        capacity,
+        overflowStrategy: 'drop-oldest',
+        priorityReserve: 1,
+        isPriority: event => event.type.startsWith('run.') && event.type !== 'run.started',
+        coalesce: coalesceRunEventDelta,
+    });
+}
+function coalesceRunEventDelta(previous, incoming) {
+    if (previous.runId !== incoming.runId || previous.type !== incoming.type)
+        return undefined;
+    if (incoming.type !== 'model.text.delta' && incoming.type !== 'model.reasoning.delta')
+        return undefined;
+    const previousData = asRecord(previous.data);
+    const incomingData = asRecord(incoming.data);
+    const left = typeof previousData?.delta === 'string' ? previousData.delta : '';
+    const right = typeof incomingData?.delta === 'string' ? incomingData.delta : '';
+    if (!left || !right)
+        return undefined;
+    return { ...incoming, data: { ...incomingData, delta: left + right } };
+}
+async function emitModelStreamEvent(event, emit) {
+    switch (event.type) {
+        case 'text.delta':
+            await emit('model.text.delta', {
+                delta: event.delta,
+                outputIndex: event.outputIndex,
+            });
+            return;
+        case 'tool_call.delta':
+            await emit('model.tool_call.delta', {
+                callId: event.callId,
+                name: event.name,
+                argumentsDelta: event.argumentsDelta,
+                outputIndex: event.outputIndex,
+            });
+            return;
+        case 'reasoning.delta':
+            await emit('model.reasoning.delta', {
+                delta: event.delta,
+                opaque: event.opaque,
+                outputIndex: event.outputIndex,
+            });
+            return;
+        case 'usage':
+            await emit('model.usage', { usage: event.usage });
+            return;
+        case 'provider.event':
+            await emit('model.provider.event', {
+                provider: event.provider,
+                event: event.event,
+            });
+            return;
+        case 'response.completed':
+            await emit('model.response.completed', {
+                responseId: event.response.id,
+                finishReason: event.response.finishReason,
+            });
+            return;
+    }
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function normalizeInput(input) {
+    if (typeof input === 'string')
+        return [{ type: 'text', role: 'user', text: input }];
+    return cloneItems(Array.isArray(input) ? input : [input]);
+}
+function cloneItems(items) {
+    return structuredClone(items);
+}
+function cloneState(state) {
+    return structuredClone(state);
+}
+function resolveLimits(base, patch) {
+    const limits = { ...base, ...patch };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isFinite(value) || value <= 0) {
+            throw new RangeError(`Run limit ${name} must be a positive finite number.`);
+        }
+    }
+    for (const name of ['maxTurns', 'maxParallelTools', 'maxSubagentDepth', 'maxSubagentFanout', 'streamBufferSize']) {
+        if (!Number.isSafeInteger(limits[name]))
+            throw new RangeError(`Run limit ${name} must be a safe integer.`);
+    }
+    if (limits.streamBufferSize < 2)
+        throw new RangeError('streamBufferSize must be at least 2.');
+    return Object.freeze(limits);
+}
+function assertAgentSpec(agent) {
+    if (!agent.id.trim())
+        throw new TypeError('Agent id must not be empty.');
+    if (!agent.name.trim())
+        throw new TypeError('Agent name must not be empty.');
+    if (typeof agent.instructions !== 'string' && typeof agent.instructions !== 'function') {
+        throw new TypeError(`Agent "${agent.id}" instructions must be a string or function.`);
+    }
+}
+async function resolveInstructions(agent, context) {
+    const instructions = typeof agent.instructions === 'function'
+        ? await agent.instructions(context)
+        : agent.instructions;
+    if (typeof instructions !== 'string')
+        throw new TypeError('Agent instructions must resolve to a string.');
+    return instructions;
+}
+async function runInputGuardrails(agent, context, input) {
+    for (const guardrail of agent.inputGuardrails ?? []) {
+        const decision = await guardrail.evaluate(context, input);
+        if (!decision.allowed)
+            throw new RunError(decision.reason ?? `Input guardrail ${guardrail.id} rejected input.`, {
+                code: 'INPUT_GUARDRAIL_REJECTED', runId: context.runId, phase: 'prepare_input',
+            });
+    }
+}
+async function runOutputGuardrails(agent, context, output) {
+    for (const guardrail of agent.outputGuardrails ?? []) {
+        const decision = await guardrail.evaluate(context, output);
+        if (!decision.allowed)
+            throw new RunError(decision.reason ?? `Output guardrail ${guardrail.id} rejected output.`, {
+                code: 'OUTPUT_GUARDRAIL_REJECTED', runId: context.runId, phase: 'finalize_output',
+            });
+    }
+}
+function finalizeOutput(agent, response) {
+    if (agent.output) {
+        if (response.structuredOutput === undefined)
+            throw new RunError(`Model did not return structured output for schema "${agent.output.name}".`, { code: 'STRUCTURED_OUTPUT_MISSING', phase: 'finalize_output' });
+        return agent.output.parse
+            ? agent.output.parse(response.structuredOutput)
+            : response.structuredOutput;
+    }
+    return response.output
+        .filter(item => item.type === 'text' && item.role === 'assistant')
+        .map(item => item.type === 'text' ? item.text : '')
+        .join('');
+}
+function enforceUsageLimits(usage, limits, runId) {
+    const value = usage.snapshot();
+    if (value.totalTokens > limits.maxTotalTokens || value.costUsd > limits.maxCostUsd) {
+        throw new RunError('Run usage budget exceeded.', {
+            code: 'USAGE_LIMIT_EXCEEDED', runId, phase: 'model_call',
+            details: { totalTokens: value.totalTokens, costUsd: value.costUsd },
+        });
+    }
+}
+const MODEL_FINISH_REASONS = new Set([
+    'stop',
+    'length',
+    'tool_calls',
+    'content_filter',
+    'refusal',
+    'cancelled',
+    'error',
+    'unknown',
+]);
+const OUTPUT_ITEM_TYPES = new Set([
+    'text',
+    'image',
+    'audio',
+    'document',
+    'artifact_ref',
+    'tool_call',
+    'tool_result',
+    'handoff_call',
+    'handoff_result',
+    'reasoning',
+    'raw',
+    'structured',
+    'refusal',
+    'error',
+]);
+function validateModelResponse(response, runId) {
+    try {
+        if (!response || typeof response !== 'object')
+            throw new TypeError('response must be an object');
+        if (typeof response.id !== 'string' || response.id.trim().length === 0) {
+            throw new TypeError('response.id must be a non-empty string');
+        }
+        if (!response.model
+            || typeof response.model.providerId !== 'string'
+            || response.model.providerId.trim().length === 0
+            || typeof response.model.modelId !== 'string'
+            || response.model.modelId.trim().length === 0) {
+            throw new TypeError('response.model must identify a provider and model');
+        }
+        if (!MODEL_FINISH_REASONS.has(response.finishReason)) {
+            throw new TypeError(`response.finishReason is invalid: ${String(response.finishReason)}`);
+        }
+        if (!Array.isArray(response.output))
+            throw new TypeError('response.output must be an array');
+        assertJsonValue(response.output, 'Model response output');
+        for (const item of response.output) {
+            if (!item || typeof item !== 'object' || !OUTPUT_ITEM_TYPES.has(item.type)) {
+                throw new TypeError(`response.output contains an unknown item type: ${String(item?.type)}`);
+            }
+        }
+        if (response.structuredOutput !== undefined) {
+            assertJsonValue(response.structuredOutput, 'Model structured output');
+        }
+        if (response.rawResponse !== undefined) {
+            assertJsonValue(response.rawResponse, 'Raw model response');
+        }
+        const validatedUsage = new UsageAccumulator(response.usage).snapshot();
+        return { ...response, usage: validatedUsage };
+    }
+    catch (cause) {
+        throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapModelCall, runId, 'Model middleware returned a response that violates the canonical response contract.', cause);
+    }
+}
+function validateToolTerminalOutput(definition, output, call, runId) {
+    try {
+        if (!definition)
+            throw new TypeError(`Unknown tool "${call.name}".`);
+        if (!output || typeof output !== 'object' || !Object.hasOwn(output, 'value')) {
+            throw new TypeError('tool middleware must return a ToolOutput object');
+        }
+        const candidate = output;
+        assertJsonValue(candidate.value, `Output from tool "${call.name}"`);
+        if (candidate.modelText !== undefined && typeof candidate.modelText !== 'string') {
+            throw new TypeError('ToolOutput.modelText must be a string');
+        }
+        if (candidate.artifacts !== undefined) {
+            if (!Array.isArray(candidate.artifacts))
+                throw new TypeError('ToolOutput.artifacts must be an array');
+            for (const artifact of candidate.artifacts) {
+                if (!artifact || typeof artifact.id !== 'string' || artifact.id.trim().length === 0) {
+                    throw new TypeError('Every tool artifact must have a non-empty id');
+                }
+            }
+        }
+        return candidate;
+    }
+    catch (cause) {
+        throw new MiddlewareInvariantViolationError(MiddlewareStage.WrapToolCall, runId, `Tool middleware returned invalid output for "${call.name}".`, cause);
+    }
+}
+function freezeToolOutput(output) {
+    deepFreezeJson(output.value);
+    if (output.artifacts) {
+        for (const artifact of output.artifacts)
+            Object.freeze(artifact);
+        Object.freeze(output.artifacts);
+    }
+    return Object.freeze(output);
+}
+function deepFreezeJson(value) {
+    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
+        return;
+    for (const child of Array.isArray(value) ? value : Object.values(value)) {
+        deepFreezeJson(child);
+    }
+    Object.freeze(value);
+}
+function toJsonValue(value, toolName) {
+    assertJsonValue(value, `Output from tool "${toolName}"`);
+    return value;
+}
+function toolFailureResult(call, error, formatted) {
+    return {
+        type: 'tool_result',
+        callId: call.id,
+        name: call.name,
+        status: 'error',
+        output: {
+            kind: error.failure.kind,
+            message: formatted,
+            retryable: error.failure.retryable,
+        },
+    };
+}
+/** Fair, abort-aware gate for top-level runtime work. */
+class RunConcurrencyGate {
+    capacity;
+    waiters = [];
+    active = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        if (!Number.isSafeInteger(capacity) || capacity < 1) {
+            throw new RangeError('maxConcurrentRuns must be a positive safe integer.');
+        }
+    }
+    async run(operation, signal) {
+        try {
+            await this.acquire(signal);
+        }
+        catch (error) {
+            // Runtime cancellation is a normal terminal result, not a rejected
+            // top-level run. Let the state machine emit/return that result without
+            // consuming a permit when cancellation happens in the wait queue.
+            if (signal.aborted)
+                return operation();
+            throw error;
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            this.release();
+        }
+    }
+    acquire(signal) {
+        if (signal.aborted) {
+            return Promise.reject(signal.reason ?? abortError('Run cancelled before execution.'));
+        }
+        if (this.active < this.capacity) {
+            this.active += 1;
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            let waiter;
+            const onAbort = () => {
+                const index = this.waiters.indexOf(waiter);
+                if (index >= 0)
+                    this.waiters.splice(index, 1);
+                reject(signal.reason ?? abortError('Run cancelled while waiting for execution.'));
+            };
+            waiter = { signal, resolve, reject, onAbort };
+            this.waiters.push(waiter);
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        });
+    }
+    release() {
+        this.active -= 1;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter.signal.removeEventListener('abort', waiter.onAbort);
+            if (waiter.signal.aborted) {
+                waiter.reject(waiter.signal.reason ?? abortError('Run cancelled while waiting for execution.'));
+                continue;
+            }
+            this.active += 1;
+            waiter.resolve();
+            return;
+        }
+    }
+}
+function createBoundary(parent, timeoutMs, message) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(parent.reason);
+    parent.addEventListener('abort', onAbort, { once: true });
+    if (parent.aborted)
+        onAbort();
+    let timer;
+    if (!controller.signal.aborted && timeoutMs <= 0) {
+        controller.abort(abortError(message));
+    }
+    else if (!controller.signal.aborted) {
+        timer = setTimeout(() => controller.abort(abortError(message)), timeoutMs);
+        timer.unref?.();
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (timer)
+                clearTimeout(timer);
+            parent.removeEventListener('abort', onAbort);
+        },
+    };
+}
+function raceWithSignal(operation, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason ?? abortError('Operation aborted.'));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason ?? abortError('Operation aborted.'));
+        signal.addEventListener('abort', onAbort, { once: true });
+        operation.then(value => { signal.removeEventListener('abort', onAbort); resolve(value); }, error => { signal.removeEventListener('abort', onAbort); reject(error); });
+    });
+}
+function abortError(message) {
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function serializeError(error) {
+    return error instanceof Error
+        ? { name: error.name, message: error.message }
+        : { name: 'Error', message: String(error) };
+}
+function validateSerializedState(state) {
+    if (state.schemaVersion !== 1)
+        throw new TypeError(`Unsupported run state version ${state.schemaVersion}.`);
+    if (!state.runId || !state.agentId)
+        throw new TypeError('Serialized run state is missing identity.');
+}
+function agentDigest(agent) {
+    const value = JSON.stringify({
+        id: agent.id,
+        name: agent.name,
+        description: agent.description,
+        instructions: typeof agent.instructions === 'string' ? agent.instructions : '[function]',
+        model: agent.model,
+        tools: agent.tools,
+        handoffs: agent.handoffs?.map(handoff => ({ id: handoff.id, targetAgentId: handoff.targetAgentId })),
+        output: agent.output ? { name: agent.output.name, schema: agent.output.schema, strict: agent.output.strict } : undefined,
+        limits: agent.limits,
+        metadata: agent.metadata,
+    });
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+function childTrace(runId, parentRunId, parent) {
+    const trace = createRootTraceContext(runId);
+    return {
+        runId,
+        parentRunId,
+        traceId: parent.traceId,
+        spanId: trace.spanId,
+        parentSpanId: parent.spanId,
+    };
+}
+//# sourceMappingURL=agentRuntime.js.map