@amalgm/agents 0.1.0

package/dist/cli/run.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv?: string[]): Promise<number>;

package/dist/cli/run.js

@@ -0,0 +1,38 @@
+import { asAgentError } from '../errors.js';
+import { parseArgs } from './args.js';
+import { runAgentCommand } from './agent-commands.js';
+import { writeJson } from './files.js';
+import { HELP } from './help.js';
+import { openAgents } from './open.js';
+import { runSessionCommand, runTalkCommand } from './session-commands.js';
+export async function runCli(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.flags.has('help') || args.words.length === 0) {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    let agents;
+    try {
+        agents = await openAgents(args);
+        const command = args.words[0];
+        const value = command === 'agent'
+            ? runAgentCommand(agents, args)
+            : command === 'session'
+                ? await runSessionCommand(agents, args)
+                : command === 'talk'
+                    ? await runTalkCommand(agents, args)
+                    : undefined;
+        if (value === undefined)
+            throw new Error(`Unknown command: ${String(command)}`);
+        writeJson(value);
+        return 0;
+    }
+    catch (error) {
+        const normalized = asAgentError(error);
+        process.stderr.write(`${normalized.code}: ${normalized.message}\n`);
+        return 1;
+    }
+    finally {
+        await agents?.close();
+    }
+}

package/dist/cli/session-commands.d.ts

@@ -0,0 +1,4 @@
+import type { Agents } from '../agents.js';
+import type { ParsedArgs } from './args.js';
+export declare function runSessionCommand(agents: Agents, args: ParsedArgs): Promise<unknown>;
+export declare function runTalkCommand(agents: Agents, args: ParsedArgs): Promise<unknown>;

package/dist/cli/session-commands.js

@@ -0,0 +1,54 @@
+import { AgentError } from '../errors.js';
+import { enabled, flag } from './args.js';
+export async function runSessionCommand(agents, args) {
+    const [, action, first, second] = args.words;
+    if (action === 'list') {
+        return { sessions: agents.listSessions(flag(args, 'agent'), enabled(args, 'include-archived')) };
+    }
+    if (action === 'start' && first) {
+        const sessionId = flag(args, 'id');
+        const revisionId = flag(args, 'revision');
+        return { session: agents.startSession({
+                agentId: first,
+                ...(sessionId ? { sessionId } : {}),
+                ...(revisionId ? { revisionId } : {}),
+            }) };
+    }
+    if (action === 'show' && first) {
+        const session = agents.getSession(first);
+        if (!session)
+            throw new AgentError('not_found', `Session not found: ${first}`);
+        return { session, turns: agents.listTurns(first), events: agents.listEvents(first) };
+    }
+    if (action === 'events' && first) {
+        return { events: agents.listEvents(first, Number(flag(args, 'after') || 0)) };
+    }
+    if (action === 'send' && first && second) {
+        const idempotencyKey = flag(args, 'key');
+        return { turn: await agents.send(first, {
+                message: second,
+                ...(idempotencyKey ? { idempotencyKey } : {}),
+            }) };
+    }
+    if (action === 'cancel' && first)
+        return { turn: agents.cancelSession(first) };
+    if (action === 'archive' && first)
+        return { session: agents.archiveSession(first) };
+    throw new AgentError('invalid_input', 'Unknown or incomplete session command. Run with --help.');
+}
+export async function runTalkCommand(agents, args) {
+    const [, agentId, message] = args.words;
+    if (!agentId || !message)
+        throw new AgentError('invalid_input', 'talk requires agent id and message.');
+    const sessionId = flag(args, 'session');
+    const idempotencyKey = flag(args, 'key');
+    const call = agents.talk(agentId, {
+        message,
+        ...(sessionId ? { sessionId } : {}),
+        ...(idempotencyKey ? { idempotencyKey } : {}),
+    });
+    if (enabled(args, 'background')) {
+        return { session: call.session, turn: call.turn, duplicate: call.duplicate };
+    }
+    return { session: call.session, turn: await call.completion, duplicate: call.duplicate };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export { parseArgs } from './cli/args.js';
+export { runCli } from './cli/run.js';

package/dist/cli.js

@@ -0,0 +1,2 @@
+export { parseArgs } from './cli/args.js';
+export { runCli } from './cli/run.js';

package/dist/database.d.ts

@@ -0,0 +1,9 @@
+import Database from 'better-sqlite3';
+import type { AgentsOptions } from './types.js';
+export interface OpenedDatabase {
+    database: Database.Database;
+    databasePath: string;
+    close(): void;
+}
+export declare function defaultStateDir(): string;
+export declare function openDatabase(options?: AgentsOptions): OpenedDatabase;

package/dist/database.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveProductStateDir } from '@amalgm/core/identity';
+import Database from 'better-sqlite3';
+import { migrate } from './schema.js';
+export function defaultStateDir() {
+    return resolveProductStateDir({
+        product: 'agents',
+        primitive: 'agents',
+        env: process.env,
+        homedir: path.join(os.homedir(), '.amalgm'),
+    });
+}
+export function openDatabase(options = {}) {
+    const stateDir = path.resolve(options.stateDir || defaultStateDir());
+    const databasePath = path.resolve(options.databasePath || path.join(stateDir, 'agents.db'));
+    fs.mkdirSync(path.dirname(databasePath), { recursive: true, mode: 0o700 });
+    const database = new Database(databasePath);
+    database.pragma('journal_mode = WAL');
+    database.pragma('foreign_keys = ON');
+    database.pragma('busy_timeout = 5000');
+    migrate(database);
+    let closed = false;
+    return {
+        database,
+        databasePath,
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            database.close();
+        },
+    };
+}

