@amalgm/agents 0.1.2 → 0.2.0

package/docs/DATA_MODEL.md

@@ -1,56 +1,17 @@
-# Persistence and recovery
+# Persistence
 
 The default database is `agents.db` inside the state directory resolved by
-`@amalgm/core/identity`: `AMALGM_AGENTS_DIR` verbatim when set, otherwise
-`$AMALGM_DIR/agents`, otherwise the scoped layout
-`~/.amalgm/users/local/agents`. Set `stateDir` or `databasePath` to relocate
-it directly.
+`@amalgm/core/identity`: `AMALGAM_AGENTS_DIR` verbatim when set, otherwise
+`$AMALGAM_DIR/agents`, otherwise `~/.amalgm/users/local/agents`.
 
-## Tables
+The registry has two tables:
 
 | Table | Role |
 |---|---|
 | `agents` | stable identity, current revision pointer, tombstone |
 | `agent_revisions` | immutable normalized definitions |
-| `sessions` | pinned revision and opaque driver session id |
-| `turns` | accepted input and execution outcome |
-| `session_events` | ordered append-only execution observations |
-
-Foreign keys prevent orphan sessions, turns, and events. SQLite WAL mode and a
-five-second busy timeout support multiple read-oriented surfaces while one
-service owns mutations.
 
 Repeating the current definition is idempotent. Returning to content used by
-an earlier revision creates a new revision number so the definition timeline
-remains complete and append-only.
-
-## Turn states
-
-```text
-queued → running → completed
-             ├──→ failed
-             ├──→ cancelling → cancelled
-             └──→ interrupted
-```
-
-`queued`, `running`, and `cancelling` are non-terminal. At service startup they
-become `interrupted`, because the previous process may have completed external
-side effects before dying. The service never guesses and never automatically
-replays uncertain work.
-
-## Idempotency
-
-`idempotencyKey` is unique within a session. Repeating a key returns its
-existing turn and does not invoke the driver again. Callers should derive it
-from their durable request identity instead of generating a new value on every
-retry.
-
-## Events
-
-Every event receives the next integer sequence within its session. SSE first
-reads committed events after the requested sequence, then subscribes to newly
-committed events. Reconnecting with the last SSE id therefore closes the gap
-without polling or losing events.
-
-Events are facts, not mutable projections. User interfaces derive streaming
-text, messages, tool activity, and status from the ledger.
+an earlier revision creates a new revision number, keeping the definition
+timeline complete and append-only. Conversations and turns are stored only by
+Chat.

package/docs/DEFINITIONS.md

@@ -37,13 +37,13 @@ products.
 
 `id` is a stable machine identity: 1–128 lowercase letters, numbers, dots,
 underscores, or hyphens. Renaming `name` never changes it. Deleted ids remain
-reserved so historical sessions cannot be confused with a new agent.
+reserved so recorded revision identities cannot be reused.
 
 ## Revisions
 
 The normalized complete definition is hashed. An edit with equal content keeps
 the current revision. Any changed field creates a new immutable revision.
-Sessions always retain the revision selected at creation.
+Chat records the exact revision selected for every prepared execution.
 
 ## PATCH behavior
 
@@ -61,5 +61,5 @@ authoritative and de-duplicated. Set nullable fields such as `model` or
 - `resources.skills` and `resources.files` are resolved by the host.
 - `resources.subagents` describes intended relationships; the host still
   authorizes every agent-to-agent call.
-- `driver.config` is non-secret runtime configuration interpreted only by the
-  selected driver.
+- `driver.config` is non-secret harness configuration interpreted only by
+  Chat's host runtime.

package/docs/ENGINE_INTEGRATION.md

@@ -1,74 +1,29 @@
-# Amalgm Engine integration
+# Shell integration
 
-Engine remains the composition root. This package becomes the canonical agent
-registry and session ledger; Engine supplies adapters for everything outside
-that domain.
+Shell is the composition root. Agents supplies the canonical registry and Chat
+supplies the canonical conversation runtime.
 
-## Existing ownership to replace
+## Resolver boundary
 
