@amalgm/agents 0.2.1 → 0.2.2

package/dist/turn-store.d.ts

@@ -1,31 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { EventStore } from './event-store.js';
-import type { SessionStore } from './session-store.js';
-import type { AgentFailure, AgentMessage, AgentTurn, JsonObject } from './types.js';
-export declare class TurnStore {
-    private readonly database;
-    private readonly sessions;
-    private readonly events;
-    private readonly now;
-    constructor(database: Database.Database, sessions: SessionStore, events: EventStore, now: () => string);
-    reserve(sessionId: string, input: AgentMessage, key?: string): {
-        turn: AgentTurn;
-        duplicate: boolean;
-    };
-    markRunning(id: string): AgentTurn;
-    requestCancellation(id: string): AgentTurn;
-    complete(id: string, result: JsonObject): AgentTurn;
-    fail(id: string, failure: AgentFailure): AgentTurn;
-    cancel(id: string): AgentTurn;
-    interrupt(id: string, failure: AgentFailure): AgentTurn;
-    get(id: string): AgentTurn | null;
-    require(id: string): AgentTurn;
-    list(sessionId: string): AgentTurn[];
-    active(sessionId: string): AgentTurn | null;
-    history(sessionId: string, beforeTurnId?: string): AgentMessage[];
-    recoverInterrupted(): number;
-    private byKey;
-    private transition;
-    private terminal;
-    private touch;
-}

package/dist/turn-store.js

@@ -1,164 +0,0 @@
-import { AgentError } from './errors.js';
-import { newId, optionalKey, randomKey, requireId } from './ids.js';
-import { isObject } from './json.js';
-import { turnFromRow } from './rows.js';
-const ACTIVE_SQL = `status IN ('queued', 'running', 'cancelling')`;
-const TERMINAL = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
-export class TurnStore {
-    database;
-    sessions;
-    events;
-    now;
-    constructor(database, sessions, events, now) {
-        this.database = database;
-        this.sessions = sessions;
-        this.events = events;
-        this.now = now;
-    }
-    reserve(sessionId, input, key) {
-        const session = this.sessions.require(sessionId);
-        if (session.status !== 'active')
-            throw new AgentError('conflict', 'Session is archived.');
-        const idempotencyKey = optionalKey(key) || randomKey('turn-key');
-        const existing = this.byKey(session.id, idempotencyKey);
-        if (existing)
-            return { turn: existing, duplicate: true };
-        if (this.active(session.id))
-            throw new AgentError('conflict', 'Session already has an active turn.');
-        const id = newId('turn');
-        const timestamp = this.now();
-        let event;
-        try {
-            this.database.transaction(() => {
-                this.database.prepare(`
-          INSERT INTO turns (id, session_id, idempotency_key, status, input_json, created_at)
-          VALUES (?, ?, ?, 'queued', ?, ?)
-        `).run(id, session.id, idempotencyKey, JSON.stringify(input), timestamp);
-                event = this.events.write(session.id, id, 'turn.input', { message: input });
-                this.touch(session.id, timestamp);
-            })();
-        }
-        catch (error) {
-            const racedDuplicate = this.byKey(session.id, idempotencyKey);
-            if (racedDuplicate)
-                return { turn: racedDuplicate, duplicate: true };
-            if (isUniqueConstraint(error)) {
-                throw new AgentError('conflict', 'Session already has an active turn.');
-            }
-            throw error;
-        }
-        if (event)
-            this.events.announce(event);
-        return { turn: this.require(id), duplicate: false };
-    }
-    markRunning(id) {
-        return this.transition(id, 'running', 'turn.running', true);
-    }
-    requestCancellation(id) {
-        return this.transition(id, 'cancelling', 'turn.cancelling');
-    }
-    complete(id, result) {
-        return this.terminal(id, 'completed', result, null, 'turn.completed');
-    }
-    fail(id, failure) {
-        return this.terminal(id, 'failed', null, failure, 'turn.failed');
-    }
-    cancel(id) {
-        return this.terminal(id, 'cancelled', null, null, 'turn.cancelled');
-    }
-    interrupt(id, failure) {
-        return this.terminal(id, 'interrupted', null, failure, 'turn.interrupted');
-    }
-    get(id) {
-        const row = this.database.prepare('SELECT * FROM turns WHERE id = ?').get(requireId(id, 'turn id'));
-        return row ? turnFromRow(row) : null;
-    }
-    require(id) {
-        const turn = this.get(id);
-        if (!turn)
-            throw new AgentError('not_found', `Turn not found: ${id}`);
-        return turn;
-    }
-    list(sessionId) {
-        this.sessions.require(sessionId);
-        return this.database.prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC')
-            .all(sessionId).map(turnFromRow);
-    }
-    active(sessionId) {
-        const row = this.database.prepare(`
-      SELECT * FROM turns WHERE session_id = ? AND ${ACTIVE_SQL} ORDER BY created_at DESC LIMIT 1
-    `).get(sessionId);
-        return row ? turnFromRow(row) : null;
-    }
-    history(sessionId, beforeTurnId) {
-        const messages = [];
-        for (const turn of this.list(sessionId)) {
-            if (turn.id === beforeTurnId)
-                break;
-            messages.push(turn.input);
-            for (const event of this.events.forTurn(turn.id)) {
-                const message = isObject(event.data.message) ? event.data.message : null;
-                if (event.type === 'message' && message)
-                    messages.push(message);
-            }
-        }
-        return messages;
-    }
-    recoverInterrupted() {
-        const rows = this.database.prepare(`SELECT * FROM turns WHERE ${ACTIVE_SQL}`).all();
-        for (const row of rows) {
-            this.interrupt(turnFromRow(row).id, {
-                code: 'process_restarted',
-                message: 'The owning process restarted before the driver settled.',
-                details: {},
-            });
-        }
-        return rows.length;
-    }
-    byKey(sessionId, key) {
-        const row = this.database.prepare('SELECT * FROM turns WHERE session_id = ? AND idempotency_key = ?')
-            .get(sessionId, key);
-        return row ? turnFromRow(row) : null;
-    }
-    transition(id, status, type, started = false) {
-        const turn = this.require(id);
-        const timestamp = this.now();
-        let event;
-        this.database.transaction(() => {
-            this.database.prepare(`UPDATE turns SET status = ?, started_at = COALESCE(started_at, ?) WHERE id = ?`)
-                .run(status, started ? timestamp : turn.startedAt, turn.id);
-            event = this.events.write(turn.sessionId, turn.id, type, {});
-            this.touch(turn.sessionId, timestamp);
-        })();
-        if (event)
-            this.events.announce(event);
-        return this.require(turn.id);
-    }
-    terminal(id, status, result, error, type) {
-        const turn = this.require(id);
-        if (TERMINAL.has(turn.status))
-            return turn;
-        const timestamp = this.now();
-        let event;
-        this.database.transaction(() => {
-            this.database.prepare(`
-        UPDATE turns SET status = ?, result_json = ?, error_json = ?, completed_at = ? WHERE id = ?
-      `).run(status, result && JSON.stringify(result), error && JSON.stringify(error), timestamp, turn.id);
-            const data = error ? { error: error } : {};
-            event = this.events.write(turn.sessionId, turn.id, type, data);
-            this.touch(turn.sessionId, timestamp);
-        })();
-        if (event)
-            this.events.announce(event);
-        return this.require(turn.id);
-    }
-    touch(sessionId, timestamp) {
-        this.database.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(timestamp, sessionId);
-    }
-}
-function isUniqueConstraint(error) {
-    return Boolean(error
-        && typeof error === 'object'
-        && 'code' in error
-        && String(error.code).startsWith('SQLITE_CONSTRAINT'));
-}