package/dist/definition.d.ts

@@ -0,0 +1,4 @@
+import type { AgentDefinition, AgentDefinitionInput, AgentPatch } from './types.js';
+export declare function normalizeDefinition(input: AgentDefinitionInput): AgentDefinition;
+export declare function patchDefinition(current: AgentDefinition, patch: AgentPatch): AgentDefinition;
+export declare function definitionHash(definition: AgentDefinition): string;

package/dist/definition.js

@@ -0,0 +1,93 @@
+import crypto from 'node:crypto';
+import { AgentError } from './errors.js';
+import { canonicalJson, isObject } from './json.js';
+import { requireId } from './ids.js';
+function text(value, fallback = '') {
+    return typeof value === 'string' ? value.trim() : fallback;
+}
+function strings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map((item) => text(item)).filter(Boolean))];
+}
+function object(value) {
+    if (!isObject(value))
+        return {};
+    return JSON.parse(JSON.stringify(value));
+}
+function driver(value) {
+    if (typeof value === 'string')
+        return { id: requireId(value, 'driver.id'), config: {} };
+    if (!isObject(value))
+        throw new AgentError('invalid_input', 'driver is required.');
+    return { id: requireId(value.id, 'driver.id'), config: object(value.config) };
+}
+function model(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!isObject(value))
+        throw new AgentError('invalid_input', 'model must be an object or null.');
+    const id = text(value.id);
+    if (!id)
+        throw new AgentError('invalid_input', 'model.id is required.');
+    return { id, settings: object(value.settings) };
+}
+export function normalizeDefinition(input) {
+    if (!isObject(input))
+        throw new AgentError('invalid_input', 'agent definition must be an object.');
+    const id = requireId(input.id, 'id');
+    const name = text(input.name);
+    if (!name)
+        throw new AgentError('invalid_input', 'name is required.');
+    const resources = isObject(input.resources) ? input.resources : {};
+    const toolbox = isObject(input.toolbox) ? input.toolbox : {};
+    const workspace = isObject(input.workspace) ? input.workspace : {};
+    return {
+        id,
+        name,
+        description: text(input.description),
+        instructions: typeof input.instructions === 'string' ? input.instructions.trim() : '',
+        driver: driver(input.driver),
+        model: model(input.model),
+        authRef: text(input.authRef) || null,
+        resources: {
+            files: strings(resources.files),
+            skills: strings(resources.skills),
+            subagents: strings(resources.subagents).map((item) => requireId(item, 'resources.subagents[]')),
+        },
+        toolbox: {
+            toolIds: strings(toolbox.toolIds),
+            actionIds: strings(toolbox.actionIds),
+        },
+        workspace: { cwd: text(workspace.cwd) || null },
+        metadata: object(input.metadata),
+    };
+}
+export function patchDefinition(current, patch) {
+    const nextDriver = patch.driver === undefined
+        ? current.driver
+        : isObject(patch.driver)
+            ? { ...current.driver, ...patch.driver, config: patch.driver.config ?? current.driver.config }
+            : patch.driver;
+    return normalizeDefinition({
+        ...current,
+        ...patch,
+        id: current.id,
+        driver: nextDriver,
+        model: patch.model === undefined ? current.model : patch.model,
+        resources: patch.resources === undefined
+            ? current.resources
+            : { ...current.resources, ...patch.resources },
+        toolbox: patch.toolbox === undefined
+            ? current.toolbox
+            : { ...current.toolbox, ...patch.toolbox },
+        workspace: patch.workspace === undefined
+            ? current.workspace
+            : { ...current.workspace, ...patch.workspace },
+    });
+}
+export function definitionHash(definition) {
+    return crypto.createHash('sha256')
+        .update(canonicalJson(definition))
+        .digest('hex');
+}

