@ai-ecoverse/slicc-agent 1.0.0 → 1.2.0

package/README.md

@@ -1,9 +1,32 @@
 # slicc-agent
 
-Empty package for SLICC's agent core. It will be rebuilt on pi's `packages/durable`: session storage in wasm SQLite, remoting, compaction, and pi extensions.
+SLICC's agent core, built on pi's [durable](https://github.com/earendil-works/pi/tree/main/packages/durable) harness. It runs in a dedicated worker next to [slicc-kernel](https://github.com/ai-ecoverse/slicc-kernel) and is shown by [slicc-spectrum](https://github.com/ai-ecoverse/slicc-spectrum). The plan is in [ai-ecoverse/slicc-agent#2](https://github.com/ai-ecoverse/slicc-agent/issues/2).
+
+The package ships unbundled ESM: `dist/` holds one file per source file and imports pi's packages by name, so [slicc-bios](https://github.com/ai-ecoverse/slicc-bios) installs it from its lockfile like any other package, and `pnpm upgrade @ai-ecoverse/slicc-agent` updates it in place.
+
+## Use
 
 ```js
-import {} from '@ai-ecoverse/slicc-agent';
+import { connectAgent, openAgent, serveAgent } from '@ai-ecoverse/slicc-agent';
+
+serveAgent(self, openAgent({ models, model: { provider: 'amazon-bedrock', modelId } }));
+
+const agent = connectAgent(new Worker(workerUrl, { type: 'module' }));
+await agent.prompt('What is in /home?');
+```
+
+- `openAgent({ models, model, storage?, registry?, settings? })` opens a durable Harness (in memory unless `storage` is given) and its root conversation. `prompt(text)` submits an input and resolves with the answer's text.
+- `openOpfsSqliteStorage({ directory?, file? })` keeps the session in wasm SQLite ([`@sqlite.org/sqlite-wasm`](https://www.npmjs.com/package/@sqlite.org/sqlite-wasm)) in an `opfs-sahpool` pool, by default `/.slicc/agent/` in OPFS. It needs a dedicated worker. Only one worker holds a pool at a time: the opener takes a Web Lock per directory and waits until every file of the pool can be opened before sqlite-wasm installs it, because a failed install deletes the pool's directory. `openMemorySqliteStorage()` keeps the same database in memory. Pass either as `storage`.
+- `serveAgent(endpoint, agent)` answers prompts that arrive on a worker or `MessagePort`; `connectAgent(endpoint)` is the page side.
+
+## Develop
+
+```sh
+npm install
+npm run build
+npm run test:unit
+npm test
+npm run lint
 ```
 
-Node ≥ 24. `npm run lint` runs `slicc-lint`. Releases use semantic-release on `main`.
+`npm test` builds `dist/`, bundles a test worker that runs the agent on pi's faux provider, and runs the integration tests in Chromium through the [slicc-shared-web harness](https://github.com/ai-ecoverse/slicc-shared-web#integration-test-harness). Unit tests live in `test/unit/`, which stays out of git; the pre-commit hook requires every changed line in `src/` to be covered. No test calls a real model.

package/dist/agent.js

@@ -0,0 +1,45 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import {
+  AssistantEntry,
+  createRegistry,
+  Harness,
+  MemoryStorage
+} from "@earendil-works/pi-durable";
+function answerText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+}
+async function prompt(root, text, context) {
+  const submission = await root.submit({ type: "input", content: text }, context);
+  const settled = await submission.wait(context);
+  const { answer, reason } = settled;
+  if (answer === void 0) throw new Error(`unanswered: ${reason}`);
+  const entry = await root.commit((tx) => tx.entry(AssistantEntry, answer), context);
+  return answerText(entry?.model?.[0]?.content);
+}
+async function openAgent(options) {
+  const context = options.context ?? BACKGROUND_CONTEXT;
+  const harness = await Harness.open(
+    options.storage ?? new MemoryStorage(),
+    {
+      models: options.models,
+      registry: options.registry ?? createRegistry(),
+      ...options.settings ? { settings: options.settings } : {}
+    },
+    context
+  );
+  const root = await harness.root(context, { agent: { model: options.model } });
+  harness.resume();
+  return {
+    harness,
+    root,
+    prompt: (text) => prompt(root, text, context),
+    close: () => harness.close(context)
+  };
+}
+export {
+  answerText,
+  openAgent
+};
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/agent.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport type { Models } from '@earendil-works/pi-ai/models';\nimport {\n  AssistantEntry,\n  type Conversation,\n  createRegistry,\n  type EntryId,\n  Harness,\n  type HarnessOptions,\n  MemoryStorage,\n  type ModelRef,\n  type Registry,\n  type Storage,\n} from '@earendil-works/pi-durable';\n\nexport interface AgentOptions {\n  models: Models;\n  model: ModelRef;\n  storage?: Storage;\n  registry?: Registry;\n  settings?: HarnessOptions['settings'];\n  context?: Context;\n}\n\nexport interface Agent {\n  readonly harness: Harness;\n  readonly root: Conversation;\n  prompt(text: string): Promise<string>;\n  close(): Promise<void>;\n}\n\ninterface Block {\n  type: string;\n  text?: string;\n}\n\nexport function answerText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  return (content as Block[])\n    .filter((block) => block.type === 'text')\n    .map((block) => block.text ?? '')\n    .join('');\n}\n\nasync function prompt(root: Conversation, text: string, context: Context): Promise<string> {\n  const submission = await root.submit({ type: 'input', content: text }, context);\n  const settled = await submission.wait(context);\n  const { answer, reason } = settled as { answer?: EntryId; reason?: string };\n  if (answer === undefined) throw new Error(`unanswered: ${reason}`);\n  const entry = await root.commit((tx) => tx.entry(AssistantEntry, answer), context);\n  return answerText(entry?.model?.[0]?.content);\n}\n\nexport async function openAgent(options: AgentOptions): Promise<Agent> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const harness = await Harness.open(\n    options.storage ?? new MemoryStorage(),\n    {\n      models: options.models,\n      registry: options.registry ?? createRegistry(),\n      ...(options.settings ? { settings: options.settings } : {}),\n    },\n    context\n  );\n  const root = await harness.root(context, { agent: { model: options.model } });\n  harness.resume();\n  return {\n    harness,\n    root,\n    prompt: (text) => prompt(root, text, context),\n    close: () => harness.close(context),\n  };\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AAEnC;AAAA,EACE;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,OAIK;AAuBA,SAAS,WAAW,SAA0B;AACnD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO,EAAG,QAAO;AACpC,SAAQ,QACL,OAAO,CAAC,UAAU,MAAM,SAAS,MAAM,EACvC,IAAI,CAAC,UAAU,MAAM,QAAQ,EAAE,EAC/B,KAAK,EAAE;AACZ;AAEA,eAAe,OAAO,MAAoB,MAAc,SAAmC;AACzF,QAAM,aAAa,MAAM,KAAK,OAAO,EAAE,MAAM,SAAS,SAAS,KAAK,GAAG,OAAO;AAC9E,QAAM,UAAU,MAAM,WAAW,KAAK,OAAO;AAC7C,QAAM,EAAE,QAAQ,OAAO,IAAI;AAC3B,MAAI,WAAW,OAAW,OAAM,IAAI,MAAM,eAAe,MAAM,EAAE;AACjE,QAAM,QAAQ,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,MAAM,gBAAgB,MAAM,GAAG,OAAO;AACjF,SAAO,WAAW,OAAO,QAAQ,CAAC,GAAG,OAAO;AAC9C;AAEA,eAAsB,UAAU,SAAuC;AACrE,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,QAAQ,WAAW,IAAI,cAAc;AAAA,IACrC;AAAA,MACE,QAAQ,QAAQ;AAAA,MAChB,UAAU,QAAQ,YAAY,eAAe;AAAA,MAC7C,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;AAAA,IAC3D;AAAA,IACA;AAAA,EACF;AACA,QAAM,OAAO,MAAM,QAAQ,KAAK,SAAS,EAAE,OAAO,EAAE,OAAO,QAAQ,MAAM,EAAE,CAAC;AAC5E,UAAQ,OAAO;AACf,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,QAAQ,CAAC,SAAS,OAAO,MAAM,MAAM,OAAO;AAAA,IAC5C,OAAO,MAAM,QAAQ,MAAM,OAAO;AAAA,EACpC;AACF;",
+  "names": []
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+import { answerText, openAgent } from "./agent.js";
+import {
+  connectAgent,
+  serveAgent
+} from "./port.js";
+import {
+  AGENT_DIRECTORY,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
+  WasmSqliteDatabase
+} from "./sqlite.js";
+export {
+  AGENT_DIRECTORY,
+  WasmSqliteDatabase,
+  answerText,
+  connectAgent,
+  openAgent,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
+  serveAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport {\n  type AgentClient,\n  type AgentReply,\n  type AgentRequest,\n  connectAgent,\n  type MessageEndpoint,\n  serveAgent,\n} from './port.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\n"],
+  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}

package/dist/opfs-pool.js

@@ -0,0 +1,55 @@
+const names = /* @__PURE__ */ new Map();
+function vfsName(directory) {
+  let name = names.get(directory);
+  if (!name) {
+    name = `slicc-agent-${names.size}`;
+    names.set(directory, name);
+  }
+  return name;
+}
+function holdLock(locks, name) {
+  return new Promise((acquired, failed) => {
+    locks.request(name, { mode: "exclusive" }, () => new Promise((release) => acquired(release))).catch(failed);
+  });
+}
+async function opaque(root, directory) {
+  let dir = root;
+  try {
+    for (const part of [...directory.split("/").filter(Boolean), ".opaque"]) {
+      dir = await dir.getDirectoryHandle(part);
+    }
+  } catch {
+    return void 0;
+  }
+  return dir;
+}
+async function acquirable(dir) {
+  for await (const handle of dir.values()) {
+    if (handle.kind !== "file") continue;
+    try {
+      const access = await handle.createSyncAccessHandle();
+      access.close();
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+const pause = (ms) => new Promise((resume) => setTimeout(resume, ms));
+async function settlePool(directory, access = {}) {
+  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();
+  const dir = await opaque(root, directory);
+  if (!dir) return;
+  const attempts = access.attempts ?? 50;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (await acquirable(dir)) return;
+    if (attempt < attempts) await pause(access.delayMs ?? 100);
+  }
+  throw new Error(`SQLite pool ${directory} is still in use by another worker`);
+}
+export {
+  holdLock,
+  settlePool,
+  vfsName
+};
+//# sourceMappingURL=opfs-pool.js.map

package/dist/opfs-pool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/opfs-pool.ts"],
+  "sourcesContent": ["export interface PoolAccess {\n  root?: () => Promise<FileSystemDirectoryHandle>;\n  locks?: LockManager;\n  attempts?: number;\n  delayMs?: number;\n}\n\ninterface SyncAccessible {\n  createSyncAccessHandle(): Promise<{ close(): void }>;\n}\n\nconst names = new Map<string, string>();\n\nexport function vfsName(directory: string): string {\n  let name = names.get(directory);\n  if (!name) {\n    name = `slicc-agent-${names.size}`;\n    names.set(directory, name);\n  }\n  return name;\n}\n\nexport function holdLock(locks: LockManager, name: string): Promise<() => void> {\n  return new Promise((acquired, failed) => {\n    locks\n      .request(name, { mode: 'exclusive' }, () => new Promise<void>((release) => acquired(release)))\n      .catch(failed);\n  });\n}\n\nasync function opaque(\n  root: FileSystemDirectoryHandle,\n  directory: string\n): Promise<FileSystemDirectoryHandle | undefined> {\n  let dir = root;\n  try {\n    for (const part of [...directory.split('/').filter(Boolean), '.opaque']) {\n      dir = await dir.getDirectoryHandle(part);\n    }\n  } catch {\n    return undefined;\n  }\n  return dir;\n}\n\nasync function acquirable(dir: FileSystemDirectoryHandle): Promise<boolean> {\n  for await (const handle of dir.values()) {\n    if (handle.kind !== 'file') continue;\n    try {\n      const access = await (handle as unknown as SyncAccessible).createSyncAccessHandle();\n      access.close();\n    } catch {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst pause = (ms: number) => new Promise((resume) => setTimeout(resume, ms));\n\nexport async function settlePool(directory: string, access: PoolAccess = {}): Promise<void> {\n  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();\n  const dir = await opaque(root, directory);\n  if (!dir) return;\n  const attempts = access.attempts ?? 50;\n  for (let attempt = 1; attempt <= attempts; attempt++) {\n    if (await acquirable(dir)) return;\n    if (attempt < attempts) await pause(access.delayMs ?? 100);\n  }\n  throw new Error(`SQLite pool ${directory} is still in use by another worker`);\n}\n"],
+  "mappings": "AAWA,MAAM,QAAQ,oBAAI,IAAoB;AAE/B,SAAS,QAAQ,WAA2B;AACjD,MAAI,OAAO,MAAM,IAAI,SAAS;AAC9B,MAAI,CAAC,MAAM;AACT,WAAO,eAAe,MAAM,IAAI;AAChC,UAAM,IAAI,WAAW,IAAI;AAAA,EAC3B;AACA,SAAO;AACT;AAEO,SAAS,SAAS,OAAoB,MAAmC;AAC9E,SAAO,IAAI,QAAQ,CAAC,UAAU,WAAW;AACvC,UACG,QAAQ,MAAM,EAAE,MAAM,YAAY,GAAG,MAAM,IAAI,QAAc,CAAC,YAAY,SAAS,OAAO,CAAC,CAAC,EAC5F,MAAM,MAAM;AAAA,EACjB,CAAC;AACH;AAEA,eAAe,OACb,MACA,WACgD;AAChD,MAAI,MAAM;AACV,MAAI;AACF,eAAW,QAAQ,CAAC,GAAG,UAAU,MAAM,GAAG,EAAE,OAAO,OAAO,GAAG,SAAS,GAAG;AACvE,YAAM,MAAM,IAAI,mBAAmB,IAAI;AAAA,IACzC;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,eAAe,WAAW,KAAkD;AAC1E,mBAAiB,UAAU,IAAI,OAAO,GAAG;AACvC,QAAI,OAAO,SAAS,OAAQ;AAC5B,QAAI;AACF,YAAM,SAAS,MAAO,OAAqC,uBAAuB;AAClF,aAAO,MAAM;AAAA,IACf,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,MAAM,QAAQ,CAAC,OAAe,IAAI,QAAQ,CAAC,WAAW,WAAW,QAAQ,EAAE,CAAC;AAE5E,eAAsB,WAAW,WAAmB,SAAqB,CAAC,GAAkB;AAC1F,QAAM,OAAO,OAAO,OAAO,SAAS,MAAM,UAAU,QAAQ,aAAa,IAAI;AAC7E,QAAM,MAAM,MAAM,OAAO,MAAM,SAAS;AACxC,MAAI,CAAC,IAAK;AACV,QAAM,WAAW,OAAO,YAAY;AACpC,WAAS,UAAU,GAAG,WAAW,UAAU,WAAW;AACpD,QAAI,MAAM,WAAW,GAAG,EAAG;AAC3B,QAAI,UAAU,SAAU,OAAM,MAAM,OAAO,WAAW,GAAG;AAAA,EAC3D;AACA,QAAM,IAAI,MAAM,eAAe,SAAS,oCAAoC;AAC9E;",
+  "names": []
+}

package/dist/port.js

@@ -0,0 +1,57 @@
+function isRequest(data) {
+  const value = data;
+  return typeof value?.id === "number" && typeof value.prompt === "string";
+}
+function reason(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function serveAgent(endpoint, agent) {
+  endpoint.addEventListener("message", ({ data }) => {
+    if (!isRequest(data)) return;
+    agent.then((ready) => ready.prompt(data.prompt)).then(
+      (text) => endpoint.postMessage({ id: data.id, text }),
+      (error) => endpoint.postMessage({ id: data.id, error: reason(error) })
+    );
+  });
+  endpoint.start?.();
+}
+function failure(event) {
+  const message = event.message;
+  return new Error(message ? `agent failed: ${message}` : `agent failed: ${event.type}`);
+}
+function connectAgent(endpoint) {
+  const pending = /* @__PURE__ */ new Map();
+  let broken;
+  let next = 0;
+  const fail = (event) => {
+    broken = failure(event);
+    for (const call of pending.values()) call.reject(broken);
+    pending.clear();
+  };
+  endpoint.addEventListener("message", ({ data }) => {
+    const reply = data;
+    const call = pending.get(reply.id);
+    if (!call) return;
+    pending.delete(reply.id);
+    if ("error" in reply) call.reject(new Error(reply.error));
+    else call.resolve(reply.text);
+  });
+  endpoint.addEventListener("error", fail);
+  endpoint.addEventListener("messageerror", fail);
+  endpoint.start?.();
+  return {
+    prompt(text) {
+      if (broken) return Promise.reject(broken);
+      const id = ++next;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        endpoint.postMessage({ id, prompt: text });
+      });
+    }
+  };
+}
+export {
+  connectAgent,
+  serveAgent
+};
+//# sourceMappingURL=port.js.map

package/dist/port.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/port.ts"],
+  "sourcesContent": ["import type { Agent } from './agent.ts';\n\nexport interface AgentRequest {\n  id: number;\n  prompt: string;\n}\n\nexport type AgentReply = { id: number; text: string } | { id: number; error: string };\n\nexport interface MessageEndpoint {\n  postMessage(message: unknown): void;\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n  addEventListener(type: 'error' | 'messageerror', listener: (event: Event) => void): void;\n  start?(): void;\n}\n\nfunction isRequest(data: unknown): data is AgentRequest {\n  const value = data as Partial<AgentRequest> | null;\n  return typeof value?.id === 'number' && typeof value.prompt === 'string';\n}\n\nfunction reason(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport function serveAgent(endpoint: MessageEndpoint, agent: Promise<Agent>): void {\n  endpoint.addEventListener('message', ({ data }) => {\n    if (!isRequest(data)) return;\n    agent\n      .then((ready) => ready.prompt(data.prompt))\n      .then(\n        (text) => endpoint.postMessage({ id: data.id, text } satisfies AgentReply),\n        (error: unknown) =>\n          endpoint.postMessage({ id: data.id, error: reason(error) } satisfies AgentReply)\n      );\n  });\n  endpoint.start?.();\n}\n\nexport interface AgentClient {\n  prompt(text: string): Promise<string>;\n}\n\nfunction failure(event: Event): Error {\n  const message = (event as ErrorEvent).message;\n  return new Error(message ? `agent failed: ${message}` : `agent failed: ${event.type}`);\n}\n\nexport function connectAgent(endpoint: MessageEndpoint): AgentClient {\n  const pending = new Map<number, { resolve(text: string): void; reject(error: Error): void }>();\n  let broken: Error | undefined;\n  let next = 0;\n  const fail = (event: Event) => {\n    broken = failure(event);\n    for (const call of pending.values()) call.reject(broken);\n    pending.clear();\n  };\n  endpoint.addEventListener('message', ({ data }) => {\n    const reply = data as AgentReply;\n    const call = pending.get(reply.id);\n    if (!call) return;\n    pending.delete(reply.id);\n    if ('error' in reply) call.reject(new Error(reply.error));\n    else call.resolve(reply.text);\n  });\n  endpoint.addEventListener('error', fail);\n  endpoint.addEventListener('messageerror', fail);\n  endpoint.start?.();\n  return {\n    prompt(text) {\n      if (broken) return Promise.reject(broken);\n      const id = ++next;\n      return new Promise((resolve, reject) => {\n        pending.set(id, { resolve, reject });\n        endpoint.postMessage({ id, prompt: text } satisfies AgentRequest);\n      });\n    },\n  };\n}\n"],
+  "mappings": "AAgBA,SAAS,UAAU,MAAqC;AACtD,QAAM,QAAQ;AACd,SAAO,OAAO,OAAO,OAAO,YAAY,OAAO,MAAM,WAAW;AAClE;AAEA,SAAS,OAAO,OAAwB;AACtC,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEO,SAAS,WAAW,UAA2B,OAA6B;AACjF,WAAS,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AACjD,QAAI,CAAC,UAAU,IAAI,EAAG;AACtB,UACG,KAAK,CAAC,UAAU,MAAM,OAAO,KAAK,MAAM,CAAC,EACzC;AAAA,MACC,CAAC,SAAS,SAAS,YAAY,EAAE,IAAI,KAAK,IAAI,KAAK,CAAsB;AAAA,MACzE,CAAC,UACC,SAAS,YAAY,EAAE,IAAI,KAAK,IAAI,OAAO,OAAO,KAAK,EAAE,CAAsB;AAAA,IACnF;AAAA,EACJ,CAAC;AACD,WAAS,QAAQ;AACnB;AAMA,SAAS,QAAQ,OAAqB;AACpC,QAAM,UAAW,MAAqB;AACtC,SAAO,IAAI,MAAM,UAAU,iBAAiB,OAAO,KAAK,iBAAiB,MAAM,IAAI,EAAE;AACvF;AAEO,SAAS,aAAa,UAAwC;AACnE,QAAM,UAAU,oBAAI,IAAyE;AAC7F,MAAI;AACJ,MAAI,OAAO;AACX,QAAM,OAAO,CAAC,UAAiB;AAC7B,aAAS,QAAQ,KAAK;AACtB,eAAW,QAAQ,QAAQ,OAAO,EAAG,MAAK,OAAO,MAAM;AACvD,YAAQ,MAAM;AAAA,EAChB;AACA,WAAS,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AACjD,UAAM,QAAQ;AACd,UAAM,OAAO,QAAQ,IAAI,MAAM,EAAE;AACjC,QAAI,CAAC,KAAM;AACX,YAAQ,OAAO,MAAM,EAAE;AACvB,QAAI,WAAW,MAAO,MAAK,OAAO,IAAI,MAAM,MAAM,KAAK,CAAC;AAAA,QACnD,MAAK,QAAQ,MAAM,IAAI;AAAA,EAC9B,CAAC;AACD,WAAS,iBAAiB,SAAS,IAAI;AACvC,WAAS,iBAAiB,gBAAgB,IAAI;AAC9C,WAAS,QAAQ;AACjB,SAAO;AAAA,IACL,OAAO,MAAM;AACX,UAAI,OAAQ,QAAO,QAAQ,OAAO,MAAM;AACxC,YAAM,KAAK,EAAE;AACb,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,gBAAQ,IAAI,IAAI,EAAE,SAAS,OAAO,CAAC;AACnC,iBAAS,YAAY,EAAE,IAAI,QAAQ,KAAK,CAAwB;AAAA,MAClE,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/sqlite.js

@@ -0,0 +1,158 @@
+import {
+  SqliteStorage
+} from "@earendil-works/pi-durable/storage/sqlite";
+import init, {} from "@sqlite.org/sqlite-wasm";
+import { holdLock, settlePool, vfsName } from "./opfs-pool.js";
+class SerialQueue {
+  #tail = Promise.resolve();
+  run(operation) {
+    const result = this.#tail.then(operation);
+    this.#tail = result.catch(() => {
+    });
+    return result;
+  }
+}
+class Statements {
+  #db;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.#db = db;
+  }
+  bound(sql, params) {
+    let statement = this.#cache.get(sql);
+    if (!statement) {
+      statement = this.#db.prepare(sql);
+      this.#cache.set(sql, statement);
+    }
+    statement.reset(true);
+    if (params.length > 0) statement.bind([...params]);
+    return statement;
+  }
+  finalize() {
+    for (const statement of this.#cache.values()) statement.finalize();
+    this.#cache.clear();
+  }
+}
+class WasmSqliteExecutor {
+  db;
+  statements;
+  constructor(db, statements) {
+    this.db = db;
+    this.statements = statements;
+  }
+  async exec(sql) {
+    this.check();
+    this.db.exec(sql);
+  }
+  async run(sql, ...params) {
+    this.check();
+    this.statements.bound(sql, params).stepReset();
+  }
+  async get(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const row = statement.step() ? statement.get({}) : void 0;
+    statement.reset();
+    return row;
+  }
+  async all(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const rows = [];
+    while (statement.step()) rows.push(statement.get({}));
+    statement.reset();
+    return rows;
+  }
+  check() {
+  }
+}
+class WasmSqliteTransaction extends WasmSqliteExecutor {
+  active = true;
+  check() {
+    if (!this.active) throw new Error("SQLite transaction handle is no longer active");
+  }
+}
+class WasmSqliteDatabase extends WasmSqliteExecutor {
+  #queue = new SerialQueue();
+  #closed;
+  constructor(db, closed = () => {
+  }) {
+    super(db, new Statements(db));
+    this.#closed = closed;
+  }
+  exec(sql) {
+    return this.#queue.run(() => super.exec(sql));
+  }
+  run(sql, ...params) {
+    return this.#queue.run(() => super.run(sql, ...params));
+  }
+  get(sql, ...params) {
+    return this.#queue.run(() => super.get(sql, ...params));
+  }
+  all(sql, ...params) {
+    return this.#queue.run(() => super.all(sql, ...params));
+  }
+  transaction(callback) {
+    return this.#queue.run(async () => {
+      const transaction = new WasmSqliteTransaction(this.db, this.statements);
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await callback(transaction);
+        this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        this.#rollback(error);
+        throw error;
+      } finally {
+        transaction.active = false;
+      }
+    });
+  }
+  close() {
+    return this.#queue.run(() => {
+      try {
+        this.statements.finalize();
+        this.db.close();
+      } finally {
+        this.#closed();
+      }
+    });
+  }
+  #rollback(cause) {
+    try {
+      this.db.exec("ROLLBACK");
+    } catch (error) {
+      throw new AggregateError([cause, error], "SQLite rollback failed");
+    }
+  }
+}
+const AGENT_DIRECTORY = "/.slicc/agent";
+async function openMemorySqliteStorage() {
+  const sqlite3 = await init();
+  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(":memory:", "c")));
+}
+async function openOpfsSqliteStorage(options = {}) {
+  const directory = options.directory ?? AGENT_DIRECTORY;
+  const release = await holdLock(
+    options.locks ?? navigator.locks,
+    `slicc-agent-sqlite:${directory}`
+  );
+  try {
+    await settlePool(directory, options);
+    const sqlite3 = await (options.load ?? init)();
+    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });
+    const db = new pool.OpfsSAHPoolDb(options.file ?? "/agent.sqlite");
+    db.exec("PRAGMA journal_mode = TRUNCATE");
+    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+export {
+  AGENT_DIRECTORY,
+  WasmSqliteDatabase,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage
+};
+//# sourceMappingURL=sqlite.js.map

