@amalgm/agents 0.2.1 → 0.2.2

package/dist/drivers.d.ts

@@ -1,4 +0,0 @@
-import type { AgentDriver } from './types.js';
-export declare function defineDriver(driver: AgentDriver): AgentDriver;
-export declare function loadDriverModules(specifiers: string[]): Promise<AgentDriver[]>;
-export declare function driverSpecifiers(value?: string): string[];

package/dist/drivers.js

@@ -1,25 +0,0 @@
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { AgentError } from './errors.js';
-export function defineDriver(driver) {
-    if (!driver || typeof driver.id !== 'string' || typeof driver.run !== 'function') {
-        throw new AgentError('invalid_input', 'Agent drivers require id and run.');
-    }
-    return driver;
-}
-export async function loadDriverModules(specifiers) {
-    const drivers = [];
-    for (const specifier of specifiers) {
-        const target = specifier.startsWith('.') || specifier.startsWith('/')
-            ? pathToFileURL(path.resolve(specifier)).href
-            : specifier;
-        const loaded = await import(target);
-        const value = loaded.default ?? loaded.driver ?? loaded;
-        const driver = typeof value === 'function' ? await value() : value;
-        drivers.push(defineDriver(driver));
-    }
-    return drivers;
-}
-export function driverSpecifiers(value = process.env.AMALGM_AGENT_DRIVERS || '') {
-    return value.split(',').map((item) => item.trim()).filter(Boolean);
-}

package/dist/event-store.d.ts

@@ -1,13 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { EventListener, JsonObject, SessionEvent } from './types.js';
-export declare class EventStore {
-    private readonly database;
-    private readonly now;
-    private readonly listener;
-    constructor(database: Database.Database, now: () => string, listener: EventListener);
-    append(sessionId: string, turnId: string | null, type: string, data: JsonObject): SessionEvent;
-    write(sessionId: string, turnId: string | null, type: string, data: JsonObject): SessionEvent;
-    announce(event: SessionEvent): void;
-    list(sessionId: string, after?: number, limit?: number): SessionEvent[];
-    forTurn(turnId: string): SessionEvent[];
-}

package/dist/event-store.js