package/dist/drivers.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,25 @@
+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/errors.d.ts

@@ -0,0 +1,9 @@
+import type { JsonObject } from './types.js';
+export type AgentErrorCode = 'invalid_input' | 'not_found' | 'conflict' | 'deleted' | 'driver_unavailable' | 'too_large' | 'cancelled' | 'internal';
+export declare class AgentError extends Error {
+    readonly code: AgentErrorCode;
+    readonly details: JsonObject;
+    readonly status: number;
+    constructor(code: AgentErrorCode, message: string, details?: JsonObject);
+}
+export declare function asAgentError(error: unknown): AgentError;

package/dist/errors.js

@@ -0,0 +1,28 @@
+const statusByCode = {
+    invalid_input: 400,
+    not_found: 404,
+    conflict: 409,
+    deleted: 410,
+    driver_unavailable: 503,
+    too_large: 413,
+    cancelled: 409,
+    internal: 500,
+};
+export class AgentError extends Error {
+    code;
+    details;
+    status;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'AgentError';
+        this.code = code;
+        this.details = details;
+        this.status = statusByCode[code];
+    }
+}
+export function asAgentError(error) {
+    if (error instanceof AgentError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    return new AgentError('internal', message);
+}

package/dist/event-store.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,50 @@
+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/agent-routes.d.ts

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

package/dist/http/agent-routes.js

@@ -0,0 +1,40 @@
+import { AgentError } from '../errors.js';
+export async function routeAgents(context) {
+    const [resource, id, child] = context.path;
+    if (resource !== 'agents')
+        return false;
+    if (!id && context.method === 'GET') {
+        const includeDeleted = context.url.searchParams.get('include_deleted') === 'true';
+        context.json(200, { agents: context.agents.listAgents(includeDeleted) });
+        return true;
+    }
+    if (!id && context.method === 'POST') {
+        const body = await context.body();
+        context.json(201, { agent: context.agents.createAgent(body) });
+        return true;
+    }
+    if (!id)
+        throw new AgentError('not_found', 'Route not found.');
+    if (child)
+        return false;
+    if (context.method === 'GET') {
+        const includeDeleted = context.url.searchParams.get('include_deleted') === 'true';
+        const agent = context.agents.getAgent(id, includeDeleted);
+        if (!agent)
+            throw new AgentError('not_found', `Agent not found: ${id}`);
+        context.json(200, { agent });
+        return true;
+    }
+    if (context.method === 'PATCH') {
+        const body = await context.body();
+        context.json(200, {
+            agent: context.agents.updateAgent(id, body),
+        });
+        return true;
+    }
+    if (context.method === 'DELETE') {
+        context.json(200, { agent: context.agents.deleteAgent(id) });
+        return true;
+    }
+    return false;
+}

package/dist/http/request.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type BearerGuardVerdict } from '@amalgm/core/transport';
+export declare function readJson(request: IncomingMessage, limit: number): Promise<Record<string, unknown>>;
+export declare function sendJson(response: ServerResponse, status: number, value: unknown): void;
+export declare function guardRequest(request: IncomingMessage, token?: string): BearerGuardVerdict;