package/docs/DRIVERS.md

@@ -1,72 +0,0 @@
-# Agent drivers
-
-Drivers connect durable Agents state to a native or hosted runtime. They are
-registered by the embedding process and selected by `definition.driver.id`.
-
-```ts
-import { defineDriver } from '@amalgm/agents';
-
-export default defineDriver({
-  id: 'my-runtime',
-  async run(request, context) {
-    context.signal.throwIfAborted();
-    context.emit({ type: 'text.delta', data: { text: 'Working…' } });
-
-    return {
-      driverSessionId: request.driverSessionId ?? 'native-session-id',
-      message: {
-        role: 'assistant',
-        parts: [{ type: 'text', text: 'Done.' }],
-      },
-      metadata: { provider: 'example' },
-    };
-  },
-});
-```
-
-## Request
-
-`DriverRunRequest` includes:
-
-- the immutable `AgentRevision`;
-- the durable session and current turn;
-- ordered completed history before this turn;
-- the accepted input; and
-- the opaque `driverSessionId` returned by an earlier turn.
-
-Drivers do not receive a database handle. They resolve Toolbox actions,
-credentials, skills, files, and native processes through dependencies supplied
-by their host.
-
-## Events and results
-
-Call `context.emit` for streaming or structured observations. The event is
-committed before the call returns. Use type `message` with an assistant
-`AgentMessage` for a durable output message; other event names are driver-owned
-and their data must be JSON.
-
-A final returned `message` is appended once before turn completion. Returned
-`driverSessionId` replaces the prior opaque value for future continuation.
-
-## Cancellation and limits
-
-Drivers must observe `context.signal` and stop their underlying process or
-request. The service records cancellation intent before aborting the signal.
-Input and event sizes are bounded. A driver that emits invalid or oversized
-data fails the turn explicitly.
-
-The in-process boundary cannot forcibly kill an uncooperative driver. Process
-drivers should own their child process and terminate it when signalled.
-
-## Loading drivers in CLIs
-
-Compile driver modules to JavaScript and export either an `AgentDriver`, a
-`driver` value, or a zero-argument factory:
-
-```bash
-AMALGM_AGENT_DRIVERS=./dist/codex-driver.js amalgm-agents-rest
-amalgm-agents --drivers ./dist/codex-driver.js talk reviewer "Review this"
-```
-
-Multiple modules are comma-separated. Secret values belong in the host's
-credential resolver, not in agent definitions or driver module arguments.