@@ -1,50 +0,0 @@
-import { AgentError } from './errors.js';
-import { newId } from './ids.js';
-import { eventFromRow } from './rows.js';
-export class EventStore {
-    database;
-    now;
-    listener;
-    constructor(database, now, listener) {
-        this.database = database;
-        this.now = now;
-        this.listener = listener;
-    }
-    append(sessionId, turnId, type, data) {
-        let event;
-        this.database.transaction(() => {
-            event = this.write(sessionId, turnId, type, data);
-            this.database.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(this.now(), sessionId);
-        })();
-        if (!event)
-            throw new AgentError('internal', 'Event transaction produced no event.');
-        this.announce(event);
-        return event;
-    }
-    write(sessionId, turnId, type, data) {
-        const sequence = Number(this.database.prepare(`
-      SELECT COALESCE(MAX(sequence), 0) + 1 AS value FROM session_events WHERE session_id = ?
-    `).get(sessionId).value);
-        const id = newId('event');
-        const createdAt = this.now();
-        this.database.prepare(`
-      INSERT INTO session_events (id, session_id, turn_id, sequence, type, data_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(id, sessionId, turnId, sequence, type, JSON.stringify(data), createdAt);
-        return { id, sessionId, turnId, sequence, type, data, createdAt };
-    }
-    announce(event) {
-        this.listener(event);
-    }
-    list(sessionId, after = 0, limit = 200) {
-        const cursor = Number.isFinite(after) ? Math.max(0, Math.floor(after)) : 0;
-        const bounded = Number.isFinite(limit) ? Math.max(1, Math.min(1000, Math.floor(limit))) : 200;
-        return this.database.prepare(`
-      SELECT * FROM session_events WHERE session_id = ? AND sequence > ? ORDER BY sequence ASC LIMIT ?
-    `).all(sessionId, cursor, bounded).map(eventFromRow);
-    }
-    forTurn(turnId) {
-        return this.database.prepare('SELECT * FROM session_events WHERE turn_id = ? ORDER BY sequence ASC')
-            .all(turnId).map(eventFromRow);
-    }
-}

package/dist/http/session-routes.d.ts

@@ -1,2 +0,0 @@
-import type { RouteContext } from '../http-types.js';
-export declare function routeSessions(context: RouteContext): Promise<boolean>;

package/dist/http/session-routes.js

@@ -1,67 +0,0 @@
-import { AgentError } from '../errors.js';
-export async function routeSessions(context) {
-    const [resource, id, child] = context.path;
-    if (resource !== 'sessions')
-        return false;
-    if (!id && context.method === 'GET') {
-        const agentId = context.url.searchParams.get('agent_id') || undefined;
-        const archived = context.url.searchParams.get('include_archived') === 'true';
-        context.json(200, { sessions: context.agents.listSessions(agentId, archived) });
-        return true;
-    }
-    if (!id && context.method === 'POST') {
-        const body = await context.body();
-        if (typeof body.agentId !== 'string')
-            throw new AgentError('invalid_input', 'agentId is required.');
-        context.json(201, { session: context.agents.startSession({
-                agentId: body.agentId,
-                ...(typeof body.revisionId === 'string' ? { revisionId: body.revisionId } : {}),
-                ...(typeof body.sessionId === 'string' ? { sessionId: body.sessionId } : {}),
-                ...(body.metadata ? { metadata: body.metadata } : {}),
-            }) });
-        return true;
-    }
-    if (!id)
-        throw new AgentError('not_found', 'Route not found.');
-    if (!child && context.method === 'GET') {
-        const session = context.agents.getSession(id);
-        if (!session)
-            throw new AgentError('not_found', `Session not found: ${id}`);
-        context.json(200, { session });
-        return true;
-    }
-    if (!child && context.method === 'DELETE') {
-        context.json(200, { session: context.agents.archiveSession(id) });
-        return true;
-    }
-    if (child === 'events' && context.method === 'GET') {
-        const after = Number(context.url.searchParams.get('after') || 0);
-        const limit = Number(context.url.searchParams.get('limit') || 200);
-        context.json(200, { events: context.agents.listEvents(id, after, limit) });
-        return true;
-    }
-    if (child === 'turns' && context.method === 'GET') {
-        context.json(200, { turns: context.agents.listTurns(id) });
-        return true;
-    }
-    if (child === 'cancel' && context.method === 'POST') {
-        context.json(202, { turn: context.agents.cancelSession(id) });
-        return true;
-    }
-    if (child === 'messages' && context.method === 'POST') {
-        const body = await context.body();
-        if (body.message === undefined)
-            throw new AgentError('invalid_input', 'message is required.');
-        const enqueued = context.agents.enqueue(id, {
-            message: body.message,
-            ...(typeof body.idempotencyKey === 'string' ? { idempotencyKey: body.idempotencyKey } : {}),
-        });
-        if (body.wait === false) {
-            context.json(202, { turn: enqueued.turn, duplicate: enqueued.duplicate });
-            return true;
-        }
-        context.json(200, { turn: await enqueued.completion, duplicate: enqueued.duplicate });
-        return true;
-    }
-    return false;
-}

package/dist/http/stream.d.ts

@@ -1,3 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Agents } from '../agents.js';
-export declare function streamEvents(agents: Agents, sessionId: string, request: IncomingMessage, response: ServerResponse, after?: number): void;

package/dist/http/stream.js

@@ -1,30 +0,0 @@
-import { AgentError } from '../errors.js';
-export function streamEvents(agents, sessionId, request, response, after = 0) {
-    if (!agents.getSession(sessionId))
-        throw new AgentError('not_found', `Session not found: ${sessionId}`);
-    response.writeHead(200, {
-        'content-type': 'text/event-stream',
-        'cache-control': 'no-cache, no-transform',
-        connection: 'keep-alive',
-    });
-    response.flushHeaders();
-    let last = after;
-    const write = (event) => {
-        if (event.sequence <= last || response.destroyed)
-            return;
-        last = event.sequence;
-        response.write(`id: ${event.sequence}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
-    };
-    for (const event of agents.listEvents(sessionId, after, 1000))
-        write(event);
-    const unsubscribe = agents.subscribe(sessionId, write);
-    const heartbeat = setInterval(() => {
-        if (!response.destroyed)
-            response.write(': heartbeat\n\n');
-    }, 15_000);
-    heartbeat.unref();
-    request.once('close', () => {
-        clearInterval(heartbeat);
-        unsubscribe();
-    });
-}

package/dist/mcp/session-tools.d.ts

@@ -1,3 +0,0 @@
-import type { Agents } from '../agents.js';
-import type { McpTool } from './types.js';
-export declare function sessionTools(agents: Agents): McpTool[];

package/dist/mcp/session-tools.js

@@ -1,81 +0,0 @@
-import { AgentError } from '../errors.js';
-import { objectSchema, toolResult } from './helpers.js';
-const string = { type: 'string' };
-function text(input, ...keys) {
-    for (const key of keys) {
-        if (typeof input[key] === 'string' && input[key])
-            return input[key];
-    }
-    return undefined;
-}
-function resolveAgentId(agents, requested) {
-    const normalized = requested.toLowerCase();
-    const matches = agents.listAgents().filter(({ id, definition }) => {
-        return id.toLowerCase() === normalized || definition.name.toLowerCase() === normalized;
-    });
-    if (matches.length === 1)
-        return matches[0].id;
-    if (matches.length > 1)
-        throw new AgentError('conflict', `Agent name is ambiguous: ${requested}`);
-    throw new AgentError('not_found', `Agent not found: ${requested}`);
-}
-export function sessionTools(agents) {
-    return [
-        {
-            name: 'agents_get_conversation',
-            description: 'Read one durable agent session, including its turns and ordered events.',
-            inputSchema: objectSchema({ conversation_id: string, session_id: string, after: { type: 'number' } }),
-            handler(input) {
-                const id = text(input, 'conversation_id', 'session_id');
-                if (!id)
-                    throw new AgentError('invalid_input', 'conversation_id is required.');
-                return toolResult({
-                    conversation_id: id,
-                    session: agents.getSession(id),
-                    turns: agents.listTurns(id),
-                    events: agents.listEvents(id, Number(input.after || 0)),
-                });
-            },
-        },
-        {
-            name: 'talk_to_agent',
-            description: 'Start or continue a durable agent session. Agents sessions are not Chat conversations.',
-            inputSchema: objectSchema({
-                agent: string,
-                agent_id: string,
-                conversation_id: string,
-                session_id: string,
-                description: string,
-                prompt: string,
-                message: { type: ['string', 'object'] },
-                idempotency_key: string,
-                run_in_background: { type: 'boolean' },
-            }),
-            async handler(input) {
-                const requestedAgent = text(input, 'agent', 'agent_id');
-                if (!requestedAgent)
-                    throw new AgentError('invalid_input', 'agent is required.');
-                const agentId = resolveAgentId(agents, requestedAgent);
-                const message = input.message ?? input.prompt;
-                if (message === undefined)
-                    throw new AgentError('invalid_input', 'prompt or message is required.');
-                const sessionId = text(input, 'conversation_id', 'session_id');
-                const idempotencyKey = text(input, 'idempotency_key');
-                const call = agents.talk(agentId, {
-                    message: message,
-                    ...(sessionId ? { sessionId } : {}),
-                    ...(idempotencyKey ? { idempotencyKey } : {}),
-                });
-                const base = {
-                    conversation_id: call.session.id,
-                    session: call.session,
-                    turn: call.turn,
-                    duplicate: call.duplicate,
-                };
-                if (input.run_in_background === true)
-                    return toolResult(base);
-                return toolResult({ ...base, turn: await call.completion });
-            },
-        },
-    ];
-}

package/dist/messages.d.ts

@@ -1,3 +0,0 @@
-import type { AgentMessage } from './types.js';
-export declare function normalizeMessage(value: string | AgentMessage, role?: AgentMessage['role']): AgentMessage;
-export declare function messageText(message: AgentMessage): string;

package/dist/messages.js

@@ -1,56 +0,0 @@
-import { AgentError } from './errors.js';
-import { isObject } from './json.js';
-function normalizePart(value) {
-    if (!isObject(value))
-        throw new AgentError('invalid_input', 'message parts must be objects.');
-    if (value.type === 'text') {
-        if (typeof value.text !== 'string' || !value.text) {
-            throw new AgentError('invalid_input', 'text parts require non-empty text.');
-        }
-        return { type: 'text', text: value.text };
-    }
-    if (value.type === 'reference') {
-        if (typeof value.uri !== 'string' || !value.uri.trim()) {
-            throw new AgentError('invalid_input', 'reference parts require uri.');
-        }
-        return {
-            type: 'reference',
-            uri: value.uri.trim(),
-            name: typeof value.name === 'string' && value.name.trim() ? value.name.trim() : null,
-            mediaType: typeof value.mediaType === 'string' && value.mediaType.trim()
-                ? value.mediaType.trim()
-                : null,
-        };
-    }
-    if (value.type === 'data') {
-        if (typeof value.name !== 'string' || !value.name.trim() || value.data === undefined) {
-            throw new AgentError('invalid_input', 'data parts require name and data.');
-        }
-        return {
-            type: 'data',
-            name: value.name.trim(),
-            data: JSON.parse(JSON.stringify(value.data)),
-        };
-    }
-    throw new AgentError('invalid_input', `Unsupported message part: ${String(value.type)}`);
-}
-export function normalizeMessage(value, role = 'user') {
-    if (typeof value === 'string') {
-        if (!value)
-            throw new AgentError('invalid_input', 'message must not be empty.');
-        return { role, parts: [{ type: 'text', text: value }] };
-    }
-    if (!isObject(value) || !Array.isArray(value.parts) || value.parts.length === 0) {
-        throw new AgentError('invalid_input', 'message requires at least one part.');
-    }
-    const validRoles = new Set(['user', 'assistant', 'system']);
-    if (!validRoles.has(value.role))
-        throw new AgentError('invalid_input', 'message role is invalid.');
-    return { role: value.role, parts: value.parts.map(normalizePart) };
-}
-export function messageText(message) {
-    return message.parts
-        .filter((part) => part.type === 'text')
-        .map((part) => part.text)
-        .join('');
-}

package/dist/runtime.d.ts

@@ -1,29 +0,0 @@
-import type { AgentStore } from './agent-store.js';
-import type { EventStore } from './event-store.js';
-import type { SessionStore } from './session-store.js';
-import type { TurnStore } from './turn-store.js';
-import type { AgentDriver, AgentTurn, EnqueuedTurn, SendInput } from './types.js';
-export interface RuntimeLimits {
-    maxInputBytes: number;
-    maxEventBytes: number;
-    turnTimeoutMs: number;
-}
-export declare class AgentRuntime {
-    private readonly agents;
-    private readonly sessions;
-    private readonly turns;
-    private readonly events;
-    private readonly limits;
-    private readonly drivers;
-    private readonly active;
-    constructor(agents: AgentStore, sessions: SessionStore, turns: TurnStore, events: EventStore, limits: RuntimeLimits, drivers?: AgentDriver[]);
-    register(driver: AgentDriver): void;
-    driverIds(): string[];
-    enqueue(sessionId: string, input: SendInput): EnqueuedTurn;
-    send(sessionId: string, input: SendInput): Promise<AgentTurn>;
-    cancel(sessionId: string): AgentTurn;
-    shutdown(): Promise<void>;
-    private execute;
-    private emit;
-    private normalizeResult;
-}

package/dist/runtime.js

@@ -1,176 +0,0 @@
-import { AgentError, asAgentError } from './errors.js';
-import { assertByteLimit, isObject } from './json.js';
-import { normalizeMessage } from './messages.js';
-export class AgentRuntime {
-    agents;
-    sessions;
-    turns;
-    events;
-    limits;
-    drivers = new Map();
-    active = new Map();
-    constructor(agents, sessions, turns, events, limits, drivers = []) {
-        this.agents = agents;
-        this.sessions = sessions;
-        this.turns = turns;
-        this.events = events;
-        this.limits = limits;
-        for (const driver of drivers)
-            this.register(driver);
-    }
-    register(driver) {
-        if (!driver || typeof driver.id !== 'string' || typeof driver.run !== 'function') {
-            throw new AgentError('invalid_input', 'Agent drivers require id and run.');
-        }
-        if (this.drivers.has(driver.id)) {
-            throw new AgentError('conflict', `Agent driver already registered: ${driver.id}`);
-        }
-        this.drivers.set(driver.id, driver);
-    }
-    driverIds() {
-        return [...this.drivers.keys()].sort();
-    }
-    enqueue(sessionId, input) {
-        const message = normalizeMessage(input.message, 'user');
-        assertByteLimit(message, this.limits.maxInputBytes, 'message');
-        const reserved = this.turns.reserve(sessionId, message, input.idempotencyKey);
-        if (reserved.duplicate) {
-            const running = this.active.get(reserved.turn.id);
-            return {
-                turn: reserved.turn,
-                completion: running?.completion || Promise.resolve(reserved.turn),
-                duplicate: true,
-            };
-        }
-        const controller = new AbortController();
-        const completion = this.execute(reserved.turn, controller);
-        this.active.set(reserved.turn.id, { controller, completion });
-        void completion.then(() => this.active.delete(reserved.turn.id), () => this.active.delete(reserved.turn.id));
-        return { turn: reserved.turn, completion, duplicate: false };
-    }
-    async send(sessionId, input) {
-        return this.enqueue(sessionId, input).completion;
-    }
-    cancel(sessionId) {
-        const turn = this.turns.active(sessionId);
-        if (!turn)
-            throw new AgentError('conflict', 'Session has no active turn.');
-        const execution = this.active.get(turn.id);
-        if (!execution)
-            throw new AgentError('conflict', 'Active turn is not owned by this process.');
-        const cancelling = this.turns.requestCancellation(turn.id);
-        execution.controller.abort(new AgentError('cancelled', 'Turn cancelled by caller.'));
-        return cancelling;
-    }
-    async shutdown() {
-        const executions = [...this.active.entries()];
-        for (const [turnId, execution] of executions) {
-            const turn = this.turns.get(turnId);
-            if (turn && (turn.status === 'queued' || turn.status === 'running')) {
-                this.turns.requestCancellation(turnId);
-            }
-            execution.controller.abort(new Error('Agents service shutting down.'));
-        }
-        await Promise.allSettled(executions.map(([, execution]) => execution.completion));
-    }
-    async execute(turn, controller) {
-        const session = this.sessions.require(turn.sessionId);
-        const revision = this.agents.revision(session.agentId, session.agentRevisionId);
-        const driver = this.drivers.get(revision.definition.driver.id);
-        if (!driver) {
-            return this.turns.fail(turn.id, failure('driver_unavailable', `Agent driver is not registered: ${revision.definition.driver.id}`));
-        }
-        this.turns.markRunning(turn.id);
-        let timedOut = false;
-        const timer = this.limits.turnTimeoutMs > 0
-            ? setTimeout(() => {
-                timedOut = true;
-                controller.abort(new Error('Turn timed out.'));
-            }, this.limits.turnTimeoutMs)
-            : null;
-        timer?.unref();
-        try {
-            const result = await driver.run({
-                agent: revision,
-                session,
-                turn: this.turns.require(turn.id),
-                history: this.turns.history(session.id, turn.id),
-                input: turn.input,
-                driverSessionId: session.driverSessionId,
-            }, {
-                signal: controller.signal,
-                emit: (event) => this.emit(session.id, turn.id, event),
-            });
-            if (controller.signal.aborted) {
-                if (this.turns.require(turn.id).status === 'cancelling')
-                    return this.turns.cancel(turn.id);
-                return this.turns.fail(turn.id, failure('turn_timeout', 'Turn timed out.'));
-            }
-            const normalized = this.normalizeResult(result);
-            if (normalized.message) {
-                const data = {
-                    message: normalized.message,
-                };
-                assertByteLimit(data, this.limits.maxEventBytes, 'driver result message');
-                this.events.append(session.id, turn.id, 'message', data);
-            }
-            if (normalized.driverSessionId) {
-                this.sessions.setDriverSession(session.id, normalized.driverSessionId);
-            }
-            const storedResult = {
-                metadata: normalized.metadata || {},
-                ...(normalized.driverSessionId ? { driverSessionId: normalized.driverSessionId } : {}),
-            };
-            assertByteLimit(storedResult, this.limits.maxEventBytes, 'driver result');
-            return this.turns.complete(turn.id, storedResult);
-        }
-        catch (error) {
-            const current = this.turns.require(turn.id);
-            if (current.status === 'cancelling')
-                return this.turns.cancel(turn.id);
-            const normalized = asAgentError(error);
-            return this.turns.fail(turn.id, failure(timedOut ? 'turn_timeout' : normalized.code === 'internal' ? 'driver_error' : normalized.code, normalized.message, normalized.details));
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    emit(sessionId, turnId, event) {
-        if (!event || typeof event.type !== 'string' || !event.type.trim() || !isObject(event.data)) {
-            throw new AgentError('invalid_input', 'Driver events require type and object data.');
-        }
-        if (/^(session|turn)\./.test(event.type)) {
-            throw new AgentError('invalid_input', 'Driver events cannot use reserved session.* or turn.* types.');
-        }
-        assertByteLimit(event.data, this.limits.maxEventBytes, 'driver event');
-        if (event.type === 'message' && event.data.message) {
-            const message = normalizeMessage(event.data.message, 'assistant');
-            if (message.role !== 'assistant') {
-                throw new AgentError('invalid_input', 'Driver message events must have assistant role.');
-            }
-            return this.events.append(sessionId, turnId, 'message', { message: message });
-        }
-        return this.events.append(sessionId, turnId, event.type.trim(), event.data);
-    }
-    normalizeResult(result) {
-        if (!result)
-            return {};
-        const normalized = {};
-        if (result.message) {
-            normalized.message = normalizeMessage(result.message, 'assistant');
-            if (normalized.message.role !== 'assistant') {
-                throw new AgentError('invalid_input', 'Driver result messages must have assistant role.');
-            }
-        }
-        if (typeof result.driverSessionId === 'string' && result.driverSessionId.trim()) {
-            normalized.driverSessionId = result.driverSessionId.trim();
-        }
-        if (result.metadata && isObject(result.metadata))
-            normalized.metadata = result.metadata;
-        return normalized;
-    }
-}
-function failure(code, message, details = {}) {
-    return { code, message, details };
-}

package/dist/session-store.d.ts

@@ -1,15 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { AgentRevision, AgentSession, JsonObject } from './types.js';
-import type { EventStore } from './event-store.js';
-export declare class SessionStore {
-    private readonly database;
-    private readonly events;
-    private readonly now;
-    constructor(database: Database.Database, events: EventStore, now: () => string);
-    create(revision: AgentRevision, sessionId?: string, metadata?: JsonObject): AgentSession;
-    get(id: string): AgentSession | null;
-    require(id: string): AgentSession;
-    list(agentId?: string, includeArchived?: boolean): AgentSession[];
-    archive(id: string, hasActiveTurn: boolean): AgentSession;
-    setDriverSession(id: string, driverSessionId: string): void;
-}

package/dist/session-store.js

@@ -1,83 +0,0 @@
-import { AgentError } from './errors.js';
-import { newId, optionalId, requireId } from './ids.js';
-import { assertJsonObject } from './json.js';
-import { sessionFromRow } from './rows.js';
-export class SessionStore {
-    database;
-    events;
-    now;
-    constructor(database, events, now) {
-        this.database = database;
-        this.events = events;
-        this.now = now;
-    }
-    create(revision, sessionId, metadata = {}) {
-        const id = optionalId(sessionId, 'session id') || newId('session');
-        if (this.get(id))
-            throw new AgentError('conflict', `Session id already exists: ${id}`);
-        const timestamp = this.now();
-        const storedMetadata = assertJsonObject(metadata, 'metadata');
-        let event;
-        this.database.transaction(() => {
-            this.database.prepare(`
-        INSERT INTO sessions
-          (id, agent_id, agent_revision_id, agent_revision_number, status, metadata_json, created_at, updated_at)
-        VALUES (?, ?, ?, ?, 'active', ?, ?, ?)
-      `).run(id, revision.agentId, revision.id, revision.number, JSON.stringify(storedMetadata), timestamp, timestamp);
-            event = this.events.write(id, null, 'session.started', {
-                agentId: revision.agentId,
-                agentRevisionId: revision.id,
-                agentRevision: revision.number,
-            });
-        })();
-        if (event)
-            this.events.announce(event);
-        return this.require(id);
-    }
-    get(id) {
-        const clean = requireId(id, 'session id');
-        const row = this.database.prepare('SELECT * FROM sessions WHERE id = ?').get(clean);
-        return row ? sessionFromRow(row) : null;
-    }
-    require(id) {
-        const session = this.get(id);
-        if (!session)
-            throw new AgentError('not_found', `Session not found: ${id}`);
-        return session;
-    }
-    list(agentId, includeArchived = false) {
-        const filters = [];
-        const values = [];
-        if (agentId) {
-            filters.push('agent_id = ?');
-            values.push(requireId(agentId, 'agent id'));
-        }
-        if (!includeArchived)
-            filters.push("status = 'active'");
-        const where = filters.length ? ` WHERE ${filters.join(' AND ')}` : '';
-        return this.database.prepare(`SELECT * FROM sessions${where} ORDER BY updated_at DESC`).all(...values)
-            .map(sessionFromRow);
-    }
-    archive(id, hasActiveTurn) {
-        const session = this.require(id);
-        if (hasActiveTurn)
-            throw new AgentError('conflict', 'Cannot archive a session with an active turn.');
-        if (session.status === 'archived')
-            return session;
-        const timestamp = this.now();
-        let event;
-        this.database.transaction(() => {
-            this.database.prepare(`
-        UPDATE sessions SET status = 'archived', archived_at = ?, updated_at = ? WHERE id = ?
-      `).run(timestamp, timestamp, session.id);
-            event = this.events.write(session.id, null, 'session.archived', {});
-        })();
-        if (event)
-            this.events.announce(event);
-        return this.require(session.id);
-    }
-    setDriverSession(id, driverSessionId) {
-        this.database.prepare('UPDATE sessions SET driver_session_id = ?, updated_at = ? WHERE id = ?')
-            .run(driverSessionId, this.now(), requireId(id, 'session id'));
-    }
-}