-| Current Engine area | Destination |
-|---|---|
-| `amalgm-mcp/agents/store.js` agent rows | `AgentStore` through `Agents` |
-| `amalgm-mcp/agent-config/*` normalized config | immutable agent definitions |
-| `amalgm-mcp/agents/talk.js` durable sessions and logs | Agents sessions, turns, events |
-| `amalgm-mcp/agents/tools.js` | packaged MCP tools |
-| `amalgm-mcp/agents/rest.js` and route wiring | packaged REST adapter |
-| `chat-core` native runtime execution | Engine-supplied `AgentDriver` implementations |
-| Toolbox lookup and MCP resolution | `@amalgm/tools` adapter inside drivers |
-| credential adapter | `authRef` resolver inside drivers |
-| Supabase Chat session creation | Chat/cloud adapter observing Agents events |
+Shell gives Chat a resolver with one job: map an installed agent id and optional
+revision id to `agents.getAgentRevision(agentId, revisionId)`, then project that
+immutable definition into Chat's execution contract. The resolver never writes
+either product's store.
 
-Agent bundles currently mix agents, apps, automations, and tool bindings. That
-cross-product packaging concern should remain outside this repository. A bundle
-installer may call each product's public apply method.
+Chat owns the conversation, accepted prompt, provider session, ordered durable
+updates, transcript, usage, reconnect, and interrupt lifecycle. Agents owns the
+identity and revision selected by that execution. Neither product imports the
+other's database.
 
-## Required driver adapter
+Tool and action ids are resolved through `@amalgm/tools`; `authRef` is resolved
+through the credential boundary. The resulting concrete values are frozen by
+Chat before it accepts a turn.
 
-Engine should implement one driver per native harness identity (`codex`,
-`claude_code`, `opencode`, `pi`, and others). A driver translates the immutable
-revision into chat-core's runtime envelope, resolves `authRef`, projects the
-Toolbox loadout, forwards normalized streaming events, and returns the native
-session id for continuation.
+## Integration checks
 
-Drivers must not write Agents SQLite or invent another conversation log.
-
-## Chat boundary
-
-Engine may associate an Agents session id with a Chat record. Chat owns title,
-participants, layout, read state, and cloud presentation. Agents owns pinned
-revision, accepted inputs, driver execution, and events. Synchronization is an
-adapter subscribed to committed Agents events; neither database is imported by
-the other product.
-
-## One-time migration
-
-1. Stop the legacy agent mutation and talk surfaces.
-2. Read each legacy agent plus its `agent_config` as one complete definition.
-3. Map `baseHarnessId` to `driver.id`, model fields to `model`, auth mode to an
-   `authRef`, and legacy loadout ids to `toolbox.toolIds`.
-4. Create missing agents and update existing agents through `Agents`.
-5. Import local conversation JSONL as archived sessions only when its agent and
-   chronological message identity are unambiguous; otherwise retain it as a
-   legacy read-only export.
-6. Start packaged REST and MCP adapters behind Engine's existing authenticated
-   routes.
-7. Enable native drivers and verify continuation against real harness sessions.
-8. Delete the legacy registry, config, talk, REST, and MCP implementations only
-   after parity and rollback checks pass.
-
-Migration must be idempotent. Record the source identity and migration version
-outside agent metadata or in a namespaced metadata field; never manufacture a
-new revision on equal reruns.
-
-## Integration tests
-
-Before switchover, run:
-
-- legacy agent create/update/delete through the UI against `Agents`;
-- a session created on revision 1, followed by an agent edit and continuation;
-- native resume after Engine restart;
-- Toolbox loadout enforcement through `@amalgm/tools`;
-- provider authentication failure without credential persistence in Agents;
-- agent-to-agent background calls and cancellation;
-- Chat projection without Chat becoming the session source of truth; and
-- one-time migration twice with byte-for-byte equal resulting definitions.
+- create, update, list, delete, and exact revision resolution use `Agents`;
+- editing an agent never changes a Chat execution that already names a revision;
+- Toolbox and credential references are authorized during preparation;
+- provider restart, reconnect, and interrupt are handled only by Chat; and
+- agent-to-agent interaction creates or joins a Chat conversation through the
+  same prepared-execution protocol as the UI.

package/docs/MCP.md

@@ -3,22 +3,6 @@
 `amalgm-agents-mcp` is the standalone stdio server. `createMcpServer` from
 `@amalgm/agents/mcp` embeds the same server.
 
-It exposes seven tools:
-
-| Tool | Purpose |
-|---|---|
-| `agents_list` | List persistent agents |
-| `agents_get` | Inspect one agent |
-| `agents_create` | Create an agent |
-| `agents_update` | Edit an agent |
-| `agents_delete` | Delete an agent while retaining session history |
-| `agents_get_conversation` | Inspect a durable agent session |
-| `talk_to_agent` | Start or continue an agent session |
-
-`talk_to_agent` accepts the legacy `agent`, `conversation_id`, `description`,
-and `prompt` fields. `agent_id`, `session_id`, and structured `message` are
-also accepted. It returns `conversation_id` as the durable Agents session ID,
-not a Chat ID. Use `run_in_background` for long work.
-
-All handlers call the injected `Agents` service. MCP contains no second
-registry, transcript, execution engine, or routing subsystem.
+It exposes five registry tools: `agents_list`, `agents_get`, `agents_create`,
+`agents_update`, and `agents_delete`. Their handlers call the injected
+`Agents` service; MCP contains no second registry and no conversation runtime.

