@purista/harness 1.0.0

package/dist/sessions/index.js

@@ -0,0 +1,718 @@
+import { z } from 'zod';
+import { InternalError, OperationCancelledError, OperationTimeoutError, HarnessError, SessionBusyError, StateError, ValidationError, WorkflowNotFoundError, serializeError } from '../errors/index.js';
+import { ulid } from '../ulid/index.js';
+import { runDefaultAgent } from '../agents/index.js';
+import { runWorkflow } from '../workflows/index.js';
+import { loadSkillsSync } from '../skills/index.js';
+import { createModelRegistry } from '../models/registry.js';
+import { createTelemetryShim } from '../telemetry/index.js';
+import { createMcpRunnerRegistry } from '../tools/mcp/runner.js';
+const MEMORY_KEY_PATTERN = /^[A-Za-z0-9_.\-:]{1,256}$/;
+function now() {
+    return new Date().toISOString();
+}
+function makeMemory(sessionId, sandboxSession) {
+    return {
+        async read(key) {
+            validateMemoryKey(key);
+            const path = `/memory/${key}.json`;
+            if (!(await sandboxSession.exists(path))) {
+                return undefined;
+            }
+            return JSON.parse(await sandboxSession.readText(path));
+        },
+        async write(key, value) {
+            validateMemoryKey(key);
+            let encoded;
+            try {
+                encoded = JSON.stringify(value);
+            }
+            catch (error) {
+                throw new ValidationError('Memory value must be JSON-serializable.', { where: 'memory_value', issues: { key } }, error);
+            }
+            await sandboxSession.write(`/memory/${key}.json`, encoded);
+        },
+        async delete(key) {
+            validateMemoryKey(key);
+            await sandboxSession.remove(`/memory/${key}.json`).catch(() => undefined);
+        },
+        async list() {
+            const entries = await sandboxSession.list('/memory').catch(() => []);
+            return entries
+                .filter((entry) => entry.kind === 'file' && entry.name.endsWith('.json'))
+                .map((entry) => entry.name.slice(0, -5))
+                .sort();
+        }
+    };
+}
+function validateMemoryKey(key) {
+    if (!MEMORY_KEY_PATTERN.test(key)) {
+        throw new ValidationError('Invalid session memory key.', { where: 'memory_key', issues: { key } });
+    }
+}
+function validateInvokeOptions(opts) {
+    if (opts?.historyWindow !== undefined && opts.historyWindow < 0) {
+        throw new ValidationError('Invoke options are invalid.', { where: 'invoke_options', issues: { historyWindow: opts.historyWindow } });
+    }
+    if (opts?.timeoutMs !== undefined && opts.timeoutMs < 0) {
+        throw new ValidationError('Invoke options are invalid.', { where: 'invoke_options', issues: { timeoutMs: opts.timeoutMs } });
+    }
+}
+function normalizeMessage(message, sessionId) {
+    return {
+        ...message,
+        sessionId,
+        id: ulid(),
+        timestamp: now()
+    };
+}
+export function createSessionHarness(definition) {
+    const resolvedSkills = loadSkillsSync(definition.skills);
+    const sessionStates = new Map();
+    const telemetry = definition.telemetryShim ?? createTelemetryShim();
+    const adapterContext = {
+        harnessName: definition.name,
+        logger: definition.logger,
+        telemetry,
+        defaults: {
+            agentMaxIterations: definition.defaults.agentMaxIterations ?? 16,
+            runTimeoutMs: definition.defaults.runTimeoutMs ?? 600_000,
+            toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
+            skillTimeoutMs: definition.defaults.skillTimeoutMs ?? 60_000,
+            modelTimeoutMs: definition.defaults.modelTimeoutMs ?? 300_000,
+            ...(definition.defaults.historyWindow !== undefined ? { historyWindow: definition.defaults.historyWindow } : {})
+        }
+    };
+    configureHarnessAdapters(adapterContext, definition.models, definition.state, definition.sandbox, definition.tools);
+    const modelRegistry = createModelRegistry(definition.models, { telemetry, harnessName: definition.name });
+    const mcpRegistry = createMcpRunnerRegistry();
+    const captureContent = definition.telemetry?.captureContent === true;
+    async function ensureSessionRecord(sessionId) {
+        const existing = await definition.state.getSession(sessionId);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            id: sessionId,
+            createdAt: now(),
+            updatedAt: now(),
+            runCount: 0
+        };
+        await definition.state.upsertSession(created);
+        return created;
+    }
+    async function getSessionState(sessionId) {
+        const existing = sessionStates.get(sessionId);
+        if (existing) {
+            return existing;
+        }
+        const sandboxSession = await definition.sandbox.open({ sessionId, runId: `init_${ulid()}` });
+        const created = { busy: false, sandboxSession, mountedSkills: new Set() };
+        sessionStates.set(sessionId, created);
+        return created;
+    }
+    async function appendEvents(runId, events) {
+        try {
+            await definition.state.appendEvents(runId, events);
+        }
+        catch (error) {
+            telemetry.recordCounter('harness.events.persist_errors', 1, { harness: definition.name });
+            definition.logger.error('Failed to persist run events.', { harness: definition.name, run_id: runId, error: serializeError(error) });
+        }
+    }
+    return {
+        inspect() {
+            return definition.inspection;
+        },
+        async getSession(sessionId) {
+            await ensureSessionRecord(sessionId);
+            const state = await getSessionState(sessionId);
+            const memory = makeMemory(sessionId, state.sandboxSession);
+            const workflowEntries = Object.entries(definition.workflows).map(([workflowId, workflow]) => {
+                const invoker = {
+                    prompt: (input, opts) => runWorkflowCall(sessionId, workflowId, workflow, input, opts),
+                    async *stream(input, opts) {
+                        for await (const event of streamWorkflowCall(sessionId, workflowId, workflow, input, opts)) {
+                            yield event;
+                        }
+                    }
+                };
+                return [workflowId, invoker];
+            });
+            const workflows = Object.fromEntries(workflowEntries);
+            const agentEntries = Object.entries(definition.agents).map(([agentId, agent]) => {
+                const invoker = {
+                    prompt: (input, opts) => runAgentCall(sessionId, agentId, agent, input, opts),
+                    async *stream(input, opts) {
+                        for await (const event of streamAgentCall(sessionId, agentId, agent, input, opts)) {
+                            yield event;
+                        }
+                    }
+                };
+                return [agentId, invoker];
+            });
+            const agents = Object.fromEntries(agentEntries);
+            return {
+                id: sessionId,
+                agents,
+                workflows,
+                memory,
+                history: {
+                    list: (opts) => definition.state.listMessages(sessionId, opts)
+                },
+                async clearHistory() {
+                    if (state.busy) {
+                        throw new SessionBusyError('Session is busy.', { session_id: sessionId, reason: 'history_clear_during_run' });
+                    }
+                    await definition.state.clearMessages(sessionId);
+                },
+                async replaceHistory(messages) {
+                    if (state.busy) {
+                        throw new SessionBusyError('Session is busy.', { session_id: sessionId, reason: 'history_replace_during_run' });
+                    }
+                    const parsed = messages.map((message) => {
+                        try {
+                            return normalizeMessage(message, sessionId);
+                        }
+                        catch (error) {
+                            throw new ValidationError('Session history replacement failed validation.', { where: 'session_history', issues: { message } }, error);
+                        }
+                    });
+                    await definition.state.clearMessages(sessionId);
+                    if (parsed.length > 0) {
+                        await definition.state.appendMessages(sessionId, parsed);
+                    }
+                },
+                async close() {
+                    await definition.state.closeSession(sessionId);
+                    sessionStates.delete(sessionId);
+                    await state.sandboxSession.close();
+                }
+            };
+        },
+        async shutdown() {
+            const errors = [];
+            try {
+                await mcpRegistry.close();
+            }
+            catch (error) {
+                errors.push(error instanceof HarnessError ? error : new InternalError('Failed to close MCP registry.', undefined, error));
+            }
+            for (const [sessionId, state] of sessionStates) {
+                try {
+                    await state.sandboxSession.close();
+                }
+                catch (error) {
+                    errors.push(error instanceof HarnessError ? error : new InternalError('Failed to close sandbox session.', { session_id: sessionId }, error));
+                }
+            }
+            sessionStates.clear();
+            try {
+                await definition.state.close?.();
+            }
+            catch (error) {
+                errors.push(error instanceof HarnessError ? error : new InternalError('Failed to close state store.', undefined, error));
+            }
+            return { errors };
+        },
+        $infer: {}
+    };
+    async function* streamAgentCall(sessionId, agentId, agent, input, opts) {
+        const buffer = [];
+        const maxBufferedEvents = 1024;
+        let dropped = 0;
+        let done = false;
+        let failure;
+        let liveRunId = 'unknown';
+        const result = runAgentCall(sessionId, agentId, agent, input, opts, (event) => {
+            if ('runId' in event)
+                liveRunId = event.runId;
+            if (buffer.length >= maxBufferedEvents) {
+                const dropIndex = buffer.findIndex((candidate) => candidate.type !== 'run.finished');
+                if (dropIndex >= 0) {
+                    buffer.splice(dropIndex, 1);
+                    dropped += 1;
+                }
+            }
+            buffer.push(event);
+            return Promise.resolve();
+        }).catch((error) => {
+            failure = error;
+            return undefined;
+        }).finally(() => {
+            done = true;
+        });
+        let cursor = 0;
+        while (true) {
+            if (dropped > 0) {
+                yield { type: 'stream.overflow', runId: liveRunId, at: now(), dropped };
+                dropped = 0;
+            }
+            while (cursor < buffer.length) {
+                yield buffer[cursor];
+                cursor += 1;
+            }
+            if (done) {
+                await result.catch(() => undefined);
+                if (failure)
+                    throw failure;
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 5));
+        }
+    }
+    async function runAgentCall(sessionId, agentId, agent, input, opts, onEvent) {
+        validateInvokeOptions(opts);
+        if (opts?.signal?.aborted) {
+            throw new OperationCancelledError('Run was cancelled before start.', { scope: 'run' });
+        }
+        const runSignal = createRunSignal(opts?.signal, opts?.timeoutMs ?? definition.defaults.runTimeoutMs);
+        const state = await getSessionState(sessionId);
+        const memory = makeMemory(sessionId, state.sandboxSession);
+        if (state.busy) {
+            throw new SessionBusyError('Session is busy.', { session_id: sessionId, reason: 'concurrent_run' });
+        }
+        state.busy = true;
+        const startedAt = now();
+        const runId = ulid();
+        const runRecord = {
+            id: runId,
+            sessionId,
+            kind: 'agent',
+            target: agentId,
+            startedAt,
+            status: 'running',
+            input: input
+        };
+        const emit = async (event) => {
+            const eventAt = 'at' in event ? event.at : now();
+            await onEvent?.(event);
+            await appendEvents(runId, [{ id: ulid(), runId, at: eventAt, type: event.type, payload: sanitizeEventForPersistence(event, captureContent) }]);
+        };
+        try {
+            await definition.state.createRun(runRecord);
+        }
+        catch (error) {
+            state.busy = false;
+            throw error;
+        }
+        try {
+            const result = await telemetry.span('harness.session.agent_prompt', {
+                'harness.name': definition.name,
+                'harness.session.id': sessionId,
+                'harness.run.id': runId,
+                'harness.agent.id': agentId
+            }, async () => {
+                await emit({ type: 'run.started', runId, at: startedAt });
+                const resolvedHistoryWindow = opts?.historyWindow ?? definition.defaults.historyWindow;
+                const run = await runDefaultAgent({
+                    harnessName: definition.name,
+                    agentId,
+                    runId,
+                    sessionId,
+                    input,
+                    history: await definition.state.listMessages(sessionId),
+                    agent,
+                    models: modelRegistry,
+                    skills: resolvedSkills,
+                    customTools: definition.tools,
+                    mcpRegistry,
+                    session: state.sandboxSession,
+                    memory,
+                    mountedSkills: state.mountedSkills,
+                    ...(resolvedHistoryWindow !== undefined ? { historyWindow: resolvedHistoryWindow } : {}),
+                    maxSteps: definition.defaults.agentMaxIterations ?? 16,
+                    signal: runSignal.signal,
+                    toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
+                    logger: definition.logger,
+                    telemetry,
+                    emitEvent: emit
+                });
+                if (run.emitted.length > 0) {
+                    await definition.state.appendMessages(sessionId, run.emitted);
+                }
+                return run.output;
+            });
+            const finishedAt = now();
+            await emit({ type: 'run.finished', runId, at: finishedAt, output: result });
+            await definition.state.finishRun(runId, { status: 'succeeded', finishedAt, output: result });
+            const sessionRecord = await ensureSessionRecord(sessionId);
+            await definition.state.upsertSession({ ...sessionRecord, updatedAt: finishedAt, runCount: sessionRecord.runCount + 1 });
+            return result;
+        }
+        catch (error) {
+            const finalError = normalizeRunError(error, runSignal.signal);
+            const finishedAt = now();
+            const serialized = serializeError(finalError);
+            const log = finalError instanceof OperationCancelledError ? definition.logger.warn.bind(definition.logger) : definition.logger.error.bind(definition.logger);
+            log('Harness agent run failed.', {
+                harness: definition.name,
+                session_id: sessionId,
+                run_id: runId,
+                agent_id: agentId,
+                error: serialized
+            });
+            const runFinished = { type: 'run.finished', runId, at: finishedAt, error: serialized };
+            await terminalizeFailedRun({
+                kind: 'agent',
+                targetId: agentId,
+                sessionId,
+                runId,
+                primaryError: serialized,
+                emitRunFinished: () => emit(runFinished),
+                finishRun: () => definition.state.finishRun(runId, {
+                    status: finalError instanceof OperationCancelledError ? 'cancelled' : 'failed',
+                    finishedAt,
+                    error: serialized
+                }),
+                upsertSession: async () => {
+                    const sessionRecord = await ensureSessionRecord(sessionId);
+                    await definition.state.upsertSession({ ...sessionRecord, updatedAt: finishedAt, runCount: sessionRecord.runCount + 1 });
+                }
+            });
+            throw finalError;
+        }
+        finally {
+            runSignal.cleanup();
+            state.busy = false;
+        }
+    }
+    async function* streamWorkflowCall(sessionId, workflowId, workflow, input, opts) {
+        const buffer = [];
+        const maxBufferedEvents = 1024;
+        let dropped = 0;
+        let done = false;
+        let failure;
+        let liveRunId = 'unknown';
+        const result = runWorkflowCall(sessionId, workflowId, workflow, input, opts, (event) => {
+            if ('runId' in event)
+                liveRunId = event.runId;
+            if (buffer.length >= maxBufferedEvents) {
+                const dropIndex = buffer.findIndex((candidate) => candidate.type !== 'run.finished');
+                if (dropIndex >= 0) {
+                    buffer.splice(dropIndex, 1);
+                    dropped += 1;
+                }
+            }
+            buffer.push(event);
+            return Promise.resolve();
+        }).catch((error) => {
+            failure = error;
+            return undefined;
+        }).finally(() => {
+            done = true;
+        });
+        let cursor = 0;
+        while (true) {
+            if (dropped > 0) {
+                yield { type: 'stream.overflow', runId: liveRunId, at: now(), dropped };
+                dropped = 0;
+            }
+            while (cursor < buffer.length) {
+                yield buffer[cursor];
+                cursor += 1;
+            }
+            if (done) {
+                await result.catch(() => undefined);
+                if (failure)
+                    throw failure;
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 5));
+        }
+    }
+    async function runWorkflowCall(sessionId, workflowId, workflow, input, opts, onEvent) {
+        validateInvokeOptions(opts);
+        if (opts?.signal?.aborted) {
+            throw new OperationCancelledError('Run was cancelled before start.', { scope: 'run' });
+        }
+        const runSignal = createRunSignal(opts?.signal, opts?.timeoutMs ?? definition.defaults.runTimeoutMs);
+        const state = await getSessionState(sessionId);
+        const memory = makeMemory(sessionId, state.sandboxSession);
+        if (state.busy) {
+            throw new SessionBusyError('Session is busy.', { session_id: sessionId, reason: 'concurrent_run' });
+        }
+        state.busy = true;
+        const startedAt = now();
+        const runId = ulid();
+        const runRecord = {
+            id: runId,
+            sessionId,
+            kind: 'workflow',
+            target: workflowId,
+            startedAt,
+            status: 'running',
+            input: input
+        };
+        const emit = async (event) => {
+            const eventAt = 'at' in event ? event.at : now();
+            await onEvent?.(event);
+            await appendEvents(runId, [{ id: ulid(), runId, at: eventAt, type: event.type, payload: sanitizeEventForPersistence(event, captureContent) }]);
+        };
+        try {
+            await definition.state.createRun(runRecord);
+        }
+        catch (error) {
+            state.busy = false;
+            throw error;
+        }
+        try {
+            const result = await telemetry.span('harness.session.prompt', {
+                'harness.name': definition.name,
+                'harness.session.id': sessionId,
+                'harness.run.id': runId,
+                'harness.workflow.id': workflowId
+            }, async () => {
+                const runStarted = { type: 'run.started', runId, at: startedAt };
+                await emit(runStarted);
+                const workflowArgs = {
+                    workflowId,
+                    workflow,
+                    input,
+                    ctx: {
+                        signal: runSignal.signal,
+                        runId,
+                        sessionId,
+                        models: modelRegistry,
+                        agents: Object.fromEntries(Object.entries(definition.agents).map(([agentId, agent]) => [
+                            agentId,
+                            async (agentInput, agentOpts) => {
+                                const agentSignal = combineSignals(runSignal.signal, agentOpts?.signal);
+                                try {
+                                    const resolvedHistoryWindow = agentOpts?.historyWindow ?? opts?.historyWindow ?? definition.defaults.historyWindow;
+                                    const run = await runDefaultAgent({
+                                        harnessName: definition.name,
+                                        agentId,
+                                        runId,
+                                        sessionId,
+                                        workflowId,
+                                        input: agentInput,
+                                        history: await definition.state.listMessages(sessionId),
+                                        agent: agent,
+                                        models: modelRegistry,
+                                        skills: resolvedSkills,
+                                        customTools: definition.tools,
+                                        mcpRegistry,
+                                        session: state.sandboxSession,
+                                        memory,
+                                        mountedSkills: state.mountedSkills,
+                                        ...(resolvedHistoryWindow !== undefined ? { historyWindow: resolvedHistoryWindow } : {}),
+                                        maxSteps: definition.defaults.agentMaxIterations ?? 16,
+                                        signal: agentSignal.signal,
+                                        toolTimeoutMs: definition.defaults.toolTimeoutMs ?? 120_000,
+                                        logger: definition.logger,
+                                        telemetry,
+                                        emitEvent: emit
+                                    });
+                                    if (run.emitted.length > 0) {
+                                        await definition.state.appendMessages(sessionId, run.emitted);
+                                    }
+                                    return run.output;
+                                }
+                                finally {
+                                    agentSignal.cleanup();
+                                }
+                            }
+                        ]))
+                    }
+                };
+                return telemetry.span('harness.workflow.run', {
+                    'harness.name': definition.name,
+                    'harness.session.id': sessionId,
+                    'harness.run.id': runId,
+                    'harness.workflow.id': workflowId
+                }, async () => runWorkflow({
+                    ...workflowArgs,
+                    ...(opts ? { opts: { ...opts, signal: runSignal.signal } } : { opts: { signal: runSignal.signal } })
+                }));
+            });
+            const finishedAt = now();
+            const runFinished = { type: 'run.finished', runId, at: finishedAt, output: result };
+            await emit(runFinished);
+            await definition.state.finishRun(runId, { status: 'succeeded', finishedAt, output: result });
+            const sessionRecord = await ensureSessionRecord(sessionId);
+            await definition.state.upsertSession({ ...sessionRecord, updatedAt: finishedAt, runCount: sessionRecord.runCount + 1 });
+            return result;
+        }
+        catch (error) {
+            const finalError = normalizeRunError(error, runSignal.signal);
+            const finishedAt = now();
+            const serialized = serializeError(finalError);
+            const log = finalError instanceof OperationCancelledError ? definition.logger.warn.bind(definition.logger) : definition.logger.error.bind(definition.logger);
+            log('Harness workflow run failed.', {
+                harness: definition.name,
+                session_id: sessionId,
+                run_id: runId,
+                workflow_id: workflowId,
+                error: serialized
+            });
+            const runFinished = { type: 'run.finished', runId, at: finishedAt, error: serialized };
+            await terminalizeFailedRun({
+                kind: 'workflow',
+                targetId: workflowId,
+                sessionId,
+                runId,
+                primaryError: serialized,
+                emitRunFinished: () => emit(runFinished),
+                finishRun: () => definition.state.finishRun(runId, {
+                    status: finalError instanceof OperationCancelledError ? 'cancelled' : 'failed',
+                    finishedAt,
+                    error: serialized
+                }),
+                upsertSession: async () => {
+                    const sessionRecord = await ensureSessionRecord(sessionId);
+                    await definition.state.upsertSession({ ...sessionRecord, updatedAt: finishedAt, runCount: sessionRecord.runCount + 1 });
+                }
+            });
+            throw finalError;
+        }
+        finally {
+            runSignal.cleanup();
+            state.busy = false;
+        }
+    }
+    async function terminalizeFailedRun(args) {
+        await runFailureTerminalizationStep(args, 'emit_run_finished', args.emitRunFinished);
+        await runFailureTerminalizationStep(args, 'finish_run', args.finishRun);
+        await runFailureTerminalizationStep(args, 'upsert_session', args.upsertSession);
+    }
+    async function runFailureTerminalizationStep(args, operation, step) {
+        try {
+            await step();
+        }
+        catch (error) {
+            telemetry.recordCounter('harness.runs.terminalization_errors', 1, {
+                harness: definition.name,
+                'harness.run.kind': args.kind,
+                'harness.run.terminalization.operation': operation
+            });
+            definition.logger.error('Failed to terminalize failed run; preserving primary run error.', {
+                harness: definition.name,
+                session_id: args.sessionId,
+                run_id: args.runId,
+                [`${args.kind}_id`]: args.targetId,
+                operation,
+                primary_error: args.primaryError,
+                error: serializeError(error)
+            });
+        }
+    }
+}
+function configureHarnessAdapters(context, models, state, sandbox, tools) {
+    const seen = new Set();
+    for (const alias of Object.values(models)) {
+        configureOne(alias.provider, context, seen);
+    }
+    configureOne(state, context, seen);
+    configureOne(sandbox, context, seen);
+    for (const tool of Object.values(tools)) {
+        configureOne(tool, context, seen);
+    }
+}
+function configureOne(adapter, context, seen) {
+    const configurable = adapter;
+    if (!configurable.configureHarnessContext || seen.has(adapter))
+        return;
+    configurable.configureHarnessContext(context);
+    seen.add(adapter);
+}
+function normalizeRunError(error, signal) {
+    if (!signal.aborted)
+        return error;
+    if (signal.reason instanceof OperationTimeoutError)
+        return signal.reason;
+    if (error instanceof OperationCancelledError || error instanceof OperationTimeoutError)
+        return error;
+    return new OperationCancelledError('Run was cancelled.', { scope: 'run' }, signal.reason ?? error);
+}
+function sanitizeEventForPersistence(event, captureContent) {
+    if (captureContent) {
+        const { runId: _runId, at: _at, type: _type, ...payload } = event;
+        return payload;
+    }
+    switch (event.type) {
+        case 'run.started':
+            return {};
+        case 'run.finished':
+            return {
+                ...(event.output !== undefined ? { output: '[redacted]' } : {}),
+                ...(event.error ? { error: event.error } : {})
+            };
+        case 'agent.started':
+            return { agentId: event.agentId };
+        case 'agent.finished':
+            return {
+                agentId: event.agentId,
+                ...(event.output !== undefined ? { output: '[redacted]' } : {}),
+                ...(event.error ? { error: event.error } : {})
+            };
+        case 'tool.started':
+            return { agentId: event.agentId, toolId: event.toolId, callId: event.callId, input: '[redacted]' };
+        case 'tool.finished':
+            return {
+                agentId: event.agentId,
+                toolId: event.toolId,
+                callId: event.callId,
+                ...(event.output !== undefined ? { output: '[redacted]' } : {}),
+                ...(event.error ? { error: event.error } : {})
+            };
+        case 'model.message':
+            return { agentId: event.agentId, message: '[redacted]' };
+        case 'model.delta':
+            return { agentId: event.agentId, delta: '[redacted]' };
+        case 'model.object.partial':
+            return { ...(event.agentId ? { agentId: event.agentId } : {}), partial: '[redacted]' };
+        case 'model.object':
+            return { ...(event.agentId ? { agentId: event.agentId } : {}), object: '[redacted]' };
+        case 'model.embedding.completed':
+            return {
+                ...(event.agentId ? { agentId: event.agentId } : {}),
+                count: event.count,
+                ...(event.dimensions !== undefined ? { dimensions: event.dimensions } : {}),
+                ...(event.usage ? { usage: event.usage } : {})
+            };
+        case 'model.rerank.completed':
+            return {
+                ...(event.agentId ? { agentId: event.agentId } : {}),
+                count: event.count,
+                ...(event.topN !== undefined ? { topN: event.topN } : {}),
+                ...(event.usage ? { usage: event.usage } : {})
+            };
+        case 'stream.overflow':
+            return { dropped: event.dropped };
+    }
+}
+function createRunSignal(parent, timeoutMs) {
+    const controller = new AbortController();
+    const relay = () => controller.abort(parent?.reason);
+    if (parent)
+        parent.addEventListener('abort', relay, { once: true });
+    const timeout = timeoutMs && timeoutMs > 0
+        ? setTimeout(() => controller.abort(new OperationTimeoutError('Run timed out.', { scope: 'run', timeout_ms: timeoutMs })), timeoutMs)
+        : undefined;
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (parent)
+                parent.removeEventListener('abort', relay);
+        }
+    };
+}
+function combineSignals(primary, secondary) {
+    if (!secondary)
+        return { signal: primary, cleanup: () => undefined };
+    const controller = new AbortController();
+    const relayPrimary = () => controller.abort(primary.reason);
+    const relaySecondary = () => controller.abort(secondary.reason);
+    primary.addEventListener('abort', relayPrimary, { once: true });
+    secondary.addEventListener('abort', relaySecondary, { once: true });
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            primary.removeEventListener('abort', relayPrimary);
+            secondary.removeEventListener('abort', relaySecondary);
+        }
+    };
+}