package/dist/http/request.js

@@ -0,0 +1,40 @@
+import { timingSafeEqual } from 'node:crypto';
+import { guardBearerRequest } from '@amalgm/core/transport';
+import { AgentError } from '../errors.js';
+import { isObject } from '../json.js';
+export async function readJson(request, limit) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit)
+            throw new AgentError('too_large', `Request body exceeds ${limit} bytes.`);
+        chunks.push(buffer);
+    }
+    if (size === 0)
+        return {};
+    try {
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (!isObject(value))
+            throw new Error('not an object');
+        return value;
+    }
+    catch {
+        throw new AgentError('invalid_input', 'Request body must be a JSON object.');
+    }
+}
+export function sendJson(response, status, value) {
+    const body = JSON.stringify(value);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+        'cache-control': 'no-store',
+    });
+    response.end(body);
+}
+export function guardRequest(request, token) {
+    if (!token)
+        return { ok: true };
+    return guardBearerRequest({ headers: request.headers, expectedToken: token, timingSafeEqual });
+}

package/dist/http/server.d.ts

@@ -0,0 +1,2 @@
+import type { RestServer, RestServerOptions } from '../http-types.js';
+export declare function createRestServer(options?: RestServerOptions): RestServer;

package/dist/http/server.js

@@ -0,0 +1,82 @@
+import http from 'node:http';
+import { Agents } from '../agents.js';
+import { asAgentError } from '../errors.js';
+import { routeAgents } from './agent-routes.js';
+import { guardRequest, readJson, sendJson } from './request.js';
+import { routeSessions } from './session-routes.js';
+import { streamEvents } from './stream.js';
+export function createRestServer(options = {}) {
+    const agents = options.agents || new Agents(options);
+    const owned = !options.agents;
+    const bodyLimit = options.bodyLimitBytes || 512_000;
+    const server = http.createServer((request, response) => {
+        void dispatch(request, response).catch((error) => {
+            if (response.headersSent) {
+                response.destroy(error instanceof Error ? error : undefined);
+                return;
+            }
+            const normalized = asAgentError(error);
+            sendJson(response, normalized.status, {
+                error: { code: normalized.code, message: normalized.message, details: normalized.details },
+            });
+        });
+    });
+    async function dispatch(request, response) {
+        const url = new URL(request.url || '/', 'http://localhost');
+        if (url.pathname === '/healthz') {
+            sendJson(response, 200, agents.health());
+            return;
+        }
+        const verdict = guardRequest(request, options.token);
+        if (!verdict.ok) {
+            response.writeHead(verdict.status, {
+                ...verdict.headers,
+                'content-length': Buffer.byteLength(verdict.body),
+            });
+            response.end(verdict.body);
+            return;
+        }
+        const path = url.pathname.split('/').filter(Boolean);
+        if (path.shift() !== 'v1') {
+            sendJson(response, 404, { error: { code: 'not_found', message: 'Route not found.' } });
+            return;
+        }
+        if (path[0] === 'sessions' && path[2] === 'events' && path[3] === 'stream' && request.method === 'GET') {
+            streamEvents(agents, path[1] || '', request, response, Number(url.searchParams.get('after') || 0));
+            return;
+        }
+        const context = {
+            agents,
+            method: request.method || 'GET',
+            path,
+            url,
+            body: () => readJson(request, bodyLimit),
+            json: (status, value) => sendJson(response, status, value),
+        };
+        if (await routeAgents(context) || await routeSessions(context))
+            return;
+        sendJson(response, 404, { error: { code: 'not_found', message: 'Route not found.' } });
+    }
+    return {
+        agents,
+        server,
+        listen(port = 0, host = '127.0.0.1') {
+            return new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(port, host, () => {
+                    server.removeListener('error', reject);
+                    resolve(server.address());
+                });
+            });
+        },
+        async close() {
+            await new Promise((resolve, reject) => {
+                if (!server.listening)
+                    return resolve();
+                server.close((error) => error ? reject(error) : resolve());
+            });
+            if (owned)
+                await agents.close();
+        },
+    };
+}

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

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

package/dist/http/session-routes.js

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,3 @@
+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;