@amalgm/agents 0.2.0 → 0.2.1

package/docs/CLI.md

@@ -3,6 +3,18 @@
 The CLI prints JSON to stdout and errors to stderr. It shares the SDK database;
 there is no CLI-specific registry.
 
+## Global options
+
+| Option | Meaning |
+|---|---|
+| `--state-dir <path>` | Override the Agents state directory |
+| `--drivers <a.js,b.js>` | Load compiled driver modules |
+| `--help` | Print command help |
+
+`AMALGM_AGENT_DRIVERS` supplies the same comma-separated driver list.
+
+## Agent commands
+
 ```bash
 amalgm-agents agent list [--include-deleted]
 amalgm-agents agent show <id> [--include-deleted]
@@ -11,11 +23,39 @@ amalgm-agents agent update <id> <patch.json>
 amalgm-agents agent delete <id>
 ```
 
-Global options are `--state-dir <path>` and `--help`.
+`create` requires an unused id. `update` uses the nested PATCH rules in
+[Definitions](./DEFINITIONS.md).
 
-The REST CLI binds loopback by default:
+## Session commands
+
+```bash
+amalgm-agents session list [--agent <id>] [--include-archived]
+amalgm-agents session start <agent-id> [--id <id>] [--revision <revision-id>]
+amalgm-agents session show <id>
+amalgm-agents session events <id> [--after <sequence>]
+amalgm-agents session send <id> <message> [--key <idempotency-key>]
+amalgm-agents session cancel <id>
+amalgm-agents session archive <id>
+```
+
+`session show` returns the session, turns, and event ledger together.
+
+## Talk shortcut
+
+```bash
+amalgm-agents talk <agent-id> <message> \
+  [--session <session-id>] [--key <idempotency-key>] [--background]
+```
+
+Without `--session`, the command starts one. Foreground waits for a terminal
+turn; background returns the accepted turn immediately.
+
+## Servers
 
 ```bash
 amalgm-agents-rest --host 127.0.0.1 --port 4317 --token "$TOKEN"
-amalgm-agents-mcp --state-dir ./state
+amalgm-agents-mcp --state-dir ./state --drivers ./dist/driver.js
 ```
+
+The REST CLI binds loopback by default. Use a bearer token before deliberately
+binding to any shared interface.

package/docs/DATA_MODEL.md

@@ -1,17 +1,56 @@
-# Persistence
+# Persistence and recovery
 
 The default database is `agents.db` inside the state directory resolved by
-`@amalgm/core/identity`: `AMALGAM_AGENTS_DIR` verbatim when set, otherwise
-`$AMALGAM_DIR/agents`, otherwise `~/.amalgm/users/local/agents`.
+`@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.
 
-The registry has two tables:
+## 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, keeping the definition
-timeline complete and append-only. Conversations and turns are stored only by
-Chat.
+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.

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 recorded revision identities cannot be reused.
+reserved so historical sessions cannot be confused with a new agent.
 
 ## Revisions
 
 The normalized complete definition is hashed. An edit with equal content keeps
 the current revision. Any changed field creates a new immutable revision.
-Chat records the exact revision selected for every prepared execution.
+Sessions always retain the revision selected at creation.
 
 ## 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 harness configuration interpreted only by
-  Chat's host runtime.
+- `driver.config` is non-secret runtime configuration interpreted only by the
+  selected driver.

package/docs/DRIVERS.md

@@ -0,0 +1,72 @@
+# 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.

package/docs/ENGINE_INTEGRATION.md

@@ -1,29 +1,74 @@
-# Shell integration
+# Amalgm Engine integration
 
-Shell is the composition root. Agents supplies the canonical registry and Chat
-supplies the canonical conversation runtime.
+Engine remains the composition root. This package becomes the canonical agent
+registry and session ledger; Engine supplies adapters for everything outside
+that domain.
 
-## Resolver boundary
+## Existing ownership to replace
 
-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.
+| 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 |
 
-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.
+Agent bundle-v2 graph and agent install laws live here. Engine supplies the
+`AgentBundlePort` that exports and installs apps, automations, and tools through
+their public SDKs; neither side imports another product's store.
 
-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.
+## Required driver adapter
 
-## Integration checks
+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.
 
-- 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.
+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.

package/docs/MCP.md

@@ -3,6 +3,22 @@
 `amalgm-agents-mcp` is the standalone stdio server. `createMcpServer` from
 `@amalgm/agents/mcp` embeds the same server.
 
-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.
+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.

package/docs/REST.md

@@ -1,20 +1,103 @@
 # REST API
 
-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.
+Create an embeddable server with `createRestServer` from
+`@amalgm/agents/http`, or run `amalgm-agents-rest`.
 
-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.
+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.
+
+## Agent bundles
+
+| Method | Path | Result |
+|---|---|---|
+| `GET` | `/agent-bundles` | Read bundle-v2 capability and available agent heads |
+| `POST` | `/agent-bundles/preview` | Export requested agent/app/automation/tool heads |
+| `POST` | `/agent-bundles/install` | Validate and install `{ bundle, auth_ref? }` |
+
+Embedding hosts inject `bundlePort` for resources owned by Apps, Automations,
+and Toolbox. Agent-only bundles need no port. Bundles with external resources
+fail explicitly when the owner port is absent.
+
+## Agents
 
 | Method | Path | Result |
 |---|---|---|
-| `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.
+| `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
+
+| 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": {}
+  }
+}
+```

package/docs/SDK.md

@@ -1,23 +1,72 @@
 # SDK reference
 
-`Agents` is the public behavior boundary for the local agent registry. Every
-mutation is durable before it returns.
+The `Agents` class is the sole public behavior boundary. All mutations are
+durable before a method returns.
+
+## Construction
 
 ```ts
-const agents = new Agents({ stateDir: './state' });
+const agents = new Agents({
+  stateDir: './state',
+  drivers: [codexDriver],
+  maxInputBytes: 256_000,
+  maxEventBytes: 256_000,
+  turnTimeoutMs: 600_000,
+});
 ```
 
-`databasePath` overrides the database location directly. Call `close()` when
-the embedding process releases the registry.
+`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
 
 | Method | Behavior |
 |---|---|
-| `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 |
+| `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 |
 | `getAgent(id, includeDeleted?)` | Read the current definition |
-| `listAgents(includeDeleted?)` | List available agents by default |
-| `getAgentRevision(agentId, revisionId?)` | Resolve the current or exact immutable revision |
+| `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`.
 
-Expected failures use `AgentError` with stable codes: `invalid_input`,
-`not_found`, `conflict`, `deleted`, and `too_large`.
+Driver failures become durable failed turns rather than escaping as transient
+transport errors. Inspect `turn.error` and the session event ledger.

package/docs/SECURITY.md

@@ -1,9 +1,38 @@
 # Security model
 
-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.
+Agents stores executable configuration and conversation history, so its state
+directory should be treated as user-private data.
 
-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.
+## 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.

package/examples/basic.ts

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