package/docs/REST.md

@@ -1,91 +1,20 @@
 # REST API
 
-Create an embeddable server with `createRestServer` from
-`@amalgm/agents/http`, or run `amalgm-agents-rest`.
+Create an embeddable server with `createRestServer` from `@amalgm/agents/http`,
+or run `amalgm-agents-rest`. The CLI binds `127.0.0.1:4317` by default.
 
-The CLI default is `127.0.0.1:4317`. If a token is configured, all `/v1`
-requests require the token via `Authorization: Bearer <token>` (scheme
-case-insensitive) or the `x-amalgm-runtime-token` header. A missing or wrong
-token receives the kernel's canonical 401 from `@amalgm/core/transport`,
-compared in constant time. `/healthz` is a minimal unauthenticated liveness
-response. JSON bodies default to a 512 KB limit.
-
-## Agent configuration
-
-| Method | Path | Result |
-|---|---|---|
-| `GET` | `/agent-config` | List normalized configs from live agent revisions |
-| `POST` | `/agent-config/get` | Read `{ agent_id }` |
-| `POST` | `/agent-config/update` | Atomically apply `{ agent_id, config }` |
-| `POST` | `/agent-config/import-native` | Import safe native fields for `{ agent_id, replace? }` |
-
-Set `nativeHomeDir` when embedding the server or `--native-home`/
-`AMALGM_NATIVE_HOME` with the REST binary. Native import intentionally ignores
-auth files, secrets, and MCP server configuration.
-
-## Agents
-
-| Method | Path | Result |
-|---|---|---|
-| `GET` | `/v1/agents` | List live agents |
-| `POST` | `/v1/agents` | Create from complete body |
-| `GET` | `/v1/agents/:id` | Read current definition |
-| `PATCH` | `/v1/agents/:id` | Merge a definition patch |
-| `DELETE` | `/v1/agents/:id` | Tombstone agent |
-
-Use `?include_deleted=true` on list or get to include tombstones.
-
-## Sessions
+When configured, authentication uses `Authorization: Bearer <token>` or the
+`x-amalgm-runtime-token` header. `/healthz` is unauthenticated. JSON bodies
+default to a 512 KB limit.
 
 | Method | Path | Result |
 |---|---|---|
-| `GET` | `/v1/sessions` | List sessions |
-| `POST` | `/v1/sessions` | Start `{ agentId, revisionId?, sessionId?, metadata? }` |
-| `GET` | `/v1/sessions/:id` | Read session |
-| `DELETE` | `/v1/sessions/:id` | Archive inactive session |
-| `GET` | `/v1/sessions/:id/turns` | List turns |
-| `GET` | `/v1/sessions/:id/events` | List ordered events |
-| `POST` | `/v1/sessions/:id/messages` | Send a turn |
-| `POST` | `/v1/sessions/:id/cancel` | Cancel active turn |
-
-List filters are `agent_id` and `include_archived=true`. Event pagination uses
-`after` and `limit` (maximum 1000).
-
-Send a message:
-
-```json
-{
-  "message": "Review the current diff.",
-  "idempotencyKey": "review-001",
-  "wait": true
-}
-```
-
-`message` may also be a structured `AgentMessage`. `wait: false` returns `202`
-after durable acceptance; otherwise the response waits for a terminal turn.
-
-## Server-sent events
-
-Connect to:
-
-```text
-GET /v1/sessions/:id/events/stream?after=<last-sequence>
-```
-
-The stream sends committed backlog first and then live events. SSE `id` equals
-the session sequence. Reconnect with the last seen id as `after`. Heartbeat
-comments are sent every 15 seconds.
-
-## Errors
-
-Errors use the HTTP status associated with `AgentError`:
-
-```json
-{
-  "error": {
-    "code": "conflict",
-    "message": "Session already has an active turn.",
-    "details": {}
-  }
-}
-```
+| `GET` | `/v1/agents` | List available agents |
+| `POST` | `/v1/agents` | Create from a complete definition |
+| `GET` | `/v1/agents/:id` | Read the current definition |
+| `PATCH` | `/v1/agents/:id` | Apply a definition patch |
+| `DELETE` | `/v1/agents/:id` | Tombstone an identity |
+
+Use `?include_deleted=true` on list or get to include tombstones. The same
+server also exposes agent configuration, installed skills, and bundle routes
+documented by their SDK modules. It exposes no conversation routes.