package/dist/sqlite.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sqlite.ts"],
+  "sourcesContent": ["import type { Storage } from '@earendil-works/pi-durable';\nimport {\n  type SqliteDatabase,\n  type SqliteExecutor,\n  SqliteStorage,\n  type SqliteValue,\n} from '@earendil-works/pi-durable/storage/sqlite';\nimport init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';\nimport { holdLock, type PoolAccess, settlePool, vfsName } from './opfs-pool.ts';\n\ntype Row = Record<string, unknown>;\n\nclass SerialQueue {\n  #tail: Promise<unknown> = Promise.resolve();\n\n  run<T>(operation: () => T | Promise<T>): Promise<T> {\n    const result = this.#tail.then(operation);\n    this.#tail = result.catch(() => {});\n    return result;\n  }\n}\n\nclass Statements {\n  readonly #db: Database;\n  readonly #cache = new Map<string, PreparedStatement>();\n\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  bound(sql: string, params: readonly SqliteValue[]): PreparedStatement {\n    let statement = this.#cache.get(sql);\n    if (!statement) {\n      statement = this.#db.prepare(sql);\n      this.#cache.set(sql, statement);\n    }\n    statement.reset(true);\n    if (params.length > 0) statement.bind([...params]);\n    return statement;\n  }\n\n  finalize(): void {\n    for (const statement of this.#cache.values()) statement.finalize();\n    this.#cache.clear();\n  }\n}\n\nclass WasmSqliteExecutor implements SqliteExecutor {\n  protected readonly db: Database;\n  protected readonly statements: Statements;\n\n  constructor(db: Database, statements: Statements) {\n    this.db = db;\n    this.statements = statements;\n  }\n\n  async exec(sql: string): Promise<void> {\n    this.check();\n    this.db.exec(sql);\n  }\n\n  async run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    this.check();\n    this.statements.bound(sql, params).stepReset();\n  }\n\n  async get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const row = statement.step() ? (statement.get({}) as Row as T) : undefined;\n    statement.reset();\n    return row;\n  }\n\n  async all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const rows: T[] = [];\n    while (statement.step()) rows.push(statement.get({}) as Row as T);\n    statement.reset();\n    return rows;\n  }\n\n  protected check(): void {}\n}\n\nclass WasmSqliteTransaction extends WasmSqliteExecutor {\n  active = true;\n\n  protected override check(): void {\n    if (!this.active) throw new Error('SQLite transaction handle is no longer active');\n  }\n}\n\nexport class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {\n  readonly #queue = new SerialQueue();\n  readonly #closed: () => void;\n\n  constructor(db: Database, closed: () => void = () => {}) {\n    super(db, new Statements(db));\n    this.#closed = closed;\n  }\n\n  override exec(sql: string): Promise<void> {\n    return this.#queue.run(() => super.exec(sql));\n  }\n\n  override run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    return this.#queue.run(() => super.run(sql, ...params));\n  }\n\n  override get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    return this.#queue.run(() => super.get<T>(sql, ...params));\n  }\n\n  override all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    return this.#queue.run(() => super.all<T>(sql, ...params));\n  }\n\n  transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T> {\n    return this.#queue.run(async () => {\n      const transaction = new WasmSqliteTransaction(this.db, this.statements);\n      this.db.exec('BEGIN IMMEDIATE');\n      try {\n        const result = await callback(transaction);\n        this.db.exec('COMMIT');\n        return result;\n      } catch (error) {\n        this.#rollback(error);\n        throw error;\n      } finally {\n        transaction.active = false;\n      }\n    });\n  }\n\n  close(): Promise<void> {\n    return this.#queue.run(() => {\n      try {\n        this.statements.finalize();\n        this.db.close();\n      } finally {\n        this.#closed();\n      }\n    });\n  }\n\n  #rollback(cause: unknown): void {\n    try {\n      this.db.exec('ROLLBACK');\n    } catch (error) {\n      throw new AggregateError([cause, error], 'SQLite rollback failed');\n    }\n  }\n}\n\nexport interface OpfsSqliteOptions extends PoolAccess {\n  directory?: string;\n  file?: string;\n  load?: typeof init;\n}\n\nexport const AGENT_DIRECTORY = '/.slicc/agent';\n\nexport async function openMemorySqliteStorage(): Promise<Storage> {\n  const sqlite3 = await init();\n  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(':memory:', 'c')));\n}\n\nexport async function openOpfsSqliteStorage(options: OpfsSqliteOptions = {}): Promise<Storage> {\n  const directory = options.directory ?? AGENT_DIRECTORY;\n  const release = await holdLock(\n    options.locks ?? navigator.locks,\n    `slicc-agent-sqlite:${directory}`\n  );\n  try {\n    await settlePool(directory, options);\n    const sqlite3 = await (options.load ?? init)();\n    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });\n    const db = new pool.OpfsSAHPoolDb(options.file ?? '/agent.sqlite');\n    db.exec('PRAGMA journal_mode = TRUNCATE');\n    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));\n  } catch (error) {\n    release();\n    throw error;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/agent.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@earendil-works/chord';
+import type { Models } from '@earendil-works/pi-ai/models';
+import { type Conversation, Harness, type HarnessOptions, type ModelRef, type Registry, type Storage } from '@earendil-works/pi-durable';
+export interface AgentOptions {
+    models: Models;
+    model: ModelRef;
+    storage?: Storage;
+    registry?: Registry;
+    settings?: HarnessOptions['settings'];
+    context?: Context;
+}
+export interface Agent {
+    readonly harness: Harness;
+    readonly root: Conversation;
+    prompt(text: string): Promise<string>;
+    close(): Promise<void>;
+}
+export declare function answerText(content: unknown): string;
+export declare function openAgent(options: AgentOptions): Promise<Agent>;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';
+export { type AgentClient, type AgentReply, type AgentRequest, connectAgent, type MessageEndpoint, serveAgent, } from './port.ts';
+export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';

package/dist/types/opfs-pool.d.ts

@@ -0,0 +1,9 @@
+export interface PoolAccess {
+    root?: () => Promise<FileSystemDirectoryHandle>;
+    locks?: LockManager;
+    attempts?: number;
+    delayMs?: number;
+}
+export declare function vfsName(directory: string): string;
+export declare function holdLock(locks: LockManager, name: string): Promise<() => void>;
+export declare function settlePool(directory: string, access?: PoolAccess): Promise<void>;

package/dist/types/port.d.ts

@@ -0,0 +1,23 @@
+import type { Agent } from './agent.ts';
+export interface AgentRequest {
+    id: number;
+    prompt: string;
+}
+export type AgentReply = {
+    id: number;
+    text: string;
+} | {
+    id: number;
+    error: string;
+};
+export interface MessageEndpoint {
+    postMessage(message: unknown): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    addEventListener(type: 'error' | 'messageerror', listener: (event: Event) => void): void;
+    start?(): void;
+}
+export declare function serveAgent(endpoint: MessageEndpoint, agent: Promise<Agent>): void;
+export interface AgentClient {
+    prompt(text: string): Promise<string>;
+}
+export declare function connectAgent(endpoint: MessageEndpoint): AgentClient;

package/dist/types/sqlite.d.ts

@@ -0,0 +1,39 @@
+import type { Storage } from '@earendil-works/pi-durable';
+import { type SqliteDatabase, type SqliteExecutor, type SqliteValue } from '@earendil-works/pi-durable/storage/sqlite';
+import init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';
+import { type PoolAccess } from './opfs-pool.ts';
+declare class Statements {
+    #private;
+    constructor(db: Database);
+    bound(sql: string, params: readonly SqliteValue[]): PreparedStatement;
+    finalize(): void;
+}
+declare class WasmSqliteExecutor implements SqliteExecutor {
+    protected readonly db: Database;
+    protected readonly statements: Statements;
+    constructor(db: Database, statements: Statements);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    protected check(): void;
+}
+export declare class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {
+    #private;
+    constructor(db: Database, closed?: () => void);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+export interface OpfsSqliteOptions extends PoolAccess {
+    directory?: string;
+    file?: string;
+    load?: typeof init;
+}
+export declare const AGENT_DIRECTORY = "/.slicc/agent";
+export declare function openMemorySqliteStorage(): Promise<Storage>;
+export declare function openOpfsSqliteStorage(options?: OpfsSqliteOptions): Promise<Storage>;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "1.0.0",
-  "description": "SLICC's agent core: session storage in wasm SQLite, remoting, compaction, and pi extensions",
+  "version": "1.2.0",
+  "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -22,24 +22,44 @@
     "provenance": true
   },
   "exports": {
-    ".": "./src/index.js"
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "src"
+    "dist"
   ],
   "scripts": {
     "prepare": "lefthook install",
+    "build": "node build.mjs && tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "start": "npm run build && node test/integration/chrome.mjs",
+    "pretest": "npm run build && node test/integration/build.mjs && playwright-core install --no-shell chromium",
+    "test": "node --test --test-global-setup=node_modules/@ai-ecoverse/slicc-shared-web/harness/global.mjs 'test/integration/*.test.mjs'",
+    "test:unit": "NODE_NO_WARNINGS=1 mcr -c node_modules/@ai-ecoverse/slicc-shared-web/mcr.config.mjs node --test 'test/unit/**/*.test.mjs'",
+    "typecheck": "tsc",
     "lint": "slicc-lint",
     "format": "biome check --write .",
-    "test": "true",
     "trust": "npx fledgling sync -y --skip-publish",
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish",
     "release": "semantic-release"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-shared-web": "1.1.0",
+    "@ai-ecoverse/slicc-shared-web": "1.5.0",
     "@biomejs/biome": "2.5.15",
+    "@types/node": "24.19.1",
+    "esbuild": "0.28.2",
     "lefthook": "2.1.16",
-    "semantic-release": "25.0.9"
+    "monocart-coverage-reports": "2.13.0",
+    "playwright-core": "1.63.0",
+    "semantic-release": "25.0.9",
+    "typescript": "7.0.2"
+  },
+  "dependencies": {
+    "@earendil-works/chord": "1.0.4",
+    "@earendil-works/pi-ai": "1.0.4",
+    "@earendil-works/pi-durable": "1.0.4",
+    "@sqlite.org/sqlite-wasm": "3.53.4-build2"
   }
 }

package/src/index.js

@@ -1 +0,0 @@
-export {};