@ai-ecoverse/slicc-agent 2.1.0 → 2.3.0

package/dist/types/kernel/client.d.ts

@@ -0,0 +1,39 @@
+export interface KernelStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mtime: Date | number;
+    ino?: number;
+}
+export interface KernelFs {
+    readFile(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    stat(path: string): Promise<KernelStat>;
+    lstat(path: string): Promise<KernelStat>;
+    readdir(path: string): Promise<string[]>;
+    mkdir(path: string): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    realpath(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+}
+export interface KernelProcess {
+    pid: number;
+    pgid: number;
+    exited: Promise<number>;
+    signal(name?: string): unknown;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    onStdout?(bytes: Uint8Array): void;
+    onStderr?(bytes: Uint8Array): void;
+}
+export interface KernelClient {
+    fs: KernelFs;
+    spawn(argv: readonly string[], options: SpawnOptions): Promise<KernelProcess>;
+}

package/dist/types/kernel/env.d.ts

@@ -0,0 +1,57 @@
+import type { Context } from '@earendil-works/chord';
+import { type BinaryReader, type DirReader, type ExecutionEnv, type ExecutionError, FileError, type FileInfo, type FileWatcher, type Result, type ShellExecOptions, type ShellExecResult, type TextLineReader, type WatchChange, type WatchTarget } from '@earendil-works/pi-durable/env';
+import type { KernelClient } from './client.ts';
+import { type PollOptions } from './watch.ts';
+export interface KernelEnvOptions {
+    cwd: string;
+    id?: string;
+    watch?: PollOptions;
+}
+type FileResult<T> = Promise<Result<T, FileError>>;
+export declare class SliccKernelEnv implements ExecutionEnv {
+    #private;
+    readonly id: string;
+    cwd: string;
+    constructor(client: KernelClient, options: KernelEnvOptions);
+    absolutePath(path: string): FileResult<string>;
+    joinPath(parts: string[]): FileResult<string>;
+    readTextFile(path: string, context: Context): FileResult<string>;
+    readBinaryFile(path: string, context: Context): FileResult<Uint8Array>;
+    openTextLineReader(path: string, context: Context): FileResult<TextLineReader>;
+    readTextLines(path: string, options: {
+        maxLines?: number;
+    } | undefined, context: Context): FileResult<string[]>;
+    openBinaryReader(path: string, options: {
+        noFollow?: boolean;
+    } | undefined, context: Context): FileResult<BinaryReader>;
+    writeFile(path: string, content: string | Uint8Array, context: Context): FileResult<void>;
+    appendFile(path: string, content: string | Uint8Array, context: Context): FileResult<void>;
+    truncateFile(path: string, size: number, context: Context): FileResult<void>;
+    flushFile(path: string, context: Context): FileResult<void>;
+    renameFile(sourcePath: string, destinationPath: string, context: Context): FileResult<void>;
+    fileInfo(path: string, context: Context): FileResult<FileInfo>;
+    listDir(path: string, context: Context): FileResult<FileInfo[]>;
+    openDirReader(path: string, context: Context): FileResult<DirReader>;
+    watch(targets: readonly WatchTarget[], onChange: (change: WatchChange) => void, context: Context): FileResult<FileWatcher>;
+    canonicalPath(path: string, context: Context): FileResult<string>;
+    exists(path: string, context: Context): FileResult<boolean>;
+    createDir(path: string, _options: {
+        recursive?: boolean;
+    } | undefined, context: Context): FileResult<void>;
+    remove(path: string, options: {
+        recursive?: boolean;
+        force?: boolean;
+    } | undefined, context: Context): FileResult<void>;
+    createTempDir(prefix: string | undefined, context: Context): FileResult<string>;
+    createTempFile(options: {
+        prefix?: string;
+        suffix?: string;
+    } | undefined, context: Context): FileResult<string>;
+    exec(command: string | readonly string[], options: ShellExecOptions | undefined, context: Context): Promise<Result<ShellExecResult, ExecutionError>>;
+    cleanup(context: Context): Promise<void>;
+}
+export declare const HOME = "/home";
+export declare function kernelEnvironment(client: KernelClient, options?: Omit<KernelEnvOptions, 'cwd'>): (target: {
+    cwd?: string;
+}) => SliccKernelEnv;
+export {};

package/dist/types/kernel/exec.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@earendil-works/chord';
+import { ExecutionError, type Result, type ShellExecOptions, type ShellExecResult } from '@earendil-works/pi-durable/env';
+import type { KernelClient } from './client.ts';
+export declare const SHELL: readonly ['bash', '-c'];
+export declare function execute(client: KernelClient, cwd: string, command: string | readonly string[], options: ShellExecOptions | undefined, context: Context): Promise<Result<ShellExecResult, ExecutionError>>;

package/dist/types/kernel/files.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from '@earendil-works/chord';
+import { type BinaryReader, type DirReader, FileError, type FileInfo, type LineScan, type Result, type TextLine, type TextLineReader } from '@earendil-works/pi-durable/env';
+import type { KernelFs, KernelStat } from './client.ts';
+export declare function fileError(error: unknown, path?: string): FileError;
+export declare function aborted(context: Context, path?: string): Result<never, FileError> | undefined;
+export declare function attempt<T>(context: Context, path: string, run: () => Promise<T>): Promise<Result<T, FileError>>;
+export declare function info(path: string, stat: KernelStat): FileInfo;
+export declare class SnapshotReader implements BinaryReader {
+    #private;
+    constructor(bytes: Uint8Array, fileInfo: FileInfo);
+    info(): Promise<Result<FileInfo, FileError>>;
+    read(offset: number, length: number, context: Context): Promise<Result<Uint8Array, FileError>>;
+    scanLines(options: {
+        startLine: number;
+        endLine?: number;
+    }, context: Context): Promise<Result<LineScan, FileError>>;
+    close(): Promise<void>;
+}
+export declare class SnapshotLines implements TextLineReader {
+    #private;
+    constructor(text: string);
+    readLine(): Promise<Result<TextLine | undefined, FileError>>;
+    close(): Promise<void>;
+}
+export declare class KernelDirReader implements DirReader {
+    #private;
+    constructor(fs: KernelFs, path: string, names: string[]);
+    next(maxEntries: number, context: Context): Promise<Result<{
+        entries: FileInfo[];
+        done: boolean;
+    }, FileError>>;
+    rest(): Promise<FileInfo[]>;
+    close(): Promise<void>;
+}

package/dist/types/kernel/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function normalize(path: string): string;
+export declare function resolve(cwd: string, path: string): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string): string;

package/dist/types/kernel/watch.d.ts

@@ -0,0 +1,10 @@
+import type { FileWatcher, WatchChange, WatchTarget } from '@earendil-works/pi-durable/env';
+import type { KernelFs } from './client.ts';
+type Snapshot = Map<string, string>;
+export declare function snapshot(fs: KernelFs, cwd: string, targets: readonly WatchTarget[]): Promise<Snapshot>;
+export declare function differences(before: Snapshot, after: Snapshot): string[];
+export interface PollOptions {
+    intervalMs?: number;
+}
+export declare function pollWatch(fs: KernelFs, cwd: string, targets: readonly WatchTarget[], onChange: (change: WatchChange) => void, options?: PollOptions): Promise<FileWatcher>;
+export {};

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/owner.d.ts

@@ -7,11 +7,15 @@ export interface AgentWorker {
 }
 export interface AgentOwner {
     connect(): Promise<AgentConnection>;
-    restart(): void;
-    release(): void;
+    restart(): Promise<void>;
+    release(): Promise<void>;
+}
+export interface KernelSource {
+    connect(): Promise<Transferable>;
 }
 export interface OwnerOptions {
     worker: () => AgentWorker;
+    kernel?: KernelSource;
     locks?: LockManager;
     channel?: () => {
         port1: PortEndpoint;

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/dist/types/worker.d.ts

@@ -3,3 +3,4 @@ export interface WorkerScope {
     addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
 }
 export declare function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void;
+export declare function kernelPort(scope: WorkerScope): Promise<MessagePort>;

package/dist/worker.js

@@ -8,7 +8,16 @@ function serveConnections(scope, host) {
     );
   });
 }