package/docs/SDK.md

@@ -1,72 +1,23 @@
 # SDK reference
 
-The `Agents` class is the sole public behavior boundary. All mutations are
-durable before a method returns.
-
-## Construction
+`Agents` is the public behavior boundary for the local agent registry. Every
+mutation is durable before it returns.
 
 ```ts
-const agents = new Agents({
-  stateDir: './state',
-  drivers: [codexDriver],
-  maxInputBytes: 256_000,
-  maxEventBytes: 256_000,
-  turnTimeoutMs: 600_000,
-});
+const agents = new Agents({ stateDir: './state' });
 ```
 
-`databasePath` overrides the database location directly. `turnTimeoutMs: 0`
-disables the service timeout. Call `close()` to abort owned executions, wait
-for them to settle, and close SQLite.
-
-## Agent methods
+`databasePath` overrides the database location directly. Call `close()` when
+the embedding process releases the registry.
 
 | Method | Behavior |
 |---|---|
-| `createAgent(definition)` | Create identity and revision 1; conflicts on any reused id |
-| `updateAgent(id, patch)` | Merge a patch and apply the resulting definition |
-| `deleteAgent(id)` | Tombstone the identity while retaining history |
+| `createAgent(definition)` | Create an identity and immutable revision 1 |
+| `updateAgent(id, patch)` | Apply a patch, appending a revision when content changes |
+| `deleteAgent(id)` | Tombstone the identity while retaining its revisions |
 | `getAgent(id, includeDeleted?)` | Read the current definition |
-| `listAgents(includeDeleted?)` | List live agents by default |
-
-## Session methods
-
-| Method | Behavior |
-|---|---|
-| `startSession(input)` | Pin a new session to the current or named revision |
-| `talk(agentId, input)` | Start or continue a session, then enqueue a turn |
-| `enqueue(sessionId, input)` | Return immediately with the turn and completion promise |
-| `send(sessionId, input)` | Wait for the turn's terminal state |
-| `cancelSession(id)` | Persist cancellation intent and signal its active driver |
-| `archiveSession(id)` | Archive an inactive session |
-| `listSessions(agentId?, includeArchived?)` | Discover durable sessions |
-| `listTurns(sessionId)` | Read accepted inputs and outcomes |
-| `listEvents(sessionId, after?, limit?)` | Read ordered events |
-
-`enqueue` returns `{ turn, completion, duplicate }`. If an idempotency key was
-already accepted, `duplicate` is true and the original turn is returned.
-
-## Event subscription
-
-```ts
-const unsubscribe = agents.subscribe(session.id, (event) => {
-  console.log(event.sequence, event.type, event.data);
-});
-
-await agents.send(session.id, { message: 'Hello' });
-unsubscribe();
-```
-
-Listeners receive events only after commit. To build a reconnectable consumer,
-read `listEvents(after)` before subscribing and de-duplicate by sequence, as
-the packaged SSE adapter does.
-
-## Errors
-
-Expected failures use `AgentError` with a stable code:
-
-`invalid_input`, `not_found`, `conflict`, `deleted`, `driver_unavailable`,
-`too_large`, or `cancelled`.
+| `listAgents(includeDeleted?)` | List available agents by default |
+| `getAgentRevision(agentId, revisionId?)` | Resolve the current or exact immutable revision |
 
-Driver failures become durable failed turns rather than escaping as transient
-transport errors. Inspect `turn.error` and the session event ledger.
+Expected failures use `AgentError` with stable codes: `invalid_input`,
+`not_found`, `conflict`, `deleted`, and `too_large`.

package/docs/SECURITY.md

@@ -1,38 +1,9 @@
 # Security model
 
-Agents stores executable configuration and conversation history, so its state
-directory should be treated as user-private data.
+Agent definitions contain `authRef`, never credentials. Toolbox ids, skill ids,
+file references, and subagent ids are requests, not authority; Shell resolves
+and authorizes them while preparing a Chat execution.
 
