@ai-ecoverse/slicc-agent 2.2.0 → 2.3.0

package/README.md

@@ -57,6 +57,28 @@ const agent = await openAgent({ models, model, storage, registry, env: kernelEnv
 
 A conversation without a `cwd` works in `/home`.
 
+### The worker seven starts
+
+`@ai-ecoverse/slicc-agent/agent-worker` is a complete agent worker. It waits for the page kernel's port, then:
+- attaches to the kernel and routes its cross-origin `fetch` through the kernel's transport when that transport isn't bound by CORS (slicc-node, slicc-swift or slicc-extension);
+- opens the encrypted credential store, the AWS Bedrock provider and the session in OPFS SQLite;
+- installs durable's coding tools and SLICC's system prompt, and serves the agent.
+
+```js
+const owner = await startAgent({
+  worker: () => new Worker(new URL('@ai-ecoverse/slicc-agent/agent-worker', import.meta.url), { type: 'module' }),
+  kernel: { connect: () => kernel.connect() },
+});
+```
+
+`runAgentWorker(self, options)` is the same with its parts replaceable (model, providers, kernel attach, credentials, storage).
+
+**Providers.** The first provider is AWS Bedrock with a Bedrock API key as the bearer token; the default model is `us.anthropic.claude-sonnet-5-5`. Bedrock sends no CORS headers, so it needs a CORS-free transport, and its account says so (`needs: 'cors-free-transport'`).
+
+**Credentials.** They live in the IndexedDB database `slicc-agent-credentials`, sealed with AES-GCM under a non-extractable key that never leaves WebCrypto. They never enter the session database or the transcript, and followers never see them.
+
+**Settings.** The `slicc.agent.settings` service shows the models and accounts and takes `connect(providerId, apiKey)` and `disconnect(providerId)`.
+
 ### In slicc-spectrum
 
 `@ai-ecoverse/slicc-agent/spectrum` turns an `AgentConnection` into slicc-spectrum's `AgentPort`, so `<slicc-app>` shows the real agent:
@@ -65,9 +87,11 @@ A conversation without a `cwd` works in `/home`.
 import { createAgentModel } from '@ai-ecoverse/slicc-agent/spectrum';
 
 const agent = await owner.connect();
-app.model = { ...createKernelModel({ kernel, root }), ...createAgentModel(agent) };
+app.model = { ...createKernelModel({ kernel, root }), ...createAgentModel(agent, { storage: localStorage }) };
 ```
 
+`createAgentModel()` returns the `agent` and `settings` ports. Settings keeps the UI preferences in `storage`; model and thinking belong to the conversation, and accounts and models come from the worker.
+
 The adapter keeps the replicated transcript and maps it on every update. User, assistant and compaction entries become messages; tool results fill in the tool calls they answer; the generation in flight shows as a streaming message; retries and running compactions show as system messages. `busy()` and `queue()` read durable's live and inbox documents. A plain send queues a follow-up, and a steer send steers, as slicc-spectrum's composer asks today. There is one cone so far; scoops, the freezer, licks and questions come later. slicc-spectrum is a peer dependency (≥ 1.7.0) used for types only.
 
 pi-server 1.0.4 calls `unref()` on a `setTimeout` handle when it accepts a connection, which browsers don't have. `PortListener` wraps that one call so its timers get a no-op `unref`.

package/dist/agent-worker.js

@@ -0,0 +1,6 @@
+import { runAgentWorker } from "./main.js";
+const host = runAgentWorker(globalThis);
+export {
+  host
+};
+//# sourceMappingURL=agent-worker.js.map

package/dist/agent-worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/agent-worker.ts"],
+  "sourcesContent": ["import { type AgentWorkerScope, runAgentWorker } from './main.ts';\n\nexport const host = runAgentWorker(globalThis as unknown as AgentWorkerScope);\n"],
+  "mappings": "AAAA,SAAgC,sBAAsB;AAE/C,MAAM,OAAO,eAAe,UAAyC;",
+  "names": []
+}

package/dist/client.js

@@ -9,6 +9,7 @@ import {
   AgentSessions,
   AgentTranscript
 } from "./services.js";
+import { AgentSettings } from "./settings.js";
 import { PortChannel } from "./wire.js";
 function attached(client) {
   return new Promise((resolve) => {
@@ -32,17 +33,19 @@ async function connectAgent(endpoint, options = {}) {
   await server.use(AgentSessions).attach(AGENT_SESSION, context);
   await ready;
   const session = createRemoteServiceBinding({
-    services: [AgentControl, AgentTranscript],
+    services: [AgentControl, AgentTranscript, AgentSettings],
     transport: createClientServiceTransport(client, () => client.attachment),
     bound: true
   });
   const control = session.use(AgentControl);
   const transcript = session.use(AgentTranscript).state;
+  const settings = session.use(AgentSettings);
   await session.ready(context);
   return {
     serverId,
     control,
     transcript,
+    settings,
     async prompt(text, whenBusy = "followUp") {
       const sent = await control.send({ text, whenBusy, requestId: null }, context);
       if (!sent.accepted) throw new Error(`${sent.error.code}: ${sent.error.message}`);

package/dist/client.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/client.ts"],
-  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceBinding,\n  type ReplicatedState,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport { Client, createClientServiceTransport } from '@earendil-works/pi-client';\nimport type { ConversationView } from '@earendil-works/pi-durable';\nimport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  AgentTranscript,\n  type SendMode,\n} from './services.ts';\nimport { PortChannel, type PortEndpoint } from './wire.ts';\n\nexport interface AgentConnection {\n  readonly serverId: string;\n  readonly control: AgentControl;\n  readonly transcript: ReplicatedState<ConversationView>;\n  prompt(text: string, whenBusy?: SendMode): Promise<string>;\n  close(): Promise<void>;\n}\n\nfunction attached(client: Client): Promise<void> {\n  return new Promise((resolve) => {\n    const stop = client.onAttachmentChange(() => {\n      stop();\n      resolve();\n    });\n  });\n}\n\nexport async function connectAgent(\n  endpoint: PortEndpoint,\n  options: { context?: Context } = {}\n): Promise<AgentConnection> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const channel = new PortChannel(endpoint);\n  const serverId = await channel.hello;\n  const client = await Client.connect({ serverId, transportFactory: channel.transport });\n  const server = createRemoteServiceBinding({\n    services: [AgentSessions],\n    transport: createClientServiceTransport(client, () => ({ serverId })),\n    bound: true,\n  });\n  const ready = attached(client);\n  await server.use(AgentSessions).attach(AGENT_SESSION, context);\n  await ready;\n  const session = createRemoteServiceBinding({\n    services: [AgentControl, AgentTranscript],\n    transport: createClientServiceTransport(client, () => client.attachment),\n    bound: true,\n  });\n  const control = session.use(AgentControl);\n  const transcript = session.use(AgentTranscript).state;\n  await session.ready(context);\n  return {\n    serverId,\n    control,\n    transcript,\n    async prompt(text, whenBusy = 'followUp') {\n      const sent = await control.send({ text, whenBusy, requestId: null }, context);\n      if (!sent.accepted) throw new Error(`${sent.error.code}: ${sent.error.message}`);\n      const settled = await control.wait(sent.submissionId, context);\n      if (settled.status !== 'done') throw new Error(`unanswered: ${settled.reason}`);\n      return settled.text;\n    },\n    async close() {\n      await server.use(AgentSessions).detach(context);\n      await session.dispose(context);\n      await server.dispose(context);\n      await client.dispose();\n    },\n  };\n}\n"],
-  "mappings": "AAAA;AAAA,EAEE;AAAA,OAEK;AACP,SAAS,0BAA0B;AACnC,SAAS,QAAQ,oCAAoC;AAErD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,mBAAsC;AAU/C,SAAS,SAAS,QAA+B;AAC/C,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,OAAO,OAAO,mBAAmB,MAAM;AAC3C,WAAK;AACL,cAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,aACpB,UACA,UAAiC,CAAC,GACR;AAC1B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,IAAI,YAAY,QAAQ;AACxC,QAAM,WAAW,MAAM,QAAQ;AAC/B,QAAM,SAAS,MAAM,OAAO,QAAQ,EAAE,UAAU,kBAAkB,QAAQ,UAAU,CAAC;AACrF,QAAM,SAAS,2BAA2B;AAAA,IACxC,UAAU,CAAC,aAAa;AAAA,IACxB,WAAW,6BAA6B,QAAQ,OAAO,EAAE,SAAS,EAAE;AAAA,IACpE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,QAAQ,SAAS,MAAM;AAC7B,QAAM,OAAO,IAAI,aAAa,EAAE,OAAO,eAAe,OAAO;AAC7D,QAAM;AACN,QAAM,UAAU,2BAA2B;AAAA,IACzC,UAAU,CAAC,cAAc,eAAe;AAAA,IACxC,WAAW,6BAA6B,QAAQ,MAAM,OAAO,UAAU;AAAA,IACvE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,UAAU,QAAQ,IAAI,YAAY;AACxC,QAAM,aAAa,QAAQ,IAAI,eAAe,EAAE;AAChD,QAAM,QAAQ,MAAM,OAAO;AAC3B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,OAAO,MAAM,WAAW,YAAY;AACxC,YAAM,OAAO,MAAM,QAAQ,KAAK,EAAE,MAAM,UAAU,WAAW,KAAK,GAAG,OAAO;AAC5E,UAAI,CAAC,KAAK,SAAU,OAAM,IAAI,MAAM,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM,OAAO,EAAE;AAC/E,YAAM,UAAU,MAAM,QAAQ,KAAK,KAAK,cAAc,OAAO;AAC7D,UAAI,QAAQ,WAAW,OAAQ,OAAM,IAAI,MAAM,eAAe,QAAQ,MAAM,EAAE;AAC9E,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,MAAM,QAAQ;AACZ,YAAM,OAAO,IAAI,aAAa,EAAE,OAAO,OAAO;AAC9C,YAAM,QAAQ,QAAQ,OAAO;AAC7B,YAAM,OAAO,QAAQ,OAAO;AAC5B,YAAM,OAAO,QAAQ;AAAA,IACvB;AAAA,EACF;AACF;",
+  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceBinding,\n  type ReplicatedState,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport { Client, createClientServiceTransport } from '@earendil-works/pi-client';\nimport type { ConversationView } from '@earendil-works/pi-durable';\nimport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  AgentTranscript,\n  type SendMode,\n} from './services.ts';\nimport { AgentSettings } from './settings.ts';\nimport { PortChannel, type PortEndpoint } from './wire.ts';\n\nexport interface AgentConnection {\n  readonly serverId: string;\n  readonly control: AgentControl;\n  readonly transcript: ReplicatedState<ConversationView>;\n  readonly settings: AgentSettings;\n  prompt(text: string, whenBusy?: SendMode): Promise<string>;\n  close(): Promise<void>;\n}\n\nfunction attached(client: Client): Promise<void> {\n  return new Promise((resolve) => {\n    const stop = client.onAttachmentChange(() => {\n      stop();\n      resolve();\n    });\n  });\n}\n\nexport async function connectAgent(\n  endpoint: PortEndpoint,\n  options: { context?: Context } = {}\n): Promise<AgentConnection> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const channel = new PortChannel(endpoint);\n  const serverId = await channel.hello;\n  const client = await Client.connect({ serverId, transportFactory: channel.transport });\n  const server = createRemoteServiceBinding({\n    services: [AgentSessions],\n    transport: createClientServiceTransport(client, () => ({ serverId })),\n    bound: true,\n  });\n  const ready = attached(client);\n  await server.use(AgentSessions).attach(AGENT_SESSION, context);\n  await ready;\n  const session = createRemoteServiceBinding({\n    services: [AgentControl, AgentTranscript, AgentSettings],\n    transport: createClientServiceTransport(client, () => client.attachment),\n    bound: true,\n  });\n  const control = session.use(AgentControl);\n  const transcript = session.use(AgentTranscript).state;\n  const settings = session.use(AgentSettings);\n  await session.ready(context);\n  return {\n    serverId,\n    control,\n    transcript,\n    settings,\n    async prompt(text, whenBusy = 'followUp') {\n      const sent = await control.send({ text, whenBusy, requestId: null }, context);\n      if (!sent.accepted) throw new Error(`${sent.error.code}: ${sent.error.message}`);\n      const settled = await control.wait(sent.submissionId, context);\n      if (settled.status !== 'done') throw new Error(`unanswered: ${settled.reason}`);\n      return settled.text;\n    },\n    async close() {\n      await server.use(AgentSessions).detach(context);\n      await session.dispose(context);\n      await server.dispose(context);\n      await client.dispose();\n    },\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EAEE;AAAA,OAEK;AACP,SAAS,0BAA0B;AACnC,SAAS,QAAQ,oCAAoC;AAErD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,qBAAqB;AAC9B,SAAS,mBAAsC;AAW/C,SAAS,SAAS,QAA+B;AAC/C,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,OAAO,OAAO,mBAAmB,MAAM;AAC3C,WAAK;AACL,cAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,aACpB,UACA,UAAiC,CAAC,GACR;AAC1B,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,IAAI,YAAY,QAAQ;AACxC,QAAM,WAAW,MAAM,QAAQ;AAC/B,QAAM,SAAS,MAAM,OAAO,QAAQ,EAAE,UAAU,kBAAkB,QAAQ,UAAU,CAAC;AACrF,QAAM,SAAS,2BAA2B;AAAA,IACxC,UAAU,CAAC,aAAa;AAAA,IACxB,WAAW,6BAA6B,QAAQ,OAAO,EAAE,SAAS,EAAE;AAAA,IACpE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,QAAQ,SAAS,MAAM;AAC7B,QAAM,OAAO,IAAI,aAAa,EAAE,OAAO,eAAe,OAAO;AAC7D,QAAM;AACN,QAAM,UAAU,2BAA2B;AAAA,IACzC,UAAU,CAAC,cAAc,iBAAiB,aAAa;AAAA,IACvD,WAAW,6BAA6B,QAAQ,MAAM,OAAO,UAAU;AAAA,IACvE,OAAO;AAAA,EACT,CAAC;AACD,QAAM,UAAU,QAAQ,IAAI,YAAY;AACxC,QAAM,aAAa,QAAQ,IAAI,eAAe,EAAE;AAChD,QAAM,WAAW,QAAQ,IAAI,aAAa;AAC1C,QAAM,QAAQ,MAAM,OAAO;AAC3B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,OAAO,MAAM,WAAW,YAAY;AACxC,YAAM,OAAO,MAAM,QAAQ,KAAK,EAAE,MAAM,UAAU,WAAW,KAAK,GAAG,OAAO;AAC5E,UAAI,CAAC,KAAK,SAAU,OAAM,IAAI,MAAM,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM,OAAO,EAAE;AAC/E,YAAM,UAAU,MAAM,QAAQ,KAAK,KAAK,cAAc,OAAO;AAC7D,UAAI,QAAQ,WAAW,OAAQ,OAAM,IAAI,MAAM,eAAe,QAAQ,MAAM,EAAE;AAC9E,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,MAAM,QAAQ;AACZ,YAAM,OAAO,IAAI,aAAa,EAAE,OAAO,OAAO;AAC9C,YAAM,QAAQ,QAAQ,OAAO;AAC7B,YAAM,OAAO,QAAQ,OAAO;AAC5B,YAAM,OAAO,QAAQ;AAAA,IACvB;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/credentials.js

@@ -0,0 +1,100 @@
+const CREDENTIALS_DATABASE = "slicc-agent-credentials";
+function request(operation) {
+  return new Promise((resolve, reject) => {
+    operation.onsuccess = () => resolve(operation.result);
+    operation.onerror = () => reject(operation.error);
+  });
+}
+function open(name) {
+  const opening = indexedDB.open(name, 1);
+  opening.onupgradeneeded = () => {
+    opening.result.createObjectStore("keys");
+    opening.result.createObjectStore("credentials");
+  };
+  return request(opening);
+}
+async function sealingKey(db) {
+  const keys = db.transaction("keys", "readonly").objectStore("keys");
+  const existing = await request(keys.get("aes"));
+  if (existing) return existing;
+  const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+    "encrypt",
+    "decrypt"
+  ]);
+  const store = db.transaction("keys", "readwrite").objectStore("keys");
+  await request(store.add(key, "aes")).catch(() => void 0);
+  return await request(
+    db.transaction("keys", "readonly").objectStore("keys").get("aes")
+  );
+}
+class EncryptedCredentialStore {
+  #db;
+  #key;
+  #chains = /* @__PURE__ */ new Map();
+  constructor(db, key) {
+    this.#db = db;
+    this.#key = key;
+  }
+  static async open(name = CREDENTIALS_DATABASE) {
+    const db = await open(name);
+    return new EncryptedCredentialStore(db, await sealingKey(db));
+  }
+  #store(mode) {
+    return this.#db.transaction("credentials", mode).objectStore("credentials");
+  }
+  async read(providerId) {
+    const sealed = await request(this.#store("readonly").get(providerId));
+    if (!sealed) return void 0;
+    const plain = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: sealed.iv },
+      this.#key,
+      sealed.data
+    );
+    return JSON.parse(new TextDecoder().decode(plain));
+  }
+  async list() {
+    const ids = await request(this.#store("readonly").getAllKeys());
+    const found = [];
+    for (const providerId of ids) {
+      const credential = await this.read(providerId);
+      if (credential) found.push({ providerId, type: credential.type });
+    }
+    return found;
+  }
+  #serial(providerId, operation) {
+    const result = (this.#chains.get(providerId) ?? Promise.resolve()).then(operation);
+    this.#chains.set(
+      providerId,
+      result.catch(() => void 0)
+    );
+    return result;
+  }
+  modify(providerId, fn) {
+    return this.#serial(providerId, async () => {
+      const current = await this.read(providerId);
+      const next = await fn(current);
+      if (next === void 0) return current;
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const data = await crypto.subtle.encrypt(
+        { name: "AES-GCM", iv },
+        this.#key,
+        new TextEncoder().encode(JSON.stringify(next))
+      );
+      await request(this.#store("readwrite").put({ iv, data }, providerId));
+      return next;
+    });
+  }
+  delete(providerId) {
+    return this.#serial(providerId, async () => {
+      await request(this.#store("readwrite").delete(providerId));
+    });
+  }
+  close() {
+    this.#db.close();
+  }
+}
+export {
+  CREDENTIALS_DATABASE,
+  EncryptedCredentialStore
+};
+//# sourceMappingURL=credentials.js.map

package/dist/credentials.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/credentials.ts"],
+  "sourcesContent": ["import type { Credential, CredentialInfo, CredentialStore } from '@earendil-works/pi-ai';\n\nexport const CREDENTIALS_DATABASE = 'slicc-agent-credentials';\n\ninterface Sealed {\n  iv: Uint8Array<ArrayBuffer>;\n  data: ArrayBuffer;\n}\n\nfunction request<T>(operation: IDBRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    operation.onsuccess = () => resolve(operation.result);\n    operation.onerror = () => reject(operation.error);\n  });\n}\n\nfunction open(name: string): Promise<IDBDatabase> {\n  const opening = indexedDB.open(name, 1);\n  opening.onupgradeneeded = () => {\n    opening.result.createObjectStore('keys');\n    opening.result.createObjectStore('credentials');\n  };\n  return request(opening);\n}\n\nasync function sealingKey(db: IDBDatabase): Promise<CryptoKey> {\n  const keys = db.transaction('keys', 'readonly').objectStore('keys');\n  const existing = (await request(keys.get('aes'))) as CryptoKey | undefined;\n  if (existing) return existing;\n  const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, [\n    'encrypt',\n    'decrypt',\n  ]);\n  const store = db.transaction('keys', 'readwrite').objectStore('keys');\n  await request(store.add(key, 'aes')).catch(() => undefined);\n  return (await request(\n    db.transaction('keys', 'readonly').objectStore('keys').get('aes')\n  )) as CryptoKey;\n}\n\nexport class EncryptedCredentialStore implements CredentialStore {\n  readonly #db: IDBDatabase;\n  readonly #key: CryptoKey;\n  readonly #chains = new Map<string, Promise<unknown>>();\n\n  private constructor(db: IDBDatabase, key: CryptoKey) {\n    this.#db = db;\n    this.#key = key;\n  }\n\n  static async open(name = CREDENTIALS_DATABASE): Promise<EncryptedCredentialStore> {\n    const db = await open(name);\n    return new EncryptedCredentialStore(db, await sealingKey(db));\n  }\n\n  #store(mode: IDBTransactionMode): IDBObjectStore {\n    return this.#db.transaction('credentials', mode).objectStore('credentials');\n  }\n\n  async read(providerId: string): Promise<Credential | undefined> {\n    const sealed = (await request(this.#store('readonly').get(providerId))) as Sealed | undefined;\n    if (!sealed) return undefined;\n    const plain = await crypto.subtle.decrypt(\n      { name: 'AES-GCM', iv: sealed.iv },\n      this.#key,\n      sealed.data\n    );\n    return JSON.parse(new TextDecoder().decode(plain)) as Credential;\n  }\n\n  async list(): Promise<readonly CredentialInfo[]> {\n    const ids = (await request(this.#store('readonly').getAllKeys())) as string[];\n    const found: CredentialInfo[] = [];\n    for (const providerId of ids) {\n      const credential = await this.read(providerId);\n      if (credential) found.push({ providerId, type: credential.type });\n    }\n    return found;\n  }\n\n  #serial<T>(providerId: string, operation: () => Promise<T>): Promise<T> {\n    const result = (this.#chains.get(providerId) ?? Promise.resolve()).then(operation);\n    this.#chains.set(\n      providerId,\n      result.catch(() => undefined)\n    );\n    return result;\n  }\n\n  modify(\n    providerId: string,\n    fn: (current: Credential | undefined) => Promise<Credential | undefined>\n  ): Promise<Credential | undefined> {\n    return this.#serial(providerId, async () => {\n      const current = await this.read(providerId);\n      const next = await fn(current);\n      if (next === undefined) return current;\n      const iv = crypto.getRandomValues(new Uint8Array(12));\n      const data = await crypto.subtle.encrypt(\n        { name: 'AES-GCM', iv },\n        this.#key,\n        new TextEncoder().encode(JSON.stringify(next))\n      );\n      await request(this.#store('readwrite').put({ iv, data } satisfies Sealed, providerId));\n      return next;\n    });\n  }\n\n  delete(providerId: string): Promise<void> {\n    return this.#serial(providerId, async () => {\n      await request(this.#store('readwrite').delete(providerId));\n    });\n  }\n\n  close(): void {\n    this.#db.close();\n  }\n}\n"],
+  "mappings": "AAEO,MAAM,uBAAuB;AAOpC,SAAS,QAAW,WAAsC;AACxD,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,cAAU,YAAY,MAAM,QAAQ,UAAU,MAAM;AACpD,cAAU,UAAU,MAAM,OAAO,UAAU,KAAK;AAAA,EAClD,CAAC;AACH;AAEA,SAAS,KAAK,MAAoC;AAChD,QAAM,UAAU,UAAU,KAAK,MAAM,CAAC;AACtC,UAAQ,kBAAkB,MAAM;AAC9B,YAAQ,OAAO,kBAAkB,MAAM;AACvC,YAAQ,OAAO,kBAAkB,aAAa;AAAA,EAChD;AACA,SAAO,QAAQ,OAAO;AACxB;AAEA,eAAe,WAAW,IAAqC;AAC7D,QAAM,OAAO,GAAG,YAAY,QAAQ,UAAU,EAAE,YAAY,MAAM;AAClE,QAAM,WAAY,MAAM,QAAQ,KAAK,IAAI,KAAK,CAAC;AAC/C,MAAI,SAAU,QAAO;AACrB,QAAM,MAAM,MAAM,OAAO,OAAO,YAAY,EAAE,MAAM,WAAW,QAAQ,IAAI,GAAG,OAAO;AAAA,IACnF;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,QAAQ,GAAG,YAAY,QAAQ,WAAW,EAAE,YAAY,MAAM;AACpE,QAAM,QAAQ,MAAM,IAAI,KAAK,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AAC1D,SAAQ,MAAM;AAAA,IACZ,GAAG,YAAY,QAAQ,UAAU,EAAE,YAAY,MAAM,EAAE,IAAI,KAAK;AAAA,EAClE;AACF;AAEO,MAAM,yBAAoD;AAAA,EACtD;AAAA,EACA;AAAA,EACA,UAAU,oBAAI,IAA8B;AAAA,EAE7C,YAAY,IAAiB,KAAgB;AACnD,SAAK,MAAM;AACX,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,aAAa,KAAK,OAAO,sBAAyD;AAChF,UAAM,KAAK,MAAM,KAAK,IAAI;AAC1B,WAAO,IAAI,yBAAyB,IAAI,MAAM,WAAW,EAAE,CAAC;AAAA,EAC9D;AAAA,EAEA,OAAO,MAA0C;AAC/C,WAAO,KAAK,IAAI,YAAY,eAAe,IAAI,EAAE,YAAY,aAAa;AAAA,EAC5E;AAAA,EAEA,MAAM,KAAK,YAAqD;AAC9D,UAAM,SAAU,MAAM,QAAQ,KAAK,OAAO,UAAU,EAAE,IAAI,UAAU,CAAC;AACrE,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,QAAQ,MAAM,OAAO,OAAO;AAAA,MAChC,EAAE,MAAM,WAAW,IAAI,OAAO,GAAG;AAAA,MACjC,KAAK;AAAA,MACL,OAAO;AAAA,IACT;AACA,WAAO,KAAK,MAAM,IAAI,YAAY,EAAE,OAAO,KAAK,CAAC;AAAA,EACnD;AAAA,EAEA,MAAM,OAA2C;AAC/C,UAAM,MAAO,MAAM,QAAQ,KAAK,OAAO,UAAU,EAAE,WAAW,CAAC;AAC/D,UAAM,QAA0B,CAAC;AACjC,eAAW,cAAc,KAAK;AAC5B,YAAM,aAAa,MAAM,KAAK,KAAK,UAAU;AAC7C,UAAI,WAAY,OAAM,KAAK,EAAE,YAAY,MAAM,WAAW,KAAK,CAAC;AAAA,IAClE;AACA,WAAO;AAAA,EACT;AAAA,EAEA,QAAW,YAAoB,WAAyC;AACtE,UAAM,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,QAAQ,QAAQ,GAAG,KAAK,SAAS;AACjF,SAAK,QAAQ;AAAA,MACX;AAAA,MACA,OAAO,MAAM,MAAM,MAAS;AAAA,IAC9B;AACA,WAAO;AAAA,EACT;AAAA,EAEA,OACE,YACA,IACiC;AACjC,WAAO,KAAK,QAAQ,YAAY,YAAY;AAC1C,YAAM,UAAU,MAAM,KAAK,KAAK,UAAU;AAC1C,YAAM,OAAO,MAAM,GAAG,OAAO;AAC7B,UAAI,SAAS,OAAW,QAAO;AAC/B,YAAM,KAAK,OAAO,gBAAgB,IAAI,WAAW,EAAE,CAAC;AACpD,YAAM,OAAO,MAAM,OAAO,OAAO;AAAA,QAC/B,EAAE,MAAM,WAAW,GAAG;AAAA,QACtB,KAAK;AAAA,QACL,IAAI,YAAY,EAAE,OAAO,KAAK,UAAU,IAAI,CAAC;AAAA,MAC/C;AACA,YAAM,QAAQ,KAAK,OAAO,WAAW,EAAE,IAAI,EAAE,IAAI,KAAK,GAAoB,UAAU,CAAC;AACrF,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,OAAO,YAAmC;AACxC,WAAO,KAAK,QAAQ,YAAY,YAAY;AAC1C,YAAM,QAAQ,KAAK,OAAO,WAAW,EAAE,OAAO,UAAU,CAAC;AAAA,IAC3D,CAAC;AAAA,EACH;AAAA,EAEA,QAAc;AACZ,SAAK,IAAI,MAAM;AAAA,EACjB;AACF;",
+  "names": []
+}

package/dist/host.js

@@ -1,6 +1,7 @@
 import {
   createRemoteServiceEndpoint,
-  RemoteServiceProvider
+  RemoteServiceProvider,
+  replicatedState
 } from "@earendil-works/chord";
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import {
@@ -9,6 +10,7 @@ import {
 } from "@earendil-works/pi-server";
 import { createAgentControl } from "./control.js";
 import { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript } from "./services.js";
+import { AgentSettings } from "./settings.js";
 import { PortListener } from "./wire.js";
 function endpointFor(provider) {
   const endpoint = createRemoteServiceEndpoint(provider);
@@ -43,16 +45,26 @@ function serverServices() {
     }
   };
 }
+const noSettings = {
+  state: replicatedState({ models: [], accounts: [] }),
+  connect: async () => {
+    throw new Error("this agent has no accounts");
+  },
+  disconnect: async () => {
+  }
+};
 async function hostAgent(agent, options = {}) {
   const context = options.context ?? BACKGROUND_CONTEXT;
   const serverId = options.serverId ?? crypto.randomUUID();
   const state = await agent.root.viewState(context);
   const provider = new RemoteServiceProvider([
     { service: AgentControl, mode: "singleton" },
-    { service: AgentTranscript, mode: "singleton" }
+    { service: AgentTranscript, mode: "singleton" },
+    { service: AgentSettings, mode: "singleton" }
   ]);
   provider.provide(AgentControl, createAgentControl(agent.harness, agent.root));
   provider.provide(AgentTranscript, { state });
+  provider.provide(AgentSettings, options.settings ?? noSettings);
   const host = {
     serverServices: serverServices(),
     async resolveSession(sessionId) {

package/dist/host.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/host.ts"],
-  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceEndpoint,\n  RemoteServiceProvider,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport {\n  type RoutedServerServiceHost,\n  type RoutedSessionAttachment,\n  type RoutedSessionHandle,\n  Server,\n  type ServerHost,\n  SessionNotFoundError,\n} from '@earendil-works/pi-server';\nimport type { Agent } from './agent.ts';\nimport { createAgentControl } from './control.ts';\nimport { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript } from './services.ts';\nimport { type PortEndpoint, PortListener } from './wire.ts';\n\nexport interface AgentHost {\n  readonly serverId: string;\n  readonly agent: Agent;\n  connect(endpoint: PortEndpoint): void;\n  close(): Promise<void>;\n}\n\nfunction endpointFor(provider: RemoteServiceProvider): RoutedSessionAttachment {\n  const endpoint = createRemoteServiceEndpoint(provider);\n  return {\n    invokeService: (call, publish, context) =>\n      endpoint.invoke(call, (id, update) => publish(id, update, context), context),\n    release: () => endpoint.dispose(),\n  };\n}\n\nfunction sessionServices(provider: RemoteServiceProvider): RoutedSessionHandle {\n  return {\n    attachClient: () => endpointFor(provider),\n    close: async () => {},\n  };\n}\n\nfunction serverServices(): RoutedServerServiceHost {\n  return {\n    attachClient(presentation) {\n      const provider = new RemoteServiceProvider([{ service: AgentSessions, mode: 'singleton' }]);\n      provider.provide(AgentSessions, {\n        attach: (sessionId, context) => presentation.attachSession(sessionId, context),\n        detach: (context) => presentation.detachSession(context),\n      });\n      const attachment = endpointFor(provider);\n      return {\n        invokeService: attachment.invokeService,\n        release(context) {\n          attachment.release(context);\n          provider.dispose();\n        },\n      };\n    },\n  };\n}\n\nexport async function hostAgent(\n  agent: Agent,\n  options: { serverId?: string; context?: Context } = {}\n): Promise<AgentHost> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const serverId = options.serverId ?? crypto.randomUUID();\n  const state = await agent.root.viewState(context);\n  const provider = new RemoteServiceProvider([\n    { service: AgentControl, mode: 'singleton' },\n    { service: AgentTranscript, mode: 'singleton' },\n  ]);\n  provider.provide(AgentControl, createAgentControl(agent.harness, agent.root));\n  provider.provide(AgentTranscript, { state });\n  const host: ServerHost = {\n    serverServices: serverServices(),\n    async resolveSession(sessionId) {\n      if (sessionId !== AGENT_SESSION)\n        throw new SessionNotFoundError(`unknown session ${sessionId}`);\n      return { id: sessionId };\n    },\n    openSession: async () => sessionServices(provider),\n  };\n  const listener = new PortListener(serverId);\n  const server = await new Server(host, { serverId, listeners: [listener] }).start();\n  return {\n    serverId,\n    agent,\n    connect: (endpoint) => listener.connect(endpoint),\n    async close() {\n      await server.close();\n      provider.dispose();\n      state.dispose();\n      await agent.close();\n    },\n  };\n}\n"],
-  "mappings": "AAAA;AAAA,EAEE;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AACnC;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;AAEP,SAAS,0BAA0B;AACnC,SAAS,eAAe,cAAc,eAAe,uBAAuB;AAC5E,SAA4B,oBAAoB;AAShD,SAAS,YAAY,UAA0D;AAC7E,QAAM,WAAW,4BAA4B,QAAQ;AACrD,SAAO;AAAA,IACL,eAAe,CAAC,MAAM,SAAS,YAC7B,SAAS,OAAO,MAAM,CAAC,IAAI,WAAW,QAAQ,IAAI,QAAQ,OAAO,GAAG,OAAO;AAAA,IAC7E,SAAS,MAAM,SAAS,QAAQ;AAAA,EAClC;AACF;AAEA,SAAS,gBAAgB,UAAsD;AAC7E,SAAO;AAAA,IACL,cAAc,MAAM,YAAY,QAAQ;AAAA,IACxC,OAAO,YAAY;AAAA,IAAC;AAAA,EACtB;AACF;AAEA,SAAS,iBAA0C;AACjD,SAAO;AAAA,IACL,aAAa,cAAc;AACzB,YAAM,WAAW,IAAI,sBAAsB,CAAC,EAAE,SAAS,eAAe,MAAM,YAAY,CAAC,CAAC;AAC1F,eAAS,QAAQ,eAAe;AAAA,QAC9B,QAAQ,CAAC,WAAW,YAAY,aAAa,cAAc,WAAW,OAAO;AAAA,QAC7E,QAAQ,CAAC,YAAY,aAAa,cAAc,OAAO;AAAA,MACzD,CAAC;AACD,YAAM,aAAa,YAAY,QAAQ;AACvC,aAAO;AAAA,QACL,eAAe,WAAW;AAAA,QAC1B,QAAQ,SAAS;AACf,qBAAW,QAAQ,OAAO;AAC1B,mBAAS,QAAQ;AAAA,QACnB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAsB,UACpB,OACA,UAAoD,CAAC,GACjC;AACpB,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,WAAW,QAAQ,YAAY,OAAO,WAAW;AACvD,QAAM,QAAQ,MAAM,MAAM,KAAK,UAAU,OAAO;AAChD,QAAM,WAAW,IAAI,sBAAsB;AAAA,IACzC,EAAE,SAAS,cAAc,MAAM,YAAY;AAAA,IAC3C,EAAE,SAAS,iBAAiB,MAAM,YAAY;AAAA,EAChD,CAAC;AACD,WAAS,QAAQ,cAAc,mBAAmB,MAAM,SAAS,MAAM,IAAI,CAAC;AAC5E,WAAS,QAAQ,iBAAiB,EAAE,MAAM,CAAC;AAC3C,QAAM,OAAmB;AAAA,IACvB,gBAAgB,eAAe;AAAA,IAC/B,MAAM,eAAe,WAAW;AAC9B,UAAI,cAAc;AAChB,cAAM,IAAI,qBAAqB,mBAAmB,SAAS,EAAE;AAC/D,aAAO,EAAE,IAAI,UAAU;AAAA,IACzB;AAAA,IACA,aAAa,YAAY,gBAAgB,QAAQ;AAAA,EACnD;AACA,QAAM,WAAW,IAAI,aAAa,QAAQ;AAC1C,QAAM,SAAS,MAAM,IAAI,OAAO,MAAM,EAAE,UAAU,WAAW,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM;AACjF,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,CAAC,aAAa,SAAS,QAAQ,QAAQ;AAAA,IAChD,MAAM,QAAQ;AACZ,YAAM,OAAO,MAAM;AACnB,eAAS,QAAQ;AACjB,YAAM,QAAQ;AACd,YAAM,MAAM,MAAM;AAAA,IACpB;AAAA,EACF;AACF;",
+  "sourcesContent": ["import {\n  type Context,\n  createRemoteServiceEndpoint,\n  RemoteServiceProvider,\n  replicatedState,\n} from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport {\n  type RoutedServerServiceHost,\n  type RoutedSessionAttachment,\n  type RoutedSessionHandle,\n  Server,\n  type ServerHost,\n  SessionNotFoundError,\n} from '@earendil-works/pi-server';\nimport type { Agent } from './agent.ts';\nimport { createAgentControl } from './control.ts';\nimport { AGENT_SESSION, AgentControl, AgentSessions, AgentTranscript } from './services.ts';\nimport { AgentSettings } from './settings.ts';\nimport { type PortEndpoint, PortListener } from './wire.ts';\n\nexport interface AgentHost {\n  readonly serverId: string;\n  readonly agent: Agent;\n  connect(endpoint: PortEndpoint): void;\n  close(): Promise<void>;\n}\n\nfunction endpointFor(provider: RemoteServiceProvider): RoutedSessionAttachment {\n  const endpoint = createRemoteServiceEndpoint(provider);\n  return {\n    invokeService: (call, publish, context) =>\n      endpoint.invoke(call, (id, update) => publish(id, update, context), context),\n    release: () => endpoint.dispose(),\n  };\n}\n\nfunction sessionServices(provider: RemoteServiceProvider): RoutedSessionHandle {\n  return {\n    attachClient: () => endpointFor(provider),\n    close: async () => {},\n  };\n}\n\nfunction serverServices(): RoutedServerServiceHost {\n  return {\n    attachClient(presentation) {\n      const provider = new RemoteServiceProvider([{ service: AgentSessions, mode: 'singleton' }]);\n      provider.provide(AgentSessions, {\n        attach: (sessionId, context) => presentation.attachSession(sessionId, context),\n        detach: (context) => presentation.detachSession(context),\n      });\n      const attachment = endpointFor(provider);\n      return {\n        invokeService: attachment.invokeService,\n        release(context) {\n          attachment.release(context);\n          provider.dispose();\n        },\n      };\n    },\n  };\n}\n\nconst noSettings: AgentSettings = {\n  state: replicatedState({ models: [], accounts: [] }),\n  connect: async () => {\n    throw new Error('this agent has no accounts');\n  },\n  disconnect: async () => {},\n};\n\nexport async function hostAgent(\n  agent: Agent,\n  options: { serverId?: string; context?: Context; settings?: AgentSettings } = {}\n): Promise<AgentHost> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const serverId = options.serverId ?? crypto.randomUUID();\n  const state = await agent.root.viewState(context);\n  const provider = new RemoteServiceProvider([\n    { service: AgentControl, mode: 'singleton' },\n    { service: AgentTranscript, mode: 'singleton' },\n    { service: AgentSettings, mode: 'singleton' },\n  ]);\n  provider.provide(AgentControl, createAgentControl(agent.harness, agent.root));\n  provider.provide(AgentTranscript, { state });\n  provider.provide(AgentSettings, options.settings ?? noSettings);\n  const host: ServerHost = {\n    serverServices: serverServices(),\n    async resolveSession(sessionId) {\n      if (sessionId !== AGENT_SESSION)\n        throw new SessionNotFoundError(`unknown session ${sessionId}`);\n      return { id: sessionId };\n    },\n    openSession: async () => sessionServices(provider),\n  };\n  const listener = new PortListener(serverId);\n  const server = await new Server(host, { serverId, listeners: [listener] }).start();\n  return {\n    serverId,\n    agent,\n    connect: (endpoint) => listener.connect(endpoint),\n    async close() {\n      await server.close();\n      provider.dispose();\n      state.dispose();\n      await agent.close();\n    },\n  };\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/index.js

@@ -1,18 +1,32 @@
 import { answerText, openAgent } from "./agent.js";
 import { connectAgent } from "./client.js";
 import { createAgentControl } from "./control.js";
+import { CREDENTIALS_DATABASE, EncryptedCredentialStore } from "./credentials.js";
 import { hostAgent } from "./host.js";
 import { HOME, kernelEnvironment, SliccKernelEnv } from "./kernel/env.js";
+import {
+  runAgentWorker
+} from "./main.js";
+import { transportFetch } from "./net.js";
 import {
   AGENT_LOCK,
   startAgent
 } from "./owner.js";
+import { SliccPrompt } from "./prompt.js";
 import {
   AGENT_SESSION,
   AgentControl,
   AgentSessions,
   AgentTranscript
 } from "./services.js";
+import {
+  AgentSettings,
+  BEDROCK,
+  createAgentSettings,
+  createSliccModels,
+  DEFAULT_MODEL,
+  sliccProviders
+} from "./settings.js";
 import {
   AGENT_DIRECTORY,
   openMemorySqliteStorage,
@@ -27,23 +41,34 @@ export {
   AGENT_SESSION,
   AgentControl,
   AgentSessions,
+  AgentSettings,
   AgentTranscript,
+  BEDROCK,
+  CREDENTIALS_DATABASE,
+  DEFAULT_MODEL,
+  EncryptedCredentialStore,
   HOME,
   PortChannel,
   PortListener,
   SliccKernelEnv,
+  SliccPrompt,
   WasmSqliteDatabase,
   answerText,
   connectAgent,
   createAgentControl,
+  createAgentSettings,
+  createSliccModels,
   hostAgent,
   kernelEnvironment,
   kernelPort,
   openAgent,
   openMemorySqliteStorage,
   openOpfsSqliteStorage,
+  runAgentWorker,
   serveConnections,
+  sliccProviders,
   startAgent,
+  transportFetch,
   withUnrefTimers
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport { type AgentConnection, connectAgent } from './client.ts';\nexport { createAgentControl } from './control.ts';\nexport { type AgentHost, hostAgent } from './host.ts';\nexport type {\n  KernelClient,\n  KernelFs,\n  KernelProcess,\n  KernelStat,\n  SpawnOptions,\n} from './kernel/client.ts';\nexport { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';\nexport {\n  AGENT_LOCK,\n  type AgentOwner,\n  type AgentWorker,\n  type OwnerOptions,\n  startAgent,\n} from './owner.ts';\nexport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  type AgentSettingsChange,\n  AgentTranscript,\n  type OperationError,\n  type PromptResult,\n  type SendMode,\n  type SendRequest,\n  type SendResponse,\n} from './services.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\nexport { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';\nexport { kernelPort, serveConnections, type WorkerScope } from './worker.ts';\n"],
-  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE,SAA+B,oBAAoB;AACnD,SAAS,0BAA0B;AACnC,SAAyB,iBAAiB;AAQ1C,SAAS,MAA6B,mBAAmB,sBAAsB;AAC/E;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,OAMK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAgC,cAAc,uBAAuB;AAC9E,SAAS,YAAY,wBAA0C;",
+  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport { type AgentConnection, connectAgent } from './client.ts';\nexport { createAgentControl } from './control.ts';\nexport { CREDENTIALS_DATABASE, EncryptedCredentialStore } from './credentials.ts';\nexport { type AgentHost, hostAgent } from './host.ts';\nexport type {\n  KernelClient,\n  KernelFs,\n  KernelProcess,\n  KernelStat,\n  SpawnOptions,\n} from './kernel/client.ts';\nexport { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';\nexport {\n  type AgentWorkerOptions,\n  type AgentWorkerScope,\n  type KernelAttach,\n  runAgentWorker,\n} from './main.ts';\nexport { type Transport, type TransportResponse, transportFetch } from './net.ts';\nexport {\n  AGENT_LOCK,\n  type AgentOwner,\n  type AgentWorker,\n  type OwnerOptions,\n  startAgent,\n} from './owner.ts';\nexport { SliccPrompt } from './prompt.ts';\nexport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  type AgentSettingsChange,\n  AgentTranscript,\n  type OperationError,\n  type PromptResult,\n  type SendMode,\n  type SendRequest,\n  type SendResponse,\n} from './services.ts';\nexport {\n  type AccountState,\n  AgentSettings,\n  BEDROCK,\n  createAgentSettings,\n  createSliccModels,\n  DEFAULT_MODEL,\n  type ModelChoice,\n  type SettingsState,\n  sliccProviders,\n} from './settings.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\nexport { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';\nexport { kernelPort, serveConnections, type WorkerScope } from './worker.ts';\n"],
+  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE,SAA+B,oBAAoB;AACnD,SAAS,0BAA0B;AACnC,SAAS,sBAAsB,gCAAgC;AAC/D,SAAyB,iBAAiB;AAQ1C,SAAS,MAA6B,mBAAmB,sBAAsB;AAC/E;AAAA,EAIE;AAAA,OACK;AACP,SAAiD,sBAAsB;AACvE;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP,SAAS,mBAAmB;AAC5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,OAMK;AACP;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAGA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAgC,cAAc,uBAAuB;AAC9E,SAAS,YAAY,wBAA0C;",
   "names": []
 }

package/dist/main.js

@@ -0,0 +1,46 @@
+import { attachKernel } from "@ai-ecoverse/slicc-kernel";
+import { createRegistry } from "@earendil-works/pi-durable";
+import { CodingTools } from "@earendil-works/pi-durable/tools";
+import { openAgent } from "./agent.js";
+import { EncryptedCredentialStore } from "./credentials.js";
+import { hostAgent } from "./host.js";
+import { kernelEnvironment } from "./kernel/env.js";
+import { transportFetch } from "./net.js";
+import { SliccPrompt } from "./prompt.js";
+import {
+  createAgentSettings,
+  createSliccModels,
+  DEFAULT_MODEL,
+  sliccProviders
+} from "./settings.js";
+import { openOpfsSqliteStorage } from "./sqlite.js";
+import { kernelPort, serveConnections } from "./worker.js";
+async function start(scope, port, options) {
+  const attach = options.attach ?? attachKernel;
+  const client = await attach(await port);
+  scope.fetch = transportFetch(client.transport, scope.location.origin, scope.fetch.bind(scope));
+  const credentials = await (options.credentials ?? (() => EncryptedCredentialStore.open()))();
+  const providers = options.providers ?? sliccProviders();
+  const models = createSliccModels(credentials, providers);
+  const registry = createRegistry();
+  registry.install(CodingTools);
+  registry.install(SliccPrompt);
+  const agent = await openAgent({
+    models,
+    model: options.model ?? DEFAULT_MODEL,
+    storage: await (options.storage ?? (() => openOpfsSqliteStorage()))(),
+    registry,
+    env: kernelEnvironment(client)
+  });
+  return hostAgent(agent, { settings: await createAgentSettings(models, credentials, providers) });
+}
+function runAgentWorker(scope, options = {}) {
+  const host = start(scope, kernelPort(scope), options);
+  host.catch(() => void 0);
+  serveConnections(scope, host);
+  return host;
+}
+export {
+  runAgentWorker
+};
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/main.ts"],
+  "sourcesContent": ["import { attachKernel } from '@ai-ecoverse/slicc-kernel';\nimport type { CredentialStore, Provider } from '@earendil-works/pi-ai';\nimport { createRegistry, type ModelRef, type Storage } from '@earendil-works/pi-durable';\nimport { CodingTools } from '@earendil-works/pi-durable/tools';\nimport { openAgent } from './agent.ts';\nimport { EncryptedCredentialStore } from './credentials.ts';\nimport { type AgentHost, hostAgent } from './host.ts';\nimport type { KernelClient } from './kernel/client.ts';\nimport { kernelEnvironment } from './kernel/env.ts';\nimport { type Transport, transportFetch } from './net.ts';\nimport { SliccPrompt } from './prompt.ts';\nimport {\n  createAgentSettings,\n  createSliccModels,\n  DEFAULT_MODEL,\n  sliccProviders,\n} from './settings.ts';\nimport { openOpfsSqliteStorage } from './sqlite.ts';\nimport { kernelPort, serveConnections, type WorkerScope } from './worker.ts';\n\nexport interface AgentWorkerScope extends WorkerScope {\n  fetch: typeof fetch;\n  location: { origin: string };\n}\n\nexport type KernelAttach = (port: MessagePort) => Promise<KernelClient & { transport: Transport }>;\n\nexport interface AgentWorkerOptions {\n  model?: ModelRef;\n  providers?: Provider[];\n  attach?: KernelAttach;\n  credentials?: () => Promise<CredentialStore>;\n  storage?: () => Promise<Storage>;\n}\n\nasync function start(\n  scope: AgentWorkerScope,\n  port: Promise<MessagePort>,\n  options: AgentWorkerOptions\n): Promise<AgentHost> {\n  const attach: KernelAttach = options.attach ?? attachKernel;\n  const client = await attach(await port);\n  scope.fetch = transportFetch(client.transport, scope.location.origin, scope.fetch.bind(scope));\n  const credentials = await (options.credentials ?? (() => EncryptedCredentialStore.open()))();\n  const providers = options.providers ?? sliccProviders();\n  const models = createSliccModels(credentials, providers);\n  const registry = createRegistry();\n  registry.install(CodingTools);\n  registry.install(SliccPrompt);\n  const agent = await openAgent({\n    models,\n    model: options.model ?? DEFAULT_MODEL,\n    storage: await (options.storage ?? (() => openOpfsSqliteStorage()))(),\n    registry,\n    env: kernelEnvironment(client),\n  });\n  return hostAgent(agent, { settings: await createAgentSettings(models, credentials, providers) });\n}\n\nexport function runAgentWorker(\n  scope: AgentWorkerScope,\n  options: AgentWorkerOptions = {}\n): Promise<AgentHost> {\n  const host = start(scope, kernelPort(scope), options);\n  host.catch(() => undefined);\n  serveConnections(scope, host);\n  return host;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,SAAS,sBAAmD;AAC5D,SAAS,mBAAmB;AAC5B,SAAS,iBAAiB;AAC1B,SAAS,gCAAgC;AACzC,SAAyB,iBAAiB;AAE1C,SAAS,yBAAyB;AAClC,SAAyB,sBAAsB;AAC/C,SAAS,mBAAmB;AAC5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,YAAY,wBAA0C;AAiB/D,eAAe,MACb,OACA,MACA,SACoB;AACpB,QAAM,SAAuB,QAAQ,UAAU;AAC/C,QAAM,SAAS,MAAM,OAAO,MAAM,IAAI;AACtC,QAAM,QAAQ,eAAe,OAAO,WAAW,MAAM,SAAS,QAAQ,MAAM,MAAM,KAAK,KAAK,CAAC;AAC7F,QAAM,cAAc,OAAO,QAAQ,gBAAgB,MAAM,yBAAyB,KAAK,IAAI;AAC3F,QAAM,YAAY,QAAQ,aAAa,eAAe;AACtD,QAAM,SAAS,kBAAkB,aAAa,SAAS;AACvD,QAAM,WAAW,eAAe;AAChC,WAAS,QAAQ,WAAW;AAC5B,WAAS,QAAQ,WAAW;AAC5B,QAAM,QAAQ,MAAM,UAAU;AAAA,IAC5B;AAAA,IACA,OAAO,QAAQ,SAAS;AAAA,IACxB,SAAS,OAAO,QAAQ,YAAY,MAAM,sBAAsB,IAAI;AAAA,IACpE;AAAA,IACA,KAAK,kBAAkB,MAAM;AAAA,EAC/B,CAAC;AACD,SAAO,UAAU,OAAO,EAAE,UAAU,MAAM,oBAAoB,QAAQ,aAAa,SAAS,EAAE,CAAC;AACjG;AAEO,SAAS,eACd,OACA,UAA8B,CAAC,GACX;AACpB,QAAM,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG,OAAO;AACpD,OAAK,MAAM,MAAM,MAAS;AAC1B,mBAAiB,OAAO,IAAI;AAC5B,SAAO;AACT;",
+  "names": []
+}

package/dist/net.js

@@ -0,0 +1,39 @@
+const empty = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+function stream(body) {
+  const iterator = body[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const next = await iterator.next();
+      if (next.done) controller.close();
+      else controller.enqueue(next.value);
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+function transportFetch(transport, origin, native = globalThis.fetch.bind(globalThis)) {
+  return async (input, init) => {
+    const request = new Request(input, init);
+    if (new URL(request.url).origin === origin || transport.traits?.crossOrigin === "cors") {
+      return native(request);
+    }
+    const body = ["GET", "HEAD"].includes(request.method) ? void 0 : new Uint8Array(await request.arrayBuffer());
+    const response = await transport.fetch({
+      url: request.url,
+      method: request.method,
+      headers: [...request.headers],
+      ...body ? { body } : {},
+      signal: request.signal
+    });
+    return new Response(empty.has(response.status) ? null : stream(response.body), {
+      status: response.status,
+      statusText: response.statusText ?? "",
+      headers: response.headers
+    });
+  };
+}
+export {
+  transportFetch
+};
+//# sourceMappingURL=net.js.map

package/dist/net.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/net.ts"],
+  "sourcesContent": ["export interface TransportResponse {\n  status: number;\n  statusText?: string;\n  headers: HeadersInit;\n  body: AsyncIterable<Uint8Array>;\n}\n\nexport interface Transport {\n  traits?: { crossOrigin?: 'cors' | 'any' };\n  fetch(request: {\n    url: string;\n    method: string;\n    headers: [string, string][];\n    body?: Uint8Array;\n    signal?: AbortSignal;\n  }): Promise<TransportResponse>;\n}\n\nconst empty = new Set([101, 103, 204, 205, 304]);\n\nfunction stream(body: AsyncIterable<Uint8Array>): ReadableStream<Uint8Array> {\n  const iterator = body[Symbol.asyncIterator]();\n  return new ReadableStream({\n    async pull(controller) {\n      const next = await iterator.next();\n      if (next.done) controller.close();\n      else controller.enqueue(next.value);\n    },\n    async cancel() {\n      await iterator.return?.();\n    },\n  });\n}\n\nexport function transportFetch(\n  transport: Transport,\n  origin: string,\n  native: typeof fetch = globalThis.fetch.bind(globalThis)\n): typeof fetch {\n  return async (input, init) => {\n    const request = new Request(input, init);\n    if (new URL(request.url).origin === origin || transport.traits?.crossOrigin === 'cors') {\n      return native(request);\n    }\n    const body = ['GET', 'HEAD'].includes(request.method)\n      ? undefined\n      : new Uint8Array(await request.arrayBuffer());\n    const response = await transport.fetch({\n      url: request.url,\n      method: request.method,\n      headers: [...request.headers],\n      ...(body ? { body } : {}),\n      signal: request.signal,\n    });\n    return new Response(empty.has(response.status) ? null : stream(response.body), {\n      status: response.status,\n      statusText: response.statusText ?? '',\n      headers: response.headers,\n    });\n  };\n}\n"],
+  "mappings": "AAkBA,MAAM,QAAQ,oBAAI,IAAI,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG,CAAC;AAE/C,SAAS,OAAO,MAA6D;AAC3E,QAAM,WAAW,KAAK,OAAO,aAAa,EAAE;AAC5C,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,KAAK,YAAY;AACrB,YAAM,OAAO,MAAM,SAAS,KAAK;AACjC,UAAI,KAAK,KAAM,YAAW,MAAM;AAAA,UAC3B,YAAW,QAAQ,KAAK,KAAK;AAAA,IACpC;AAAA,IACA,MAAM,SAAS;AACb,YAAM,SAAS,SAAS;AAAA,IAC1B;AAAA,EACF,CAAC;AACH;AAEO,SAAS,eACd,WACA,QACA,SAAuB,WAAW,MAAM,KAAK,UAAU,GACzC;AACd,SAAO,OAAO,OAAO,SAAS;AAC5B,UAAM,UAAU,IAAI,QAAQ,OAAO,IAAI;AACvC,QAAI,IAAI,IAAI,QAAQ,GAAG,EAAE,WAAW,UAAU,UAAU,QAAQ,gBAAgB,QAAQ;AACtF,aAAO,OAAO,OAAO;AAAA,IACvB;AACA,UAAM,OAAO,CAAC,OAAO,MAAM,EAAE,SAAS,QAAQ,MAAM,IAChD,SACA,IAAI,WAAW,MAAM,QAAQ,YAAY,CAAC;AAC9C,UAAM,WAAW,MAAM,UAAU,MAAM;AAAA,MACrC,KAAK,QAAQ;AAAA,MACb,QAAQ,QAAQ;AAAA,MAChB,SAAS,CAAC,GAAG,QAAQ,OAAO;AAAA,MAC5B,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,MACvB,QAAQ,QAAQ;AAAA,IAClB,CAAC;AACD,WAAO,IAAI,SAAS,MAAM,IAAI,SAAS,MAAM,IAAI,OAAO,OAAO,SAAS,IAAI,GAAG;AAAA,MAC7E,QAAQ,SAAS;AAAA,MACjB,YAAY,SAAS,cAAc;AAAA,MACnC,SAAS,SAAS;AAAA,IACpB,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/prompt.js

@@ -0,0 +1,18 @@
+import { defineExtension, section } from "@earendil-works/pi-durable";
+const PREAMBLE = [
+  "You are sliccy, the agent of SLICC. You run in a worker inside the user\u2019s browser tab.",
+  "Your tools work on slicc-kernel: bash and coreutils compiled to WebAssembly, on the browser\u2019s private file system.",
+  "The user can watch and stop your processes from a terminal next to this chat.",
+  "Be brief, do the work with your tools, and say what you changed."
+].join("\n");
+const SliccPrompt = defineExtension({
+  name: "slicc",
+  sections: [
+    section("preamble", () => PREAMBLE, { tag: false }),
+    section("cwd", (input) => input.env?.cwd)
+  ]
+});
+export {
+  SliccPrompt
+};
+//# sourceMappingURL=prompt.js.map

package/dist/prompt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/prompt.ts"],
+  "sourcesContent": ["import { defineExtension, section } from '@earendil-works/pi-durable';\n\nconst PREAMBLE = [\n  'You are sliccy, the agent of SLICC. You run in a worker inside the user\u2019s browser tab.',\n  'Your tools work on slicc-kernel: bash and coreutils compiled to WebAssembly, on the browser\u2019s private file system.',\n  'The user can watch and stop your processes from a terminal next to this chat.',\n  'Be brief, do the work with your tools, and say what you changed.',\n].join('\\n');\n\nexport const SliccPrompt = defineExtension({\n  name: 'slicc',\n  sections: [\n    section('preamble', () => PREAMBLE, { tag: false }),\n    section('cwd', (input) => input.env?.cwd),\n  ],\n});\n"],
+  "mappings": "AAAA,SAAS,iBAAiB,eAAe;AAEzC,MAAM,WAAW;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEJ,MAAM,cAAc,gBAAgB;AAAA,EACzC,MAAM;AAAA,EACN,UAAU;AAAA,IACR,QAAQ,YAAY,MAAM,UAAU,EAAE,KAAK,MAAM,CAAC;AAAA,IAClD,QAAQ,OAAO,CAAC,UAAU,MAAM,KAAK,GAAG;AAAA,EAC1C;AACF,CAAC;",
+  "names": []
+}

package/dist/settings.js

@@ -0,0 +1,77 @@
+import {
+  defineService,
+  replicatedState
+} from "@earendil-works/chord";
+import { createModels } from "@earendil-works/pi-ai/models";
+import { amazonBedrockProvider } from "@earendil-works/pi-ai/providers/amazon-bedrock";
+const BEDROCK = "amazon-bedrock";
+const DEFAULT_MODEL = { provider: BEDROCK, modelId: "us.anthropic.claude-sonnet-5-5" };
+const AgentSettings = defineService("slicc.agent.settings");
+const corsFree = /* @__PURE__ */ new Set([BEDROCK]);
+function sliccProviders() {
+  return [amazonBedrockProvider()];
+}
+function createSliccModels(credentials, providers = sliccProviders()) {
+  const models = createModels({ credentials });
+  for (const provider of providers) models.setProvider(provider);
+  return models;
+}
+function choices(models, providers) {
+  return providers.flatMap(
+    (provider) => models.getModels(provider.id).map((model) => ({
+      id: `${provider.id}/${model.id}`,
+      label: model.name,
+      provider: provider.name ?? provider.id,
+      kind: "chat",
+      reasoning: Boolean(model.reasoning),
+      contextWindow: model.contextWindow
+    }))
+  );
+}
+async function accounts(credentials, providers) {
+  const stored = new Set((await credentials.list()).map((info) => info.providerId));
+  return providers.map((provider) => ({
+    id: provider.id,
+    provider: provider.name ?? provider.id,
+    identity: stored.has(provider.id) ? "API key" : "",
+    status: stored.has(provider.id) ? "connected" : "disconnected",
+    auth: "api-key",
+    needs: corsFree.has(provider.id) ? "cors-free-transport" : null
+  }));
+}
+async function createAgentSettings(models, credentials, providers = sliccProviders()) {
+  const state = replicatedState({
+    models: choices(models, providers),
+    accounts: await accounts(credentials, providers)
+  });
+  const refresh = async (context) => {
+    state.replace(context, {
+      models: choices(models, providers),
+      accounts: await accounts(credentials, providers)
+    });
+  };
+  return {
+    state,
+    async connect(providerId, secret, region, context) {
+      await credentials.modify(providerId, async () => ({
+        type: "api_key",
+        key: secret,
+        ...region ? { env: { AWS_REGION: region } } : {}
+      }));
+      await refresh(context);
+    },
+    async disconnect(providerId, context) {
+      await credentials.delete(providerId);
+      await refresh(context);
+    }
+  };
+}
+export {
+  AgentSettings,
+  BEDROCK,
+  DEFAULT_MODEL,
+  createAgentSettings,
+  createSliccModels,
+  sliccProviders
+};
+//# sourceMappingURL=settings.js.map

package/dist/settings.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/settings.ts"],
+  "sourcesContent": ["import {\n  type Context,\n  defineService,\n  type ReplicatedState,\n  replicatedState,\n} from '@earendil-works/chord';\nimport type { CredentialStore, Provider } from '@earendil-works/pi-ai';\nimport { createModels, type MutableModels } from '@earendil-works/pi-ai/models';\nimport { amazonBedrockProvider } from '@earendil-works/pi-ai/providers/amazon-bedrock';\n\nexport const BEDROCK = 'amazon-bedrock';\nexport const DEFAULT_MODEL = { provider: BEDROCK, modelId: 'us.anthropic.claude-sonnet-5-5' };\n\nexport interface ModelChoice {\n  id: string;\n  label: string;\n  provider: string;\n  kind: 'chat' | 'classifier';\n  reasoning: boolean;\n  contextWindow: number;\n}\n\nexport interface AccountState {\n  id: string;\n  provider: string;\n  identity: string;\n  status: 'connected' | 'disconnected';\n  auth: 'api-key';\n  needs: 'cors-free-transport' | null;\n}\n\nexport interface SettingsState {\n  models: ModelChoice[];\n  accounts: AccountState[];\n}\n\nexport interface AgentSettings {\n  readonly state: ReplicatedState<SettingsState>;\n  connect(\n    providerId: string,\n    secret: string,\n    region: string | null,\n    context: Context\n  ): Promise<void>;\n  disconnect(providerId: string, context: Context): Promise<void>;\n}\n\nexport const AgentSettings = defineService<AgentSettings>('slicc.agent.settings');\n\nconst corsFree = new Set([BEDROCK]);\n\nexport function sliccProviders(): Provider[] {\n  return [amazonBedrockProvider() as Provider];\n}\n\nexport function createSliccModels(\n  credentials: CredentialStore,\n  providers = sliccProviders()\n): MutableModels {\n  const models = createModels({ credentials });\n  for (const provider of providers) models.setProvider(provider);\n  return models;\n}\n\nfunction choices(models: MutableModels, providers: Provider[]): ModelChoice[] {\n  return providers.flatMap((provider) =>\n    models.getModels(provider.id).map((model) => ({\n      id: `${provider.id}/${model.id}`,\n      label: model.name,\n      provider: provider.name ?? provider.id,\n      kind: 'chat' as const,\n      reasoning: Boolean(model.reasoning),\n      contextWindow: model.contextWindow,\n    }))\n  );\n}\n\nasync function accounts(\n  credentials: CredentialStore,\n  providers: Provider[]\n): Promise<AccountState[]> {\n  const stored = new Set((await credentials.list()).map((info) => info.providerId));\n  return providers.map((provider) => ({\n    id: provider.id,\n    provider: provider.name ?? provider.id,\n    identity: stored.has(provider.id) ? 'API key' : '',\n    status: stored.has(provider.id) ? 'connected' : 'disconnected',\n    auth: 'api-key',\n    needs: corsFree.has(provider.id) ? 'cors-free-transport' : null,\n  }));\n}\n\nexport async function createAgentSettings(\n  models: MutableModels,\n  credentials: CredentialStore,\n  providers = sliccProviders()\n): Promise<AgentSettings> {\n  const state = replicatedState<SettingsState>({\n    models: choices(models, providers),\n    accounts: await accounts(credentials, providers),\n  });\n  const refresh = async (context: Context) => {\n    state.replace(context, {\n      models: choices(models, providers),\n      accounts: await accounts(credentials, providers),\n    });\n  };\n  return {\n    state,\n    async connect(providerId, secret, region, context) {\n      await credentials.modify(providerId, async () => ({\n        type: 'api_key',\n        key: secret,\n        ...(region ? { env: { AWS_REGION: region } } : {}),\n      }));\n      await refresh(context);\n    },\n    async disconnect(providerId, context) {\n      await credentials.delete(providerId);\n      await refresh(context);\n    },\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EAEE;AAAA,EAEA;AAAA,OACK;AAEP,SAAS,oBAAwC;AACjD,SAAS,6BAA6B;AAE/B,MAAM,UAAU;AAChB,MAAM,gBAAgB,EAAE,UAAU,SAAS,SAAS,iCAAiC;AAoCrF,MAAM,gBAAgB,cAA6B,sBAAsB;AAEhF,MAAM,WAAW,oBAAI,IAAI,CAAC,OAAO,CAAC;AAE3B,SAAS,iBAA6B;AAC3C,SAAO,CAAC,sBAAsB,CAAa;AAC7C;AAEO,SAAS,kBACd,aACA,YAAY,eAAe,GACZ;AACf,QAAM,SAAS,aAAa,EAAE,YAAY,CAAC;AAC3C,aAAW,YAAY,UAAW,QAAO,YAAY,QAAQ;AAC7D,SAAO;AACT;AAEA,SAAS,QAAQ,QAAuB,WAAsC;AAC5E,SAAO,UAAU;AAAA,IAAQ,CAAC,aACxB,OAAO,UAAU,SAAS,EAAE,EAAE,IAAI,CAAC,WAAW;AAAA,MAC5C,IAAI,GAAG,SAAS,EAAE,IAAI,MAAM,EAAE;AAAA,MAC9B,OAAO,MAAM;AAAA,MACb,UAAU,SAAS,QAAQ,SAAS;AAAA,MACpC,MAAM;AAAA,MACN,WAAW,QAAQ,MAAM,SAAS;AAAA,MAClC,eAAe,MAAM;AAAA,IACvB,EAAE;AAAA,EACJ;AACF;AAEA,eAAe,SACb,aACA,WACyB;AACzB,QAAM,SAAS,IAAI,KAAK,MAAM,YAAY,KAAK,GAAG,IAAI,CAAC,SAAS,KAAK,UAAU,CAAC;AAChF,SAAO,UAAU,IAAI,CAAC,cAAc;AAAA,IAClC,IAAI,SAAS;AAAA,IACb,UAAU,SAAS,QAAQ,SAAS;AAAA,IACpC,UAAU,OAAO,IAAI,SAAS,EAAE,IAAI,YAAY;AAAA,IAChD,QAAQ,OAAO,IAAI,SAAS,EAAE,IAAI,cAAc;AAAA,IAChD,MAAM;AAAA,IACN,OAAO,SAAS,IAAI,SAAS,EAAE,IAAI,wBAAwB;AAAA,EAC7D,EAAE;AACJ;AAEA,eAAsB,oBACpB,QACA,aACA,YAAY,eAAe,GACH;AACxB,QAAM,QAAQ,gBAA+B;AAAA,IAC3C,QAAQ,QAAQ,QAAQ,SAAS;AAAA,IACjC,UAAU,MAAM,SAAS,aAAa,SAAS;AAAA,EACjD,CAAC;AACD,QAAM,UAAU,OAAO,YAAqB;AAC1C,UAAM,QAAQ,SAAS;AAAA,MACrB,QAAQ,QAAQ,QAAQ,SAAS;AAAA,MACjC,UAAU,MAAM,SAAS,aAAa,SAAS;AAAA,IACjD,CAAC;AAAA,EACH;AACA,SAAO;AAAA,IACL;AAAA,IACA,MAAM,QAAQ,YAAY,QAAQ,QAAQ,SAAS;AACjD,YAAM,YAAY,OAAO,YAAY,aAAa;AAAA,QAChD,MAAM;AAAA,QACN,KAAK;AAAA,QACL,GAAI,SAAS,EAAE,KAAK,EAAE,YAAY,OAAO,EAAE,IAAI,CAAC;AAAA,MAClD,EAAE;AACF,YAAM,QAAQ,OAAO;AAAA,IACvB;AAAA,IACA,MAAM,WAAW,YAAY,SAAS;AACpC,YAAM,YAAY,OAAO,UAAU;AACnC,YAAM,QAAQ,OAAO;AAAA,IACvB;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/spectrum/index.js

@@ -1,12 +1,20 @@
 import { AgentAdapter } from "./agent-port.js";
+import { SettingsAdapter } from "./settings-port.js";
 import { AgentAdapter as AgentAdapter2, CONE } from "./agent-port.js";
 import { assistant, isBusy, queued, textOf, toMessages } from "./messages.js";
-function createAgentModel(connection) {
-  return { agent: new AgentAdapter(connection) };
+import { SETTINGS_KEY, SettingsAdapter as SettingsAdapter2 } from "./settings-port.js";
+function createAgentModel(connection, options = {}) {
+  const agent = new AgentAdapter(connection);
+  return {
+    agent,
+    settings: new SettingsAdapter(connection.settings, agent, options.storage ?? null)
+  };
 }
 export {
   AgentAdapter2 as AgentAdapter,
   CONE,
+  SETTINGS_KEY,
+  SettingsAdapter2 as SettingsAdapter,
   assistant,
   createAgentModel,
   isBusy,

package/dist/spectrum/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/spectrum/index.ts"],
-  "sourcesContent": ["import type { AgentConnection } from '../client.ts';\nimport { AgentAdapter } from './agent-port.ts';\n\nexport { AgentAdapter, CONE } from './agent-port.ts';\nexport { assistant, isBusy, queued, textOf, toMessages } from './messages.ts';\n\nexport function createAgentModel(connection: AgentConnection): { agent: AgentAdapter } {\n  return { agent: new AgentAdapter(connection) };\n}\n"],
-  "mappings": "AACA,SAAS,oBAAoB;AAE7B,SAAS,gBAAAA,eAAc,YAAY;AACnC,SAAS,WAAW,QAAQ,QAAQ,QAAQ,kBAAkB;AAEvD,SAAS,iBAAiB,YAAsD;AACrF,SAAO,EAAE,OAAO,IAAI,aAAa,UAAU,EAAE;AAC/C;",
-  "names": ["AgentAdapter"]
+  "sourcesContent": ["import type { AgentConnection } from '../client.ts';\nimport { AgentAdapter } from './agent-port.ts';\nimport { SettingsAdapter } from './settings-port.ts';\n\nexport { AgentAdapter, CONE } from './agent-port.ts';\nexport { assistant, isBusy, queued, textOf, toMessages } from './messages.ts';\nexport { SETTINGS_KEY, SettingsAdapter } from './settings-port.ts';\n\nexport function createAgentModel(\n  connection: AgentConnection,\n  options: { storage?: Pick<Storage, 'getItem' | 'setItem'> | null } = {}\n): { agent: AgentAdapter; settings: SettingsAdapter } {\n  const agent = new AgentAdapter(connection);\n  return {\n    agent,\n    settings: new SettingsAdapter(connection.settings, agent, options.storage ?? null),\n  };\n}\n"],
+  "mappings": "AACA,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAEhC,SAAS,gBAAAA,eAAc,YAAY;AACnC,SAAS,WAAW,QAAQ,QAAQ,QAAQ,kBAAkB;AAC9D,SAAS,cAAc,mBAAAC,wBAAuB;AAEvC,SAAS,iBACd,YACA,UAAqE,CAAC,GAClB;AACpD,QAAM,QAAQ,IAAI,aAAa,UAAU;AACzC,SAAO;AAAA,IACL;AAAA,IACA,UAAU,IAAI,gBAAgB,WAAW,UAAU,OAAO,QAAQ,WAAW,IAAI;AAAA,EACnF;AACF;",
+  "names": ["AgentAdapter", "SettingsAdapter"]
 }

package/dist/spectrum/settings-port.js

@@ -0,0 +1,73 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { Emitter } from "./emitter.js";
+const SETTINGS_KEY = "slicc-agent.settings";
+const defaults = {
+  color: "system",
+  model: "",
+  thinking: "off",
+  sendOnEnter: true,
+  showThinking: false,
+  diffStyle: "unified"
+};
+class SettingsAdapter extends Emitter {
+  #settings;
+  #agent;
+  #storage;
+  #local;
+  constructor(settings, agent, storage) {
+    super();
+    this.#settings = settings;
+    this.#agent = agent;
+    this.#storage = storage;
+    const saved = JSON.parse(storage?.getItem(SETTINGS_KEY) ?? "{}");
+    const { model: _model, thinking: _thinking, ...local } = { ...defaults, ...saved };
+    this.#local = local;
+    settings.state.subscribe(() => {
+      this.emit("accounts", this.accounts());
+      this.emit("settings", this.get());
+    });
+    agent.on("agents", () => this.emit("settings", this.get()));
+  }
+  #state() {
+    return this.#settings.state.value ?? { models: [], accounts: [] };
+  }
+  get() {
+    const cone = this.#agent.list()[0];
+    return { ...this.#local, model: cone?.model ?? "", thinking: cone?.thinking ?? "off" };
+  }
+  update(patch) {
+    const { model, thinking, ...local } = patch;
+    const id = this.#agent.active();
+    if (model !== void 0) this.#agent.setModel(id, model);
+    if (thinking !== void 0) this.#agent.setThinking(id, thinking);
+    this.#local = { ...this.#local, ...local };
+    this.#storage?.setItem(SETTINGS_KEY, JSON.stringify(this.#local));
+    this.emit("settings", this.get());
+  }
+  models() {
+    return this.#state().models.map(({ id, label, provider, kind, reasoning }) => ({
+      id,
+      label,
+      provider,
+      kind,
+      reasoning
+    }));
+  }
+  accounts() {
+    return this.#state().accounts.map(
+      ({ needs, ...account }) => needs ? { ...account, needs } : account
+    );
+  }
+  async connect(id, secret, options = {}) {
+    if (!secret) throw new Error(`${id} needs an API key`);
+    await this.#settings.connect(id, secret, options.region ?? null, BACKGROUND_CONTEXT);
+  }
+  disconnect(id) {
+    void this.#settings.disconnect(id, BACKGROUND_CONTEXT);
+  }
+}
+export {
+  SETTINGS_KEY,
+  SettingsAdapter
+};
+//# sourceMappingURL=settings-port.js.map

package/dist/spectrum/settings-port.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/spectrum/settings-port.ts"],
+  "sourcesContent": ["import type {\n  Account,\n  ModelOption,\n  Settings,\n  SettingsEvents,\n  SettingsPort,\n} from '@ai-ecoverse/slicc-spectrum/ui';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport type { AgentSettings, SettingsState } from '../settings.ts';\nimport type { AgentAdapter } from './agent-port.ts';\nimport { Emitter } from './emitter.ts';\n\nexport const SETTINGS_KEY = 'slicc-agent.settings';\n\nconst defaults: Settings = {\n  color: 'system',\n  model: '',\n  thinking: 'off',\n  sendOnEnter: true,\n  showThinking: false,\n  diffStyle: 'unified',\n};\n\ntype Local = Omit<Settings, 'model' | 'thinking'>;\n\nexport class SettingsAdapter extends Emitter<SettingsEvents> implements SettingsPort {\n  readonly #settings: AgentSettings;\n  readonly #agent: AgentAdapter;\n  readonly #storage: Pick<Storage, 'getItem' | 'setItem'> | null;\n  #local: Local;\n\n  constructor(\n    settings: AgentSettings,\n    agent: AgentAdapter,\n    storage: Pick<Storage, 'getItem' | 'setItem'> | null\n  ) {\n    super();\n    this.#settings = settings;\n    this.#agent = agent;\n    this.#storage = storage;\n    const saved = JSON.parse(storage?.getItem(SETTINGS_KEY) ?? '{}') as Partial<Local>;\n    const { model: _model, thinking: _thinking, ...local } = { ...defaults, ...saved };\n    this.#local = local;\n    settings.state.subscribe(() => {\n      this.emit('accounts', this.accounts());\n      this.emit('settings', this.get());\n    });\n    agent.on('agents', () => this.emit('settings', this.get()));\n  }\n\n  #state(): SettingsState {\n    return this.#settings.state.value ?? { models: [], accounts: [] };\n  }\n\n  get(): Settings {\n    const cone = this.#agent.list()[0];\n    return { ...this.#local, model: cone?.model ?? '', thinking: cone?.thinking ?? 'off' };\n  }\n\n  update(patch: Partial<Settings>): void {\n    const { model, thinking, ...local } = patch;\n    const id = this.#agent.active();\n    if (model !== undefined) this.#agent.setModel(id, model);\n    if (thinking !== undefined) this.#agent.setThinking(id, thinking);\n    this.#local = { ...this.#local, ...local };\n    this.#storage?.setItem(SETTINGS_KEY, JSON.stringify(this.#local));\n    this.emit('settings', this.get());\n  }\n\n  models(): readonly ModelOption[] {\n    return this.#state().models.map(({ id, label, provider, kind, reasoning }) => ({\n      id,\n      label,\n      provider,\n      kind,\n      reasoning,\n    }));\n  }\n\n  accounts(): readonly Account[] {\n    return this.#state().accounts.map(({ needs, ...account }) =>\n      needs ? { ...account, needs } : account\n    );\n  }\n\n  async connect(id: string, secret?: string, options: { region?: string } = {}): Promise<void> {\n    if (!secret) throw new Error(`${id} needs an API key`);\n    await this.#settings.connect(id, secret, options.region ?? null, BACKGROUND_CONTEXT);\n  }\n\n  disconnect(id: string): void {\n    void this.#settings.disconnect(id, BACKGROUND_CONTEXT);\n  }\n}\n"],
+  "mappings": "AAOA,SAAS,0BAA0B;AAGnC,SAAS,eAAe;AAEjB,MAAM,eAAe;AAE5B,MAAM,WAAqB;AAAA,EACzB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,UAAU;AAAA,EACV,aAAa;AAAA,EACb,cAAc;AAAA,EACd,WAAW;AACb;AAIO,MAAM,wBAAwB,QAAgD;AAAA,EAC1E;AAAA,EACA;AAAA,EACA;AAAA,EACT;AAAA,EAEA,YACE,UACA,OACA,SACA;AACA,UAAM;AACN,SAAK,YAAY;AACjB,SAAK,SAAS;AACd,SAAK,WAAW;AAChB,UAAM,QAAQ,KAAK,MAAM,SAAS,QAAQ,YAAY,KAAK,IAAI;AAC/D,UAAM,EAAE,OAAO,QAAQ,UAAU,WAAW,GAAG,MAAM,IAAI,EAAE,GAAG,UAAU,GAAG,MAAM;AACjF,SAAK,SAAS;AACd,aAAS,MAAM,UAAU,MAAM;AAC7B,WAAK,KAAK,YAAY,KAAK,SAAS,CAAC;AACrC,WAAK,KAAK,YAAY,KAAK,IAAI,CAAC;AAAA,IAClC,CAAC;AACD,UAAM,GAAG,UAAU,MAAM,KAAK,KAAK,YAAY,KAAK,IAAI,CAAC,CAAC;AAAA,EAC5D;AAAA,EAEA,SAAwB;AACtB,WAAO,KAAK,UAAU,MAAM,SAAS,EAAE,QAAQ,CAAC,GAAG,UAAU,CAAC,EAAE;AAAA,EAClE;AAAA,EAEA,MAAgB;AACd,UAAM,OAAO,KAAK,OAAO,KAAK,EAAE,CAAC;AACjC,WAAO,EAAE,GAAG,KAAK,QAAQ,OAAO,MAAM,SAAS,IAAI,UAAU,MAAM,YAAY,MAAM;AAAA,EACvF;AAAA,EAEA,OAAO,OAAgC;AACrC,UAAM,EAAE,OAAO,UAAU,GAAG,MAAM,IAAI;AACtC,UAAM,KAAK,KAAK,OAAO,OAAO;AAC9B,QAAI,UAAU,OAAW,MAAK,OAAO,SAAS,IAAI,KAAK;AACvD,QAAI,aAAa,OAAW,MAAK,OAAO,YAAY,IAAI,QAAQ;AAChE,SAAK,SAAS,EAAE,GAAG,KAAK,QAAQ,GAAG,MAAM;AACzC,SAAK,UAAU,QAAQ,cAAc,KAAK,UAAU,KAAK,MAAM,CAAC;AAChE,SAAK,KAAK,YAAY,KAAK,IAAI,CAAC;AAAA,EAClC;AAAA,EAEA,SAAiC;AAC/B,WAAO,KAAK,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,IAAI,OAAO,UAAU,MAAM,UAAU,OAAO;AAAA,MAC7E;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE;AAAA,EACJ;AAAA,EAEA,WAA+B;AAC7B,WAAO,KAAK,OAAO,EAAE,SAAS;AAAA,MAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,MACrD,QAAQ,EAAE,GAAG,SAAS,MAAM,IAAI;AAAA,IAClC;AAAA,EACF;AAAA,EAEA,MAAM,QAAQ,IAAY,QAAiB,UAA+B,CAAC,GAAkB;AAC3F,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,GAAG,EAAE,mBAAmB;AACrD,UAAM,KAAK,UAAU,QAAQ,IAAI,QAAQ,QAAQ,UAAU,MAAM,kBAAkB;AAAA,EACrF;AAAA,EAEA,WAAW,IAAkB;AAC3B,SAAK,KAAK,UAAU,WAAW,IAAI,kBAAkB;AAAA,EACvD;AACF;",
+  "names": []
+}

package/dist/types/agent-worker.d.ts

@@ -0,0 +1 @@
+export declare const host: Promise<import("./host.ts").AgentHost>;

package/dist/types/client.d.ts

@@ -1,11 +1,13 @@
 import { type Context, type ReplicatedState } from '@earendil-works/chord';
 import type { ConversationView } from '@earendil-works/pi-durable';
 import { AgentControl, type SendMode } from './services.ts';
+import { AgentSettings } from './settings.ts';
 import { type PortEndpoint } from './wire.ts';
 export interface AgentConnection {
     readonly serverId: string;
     readonly control: AgentControl;
     readonly transcript: ReplicatedState<ConversationView>;
+    readonly settings: AgentSettings;
     prompt(text: string, whenBusy?: SendMode): Promise<string>;
     close(): Promise<void>;
 }

package/dist/types/credentials.d.ts

@@ -0,0 +1,12 @@
+import type { Credential, CredentialInfo, CredentialStore } from '@earendil-works/pi-ai';
+export declare const CREDENTIALS_DATABASE = "slicc-agent-credentials";
+export declare class EncryptedCredentialStore implements CredentialStore {
+    #private;
+    private constructor();
+    static open(name?: string): Promise<EncryptedCredentialStore>;
+    read(providerId: string): Promise<Credential | undefined>;
+    list(): Promise<readonly CredentialInfo[]>;
+    modify(providerId: string, fn: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;
+    delete(providerId: string): Promise<void>;
+    close(): void;
+}

package/dist/types/host.d.ts

@@ -1,5 +1,6 @@
 import { type Context } from '@earendil-works/chord';
 import type { Agent } from './agent.ts';
+import { AgentSettings } from './settings.ts';
 import { type PortEndpoint } from './wire.ts';
 export interface AgentHost {
     readonly serverId: string;
@@ -10,4 +11,5 @@ export interface AgentHost {
 export declare function hostAgent(agent: Agent, options?: {
     serverId?: string;
     context?: Context;
+    settings?: AgentSettings;
 }): Promise<AgentHost>;

package/dist/types/index.d.ts

@@ -1,11 +1,16 @@
 export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';
 export { type AgentConnection, connectAgent } from './client.ts';
 export { createAgentControl } from './control.ts';
+export { CREDENTIALS_DATABASE, EncryptedCredentialStore } from './credentials.ts';
 export { type AgentHost, hostAgent } from './host.ts';
 export type { KernelClient, KernelFs, KernelProcess, KernelStat, SpawnOptions, } from './kernel/client.ts';
 export { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';
+export { type AgentWorkerOptions, type AgentWorkerScope, type KernelAttach, runAgentWorker, } from './main.ts';
+export { type Transport, type TransportResponse, transportFetch } from './net.ts';
 export { AGENT_LOCK, type AgentOwner, type AgentWorker, type OwnerOptions, startAgent, } from './owner.ts';
+export { SliccPrompt } from './prompt.ts';
 export { AGENT_SESSION, AgentControl, AgentSessions, type AgentSettingsChange, AgentTranscript, type OperationError, type PromptResult, type SendMode, type SendRequest, type SendResponse, } from './services.ts';
+export { type AccountState, AgentSettings, BEDROCK, createAgentSettings, createSliccModels, DEFAULT_MODEL, type ModelChoice, type SettingsState, sliccProviders, } from './settings.ts';
 export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';
 export { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';
 export { kernelPort, serveConnections, type WorkerScope } from './worker.ts';

package/dist/types/main.d.ts

@@ -0,0 +1,23 @@
+import type { CredentialStore, Provider } from '@earendil-works/pi-ai';
+import { type ModelRef, type Storage } from '@earendil-works/pi-durable';
+import { type AgentHost } from './host.ts';
+import type { KernelClient } from './kernel/client.ts';
+import { type Transport } from './net.ts';
+import { type WorkerScope } from './worker.ts';
+export interface AgentWorkerScope extends WorkerScope {
+    fetch: typeof fetch;
+    location: {
+        origin: string;
+    };
+}
+export type KernelAttach = (port: MessagePort) => Promise<KernelClient & {
+    transport: Transport;
+}>;
+export interface AgentWorkerOptions {
+    model?: ModelRef;
+    providers?: Provider[];
+    attach?: KernelAttach;
+    credentials?: () => Promise<CredentialStore>;
+    storage?: () => Promise<Storage>;
+}
+export declare function runAgentWorker(scope: AgentWorkerScope, options?: AgentWorkerOptions): Promise<AgentHost>;

package/dist/types/net.d.ts

@@ -0,0 +1,19 @@
+export interface TransportResponse {
+    status: number;
+    statusText?: string;
+    headers: HeadersInit;
+    body: AsyncIterable<Uint8Array>;
+}
+export interface Transport {
+    traits?: {
+        crossOrigin?: 'cors' | 'any';
+    };
+    fetch(request: {
+        url: string;
+        method: string;
+        headers: [string, string][];
+        body?: Uint8Array;
+        signal?: AbortSignal;
+    }): Promise<TransportResponse>;
+}
+export declare function transportFetch(transport: Transport, origin: string, native?: typeof fetch): typeof fetch;

package/dist/types/prompt.d.ts

@@ -0,0 +1 @@
+export declare const SliccPrompt: import("@earendil-works/pi-durable").Extension<import("@earendil-works/pi-durable").ToolRegistration>;

package/dist/types/settings.d.ts

@@ -0,0 +1,37 @@
+import { type Context, type ReplicatedState } from '@earendil-works/chord';
+import type { CredentialStore, Provider } from '@earendil-works/pi-ai';
+import { type MutableModels } from '@earendil-works/pi-ai/models';
+export declare const BEDROCK = "amazon-bedrock";
+export declare const DEFAULT_MODEL: {
+    provider: string;
+    modelId: string;
+};
+export interface ModelChoice {
+    id: string;
+    label: string;
+    provider: string;
+    kind: 'chat' | 'classifier';
+    reasoning: boolean;
+    contextWindow: number;
+}
+export interface AccountState {
+    id: string;
+    provider: string;
+    identity: string;
+    status: 'connected' | 'disconnected';
+    auth: 'api-key';
+    needs: 'cors-free-transport' | null;
+}
+export interface SettingsState {
+    models: ModelChoice[];
+    accounts: AccountState[];
+}
+export interface AgentSettings {
+    readonly state: ReplicatedState<SettingsState>;
+    connect(providerId: string, secret: string, region: string | null, context: Context): Promise<void>;
+    disconnect(providerId: string, context: Context): Promise<void>;
+}
+export declare const AgentSettings: import("@earendil-works/chord").Service<AgentSettings>;
+export declare function sliccProviders(): Provider[];
+export declare function createSliccModels(credentials: CredentialStore, providers?: Provider<import("@earendil-works/pi-ai").Api>[]): MutableModels;
+export declare function createAgentSettings(models: MutableModels, credentials: CredentialStore, providers?: Provider<import("@earendil-works/pi-ai").Api>[]): Promise<AgentSettings>;

package/dist/types/spectrum/index.d.ts

@@ -1,7 +1,12 @@
 import type { AgentConnection } from '../client.ts';
 import { AgentAdapter } from './agent-port.ts';
+import { SettingsAdapter } from './settings-port.ts';
 export { AgentAdapter, CONE } from './agent-port.ts';
 export { assistant, isBusy, queued, textOf, toMessages } from './messages.ts';
-export declare function createAgentModel(connection: AgentConnection): {
+export { SETTINGS_KEY, SettingsAdapter } from './settings-port.ts';
+export declare function createAgentModel(connection: AgentConnection, options?: {
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | null;
+}): {
     agent: AgentAdapter;
+    settings: SettingsAdapter;
 };

package/dist/types/spectrum/settings-port.d.ts

@@ -0,0 +1,17 @@
+import type { Account, ModelOption, Settings, SettingsEvents, SettingsPort } from '@ai-ecoverse/slicc-spectrum/ui';
+import type { AgentSettings } from '../settings.ts';
+import type { AgentAdapter } from './agent-port.ts';
+import { Emitter } from './emitter.ts';
+export declare const SETTINGS_KEY = "slicc-agent.settings";
+export declare class SettingsAdapter extends Emitter<SettingsEvents> implements SettingsPort {
+    #private;
+    constructor(settings: AgentSettings, agent: AgentAdapter, storage: Pick<Storage, 'getItem' | 'setItem'> | null);
+    get(): Settings;
+    update(patch: Partial<Settings>): void;
+    models(): readonly ModelOption[];
+    accounts(): readonly Account[];
+    connect(id: string, secret?: string, options?: {
+        region?: string;
+    }): Promise<void>;
+    disconnect(id: string): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -29,6 +29,10 @@
     "./spectrum": {
       "types": "./dist/types/spectrum/index.d.ts",
       "default": "./dist/spectrum/index.js"
+    },
+    "./agent-worker": {
+      "types": "./dist/types/agent-worker.d.ts",
+      "default": "./dist/agent-worker.js"
     }
   },
   "files": [
@@ -50,7 +54,6 @@
     "release": "semantic-release"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-kernel": "1.9.0",
     "@ai-ecoverse/slicc-shared-web": "1.5.0",
     "@ai-ecoverse/slicc-spectrum": "1.7.0",
     "@ai-ecoverse/wasm-bash": "5.3.0-7",
@@ -58,6 +61,7 @@
     "@biomejs/biome": "2.5.15",
     "@types/node": "24.19.1",
     "esbuild": "0.28.2",
+    "fake-indexeddb": "6.2.5",
     "lefthook": "2.1.16",
     "monocart-coverage-reports": "2.13.0",
     "playwright-core": "1.63.0",
@@ -65,6 +69,7 @@
     "typescript": "7.0.2"
   },
   "dependencies": {
+    "@ai-ecoverse/slicc-kernel": "1.9.0",
     "@earendil-works/chord": "1.0.4",
     "@earendil-works/pi-ai": "1.0.4",
     "@earendil-works/pi-client": "1.0.4",