+function kernelPort(scope) {
+  return new Promise((resolve) => {
+    scope.addEventListener("message", ({ data }) => {
+      const port = data?.kernel;
+      if (port) resolve(port);
+    });
+  });
+}
 export {
+  kernelPort,
   serveConnections
 };
 //# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/worker.ts"],
-  "sourcesContent": ["import type { AgentHost } from './host.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport interface WorkerScope {\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n}\n\nexport function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void {\n  scope.addEventListener('message', ({ data }) => {\n    const port = (data as { connect?: PortEndpoint } | null)?.connect;\n    if (!port) return;\n    host.then(\n      (ready) => ready.connect(port),\n      () => port.close?.()\n    );\n  });\n}\n"],
-  "mappings": "AAOO,SAAS,iBAAiB,OAAoB,MAAgC;AACnF,QAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,UAAM,OAAQ,MAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,SAAK;AAAA,MACH,CAAC,UAAU,MAAM,QAAQ,IAAI;AAAA,MAC7B,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF,CAAC;AACH;",
+  "sourcesContent": ["import type { AgentHost } from './host.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport interface WorkerScope {\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n}\n\nexport function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void {\n  scope.addEventListener('message', ({ data }) => {\n    const port = (data as { connect?: PortEndpoint } | null)?.connect;\n    if (!port) return;\n    host.then(\n      (ready) => ready.connect(port),\n      () => port.close?.()\n    );\n  });\n}\n\nexport function kernelPort(scope: WorkerScope): Promise<MessagePort> {\n  return new Promise((resolve) => {\n    scope.addEventListener('message', ({ data }) => {\n      const port = (data as { kernel?: MessagePort } | null)?.kernel;\n      if (port) resolve(port);\n    });\n  });\n}\n"],
+  "mappings": "AAOO,SAAS,iBAAiB,OAAoB,MAAgC;AACnF,QAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,UAAM,OAAQ,MAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,SAAK;AAAA,MACH,CAAC,UAAU,MAAM,QAAQ,IAAI;AAAA,MAC7B,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF,CAAC;AACH;AAEO,SAAS,WAAW,OAA0C;AACnE,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,YAAM,OAAQ,MAA0C;AACxD,UAAI,KAAM,SAAQ,IAAI;AAAA,IACxB,CAAC;AAAA,EACH,CAAC;AACH;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "2.1.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": [
@@ -40,7 +44,7 @@
     "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": "node --test --test-timeout=120000 --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",
@@ -52,9 +56,12 @@
   "devDependencies": {
     "@ai-ecoverse/slicc-shared-web": "1.5.0",
     "@ai-ecoverse/slicc-spectrum": "1.7.0",
+    "@ai-ecoverse/wasm-bash": "5.3.0-7",
+    "@ai-ecoverse/wasm-coreutils": "9.7.0-3",
     "@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",
@@ -62,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",