-## Secrets
-
-Agent definitions contain `authRef`, not credentials. Drivers resolve that
-reference at execution time through the host's credential boundary. Do not put
-tokens, cookies, private keys, or passwords in `driver.config`, `metadata`,
-messages, or events.
-
-## Capability references
-
-Toolbox ids and subagent ids are requests, not authority. The composing host
-must resolve them against the caller's allowed Toolbox view and agent policy.
-Agents never infers permission merely because an id appears in a definition.
-
-## REST exposure
-
-The REST CLI binds `127.0.0.1` by default. Configure a bearer token before
-binding to a LAN, container bridge, tunnel, or public interface. The packaged
-server intentionally does not implement browser sessions, CORS, TLS, user
-accounts, or cloud authorization; Engine supplies those outer boundaries.
-
-## Driver trust
-
-Drivers execute inside the hosting process and are trusted code. A driver can
-read its process environment and access the filesystem with that process's
-permissions. Load only reviewed modules. Native process drivers should avoid a
-shell, pass explicit arguments, bound output, and kill their child on abort.
-
-## Stored data
-
-SQLite files are created beneath a mode-`0700` state directory. Application
-packaging and backups must preserve appropriate filesystem permissions.
-Messages and driver events may contain sensitive user content; retention and
-export policies belong to the embedding product.
+The REST CLI binds loopback by default. Configure a bearer token before
+binding it to a shared interface. SQLite state is created beneath a private
+state directory and should be backed up with equivalent file permissions.

package/examples/basic.ts

@@ -1,31 +1,17 @@
-import { Agents, defineDriver, messageText } from '@amalgm/agents';
+import { Agents } from '@amalgm/agents';
 
-const echo = defineDriver({
-  id: 'echo',
-  async run(request) {
-    return {
-      driverSessionId: request.driverSessionId || `echo-${request.session.id}`,
-      message: {
-        role: 'assistant',
-        parts: [{ type: 'text', text: `Echo: ${messageText(request.input)}` }],
-      },
-    };
-  },
-});
+const agents = new Agents({ stateDir: './example-state' });
 
-async function main(): Promise<void> {
-  const agents = new Agents({ stateDir: './example-state', drivers: [echo] });
+try {
   agents.createAgent({
     id: 'reviewer',
     name: 'Reviewer',
-    driver: 'echo',
+    driver: 'codex',
     instructions: 'Review carefully.',
   });
 
-  const call = agents.talk('reviewer', { message: 'Check this design.' });
-  console.log(await call.completion);
-  console.log(agents.listEvents(call.session.id));
-  await agents.close();
+  const revision = agents.getAgentRevision('reviewer');
+  console.log(revision.id, revision.definition);
+} finally {
+  agents.close();
 }
-
-void main();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@amalgm/agents",
-  "version": "0.1.2",
-  "description": "Local-first agent definitions, immutable revisions, and durable sessions.",
+  "version": "0.2.0",
+  "description": "Local-first agent identities, installations, and immutable revisions.",
   "license": "UNLICENSED",
   "private": false,
   "repository": {

package/skills/amalgm-agents/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: amalgm-agents
-description: Create, inspect, edit, delete, and talk to persistent Amalgm agents and their existing sessions. Use when a user wants to manage an agent definition, discover available agents, delegate work to an agent, continue an agent session, or inspect its transcript. Agents are separate from Chat conversations.
+description: Create, inspect, edit, delete, install, and resolve persistent Amalgm agent identities and immutable revisions. Use when a user wants to manage an agent definition or discover available agents.
 ---
 
 # Amalgm Agents
@@ -17,14 +17,5 @@ Use the available Agents MCP tools. If MCP is unavailable, use the equivalent
 5. Keep tool, skill, file, credential, and subagent values as references; do
    not copy those products into the agent definition.
 
-## Talk to an agent
-
-1. Resolve the agent with `agents_list` or `agents_get` when its identity is
-   ambiguous.
-2. Call `talk_to_agent` without a session ID to start a session.
-3. Preserve and return the resulting session ID.
-4. Pass that ID to continue the same session.
-5. Use conversation/session inspection to recover durable results or history.
-6. Use background execution for work likely to outlive one MCP request.
-
-Never create a Chat conversation merely to represent an Agents session.
+To run an agent, resolve its identity here and use Chat. Agents has no
+conversation, execution, transcript, interrupt, or reconnect operation.

package/skills/amalgm-agents/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Amalgm Agents"
-  short_description: "Create, manage, and talk to Amalgm agents"
-  default_prompt: "Use $amalgm-agents to create or talk to an agent."
+  short_description: "Create and manage Amalgm agents"
+  default_prompt: "Use $amalgm-agents to create or manage an agent."

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

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

@@ -1,54 +0,0 @@
-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/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[];
-}