pi-wasm-kit 0.0.0-stage → 0.2.0

package/dist/guest/entry.js

@@ -0,0 +1,134 @@
+import './platform.js';
+import * as contexts from '@earendil-works/chord/context';
+import * as pi from '@earendil-works/pi-durable';
+import { Type } from '@earendil-works/pi-ai';
+import { createModels, createProvider } from '@earendil-works/pi-ai/models';
+import { createAssistantMessageEventStream } from '@earendil-works/pi-ai/utils/event-stream';
+import { JournalStorage } from './journal.js';
+import { hostCall } from './bridge.js';
+const context = contexts.BACKGROUND_CONTEXT;
+let harness;
+let root;
+const registry = pi.createRegistry();
+const watches = new Map();
+const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+function stream(model, transcript, options) {
+    const events = createAssistantMessageEventStream();
+    void hostCall('model', { model, context: transcript, options: { ...options, signal: undefined } }, options?.signal, event => events.push(event)).then(message => {
+        if (message.stopReason === 'error' || message.stopReason === 'aborted')
+            events.push({ type: 'error', reason: message.stopReason, error: message });
+        else
+            events.push({ type: 'done', reason: message.stopReason, message });
+        events.end(message);
+    }, error => {
+        const message = { role: 'assistant', api: 'host', provider: 'host', model: model.id, content: [], usage, stopReason: options?.signal?.aborted ? 'aborted' : 'error', errorMessage: String(error), timestamp: Date.now() };
+        events.push({ type: 'error', reason: message.stopReason, error: message });
+        events.end(message);
+    });
+    return events;
+}
+function install(source) {
+    const module = { exports: {} };
+    const require = (name) => {
+        if (name === '@earendil-works/pi-durable')
+            return pi;
+        if (name === '@earendil-works/pi-ai')
+            return { Type };
+        if (name === '@earendil-works/chord/context')
+            return contexts;
+        throw new Error(`Guest module not available: ${name}`);
+    };
+    new Function('module', 'exports', 'require', source)(module, module.exports, require);
+    const extension = module.exports.default ?? module.exports;
+    registry.install(extension);
+    return extension.name;
+}
+async function conversation(args) {
+    if (args.conversationId === undefined)
+        return root;
+    const found = await harness.conversation(args.conversationId, context);
+    if (!found)
+        throw new Error('Conversation not found');
+    return found;
+}
+async function watch(id) {
+    if (watches.has(id))
+        return;
+    const stream = await pi.watchEvents(harness, id, context);
+    watches.set(id, stream);
+    const emit = (events) => __emit(JSON.stringify({ type: 'events', conversationId: id, events }));
+    emit([stream.snapshot]);
+    stream.start(async (events) => { emit(events); });
+}
+async function open(config) {
+    const models = createModels();
+    models.setProvider(createProvider({ id: 'host', auth: { apiKey: { name: 'Host', resolve: async () => ({ auth: {} }) } }, models: [{ id: config.modelId ?? 'host-model', name: 'Host model', provider: 'host', baseUrl: 'host://model', api: 'host', reasoning: true, input: ['text', 'image'], cost: usage.cost, contextWindow: config.contextWindow ?? 32768, maxTokens: 4096 }], api: { stream, streamSimple: stream } }));
+    registry.install(pi.defineExtension({ name: 'host-tools', tools: config.tools.map((tool) => pi.defineTool({ ...tool, execute: async (args, api, ctx) => {
+                const result = await hostCall('tool', { name: tool.name, args, taskId: api.taskId, conversationId: api.conversationId, callId: api.callId }, ctx.abortSignal, update => { if (update.type === 'output')
+                    api.output(update.text); });
+                return typeof result === 'string' ? { content: [{ type: 'text', text: result }] } : result;
+            } })) }));
+    for (const source of config.extensions ?? [])
+        install(source);
+    harness = await pi.Harness.open(await JournalStorage.open(), { models, registry, settings: config.settings, onReport: error => __emit(JSON.stringify({ type: 'error', message: String(error) })) }, context);
+    root = await harness.root(context, { agent: { model: { provider: 'host', modelId: config.modelId ?? 'host-model' }, instructions: config.instructions ?? 'You are a helpful assistant.' } });
+    if (config.events)
+        await watch(root.id);
+    if (config.autoResume !== false)
+        harness.resume();
+    return { conversationId: root.id };
+}
+const api = {
+    open,
+    resume: async () => { harness.resume(); return null; },
+    submit: async (args) => ({ id: (await (await conversation(args)).submit(args.submission, context)).id }),
+    wait: async (args) => { const submission = await harness.submission(args.id, context); if (!submission)
+        throw new Error('Submission not found'); return submission.wait(context); },
+    view: async (args) => { const state = await (await conversation(args)).viewState(context); try {
+        return state.value;
+    }
+    finally {
+        state.dispose();
+    } },
+    context: async (args) => (await conversation(args)).context(context, args.at === undefined ? {} : { at: args.at }),
+    configure: async (args) => {
+        const change = { ...args.change };
+        const snapshot = registry.snapshot();
+        if (change.extensions)
+            change.extensions = change.extensions.map((name) => { const ext = snapshot.extension(name); if (!ext)
+                throw new Error(`Unknown extension: ${name}`); return ext; });
+        if (change.tools)
+            change.tools = change.tools.map((name) => { const tool = snapshot.tools().find(t => t.tool.name === name)?.tool; if (!tool)
+                throw new Error(`Unknown tool: ${name}`); return tool; });
+        await (await conversation(args)).configure(change, context);
+        return null;
+    },
+    createConversation: async (args) => ({ conversationId: (await harness.createConversation({ ownership: { kind: 'ownerless' }, agent: args.agent }, context)).id }),
+    fork: async (args) => ({ conversationId: (await (await conversation(args)).fork(args.at, { ownership: { kind: 'ownerless' } }, context)).id }),
+    reset: async (args) => { await (await conversation(args)).reset(args.handoff, context); return null; },
+    compact: async (args) => ({ taskId: await (await conversation(args)).compact(args.instructions, context) }),
+    waitForTask: async (args) => harness.waitForTask(args.id, context),
+    inspect: async () => harness.inspect(context),
+    taskGraph: async () => { const state = await harness.taskGraph(context); try {
+        return state.value;
+    }
+    finally {
+        state.dispose();
+    } },
+    abort: async (args) => { await (await conversation(args)).abort(context, { background: args.background }); return null; },
+    abortSubmission: async (args) => harness.abortSubmission(args.id, context),
+    watch: async (args) => { await watch((await conversation(args)).id); return null; },
+    install: async (args) => install(args.source),
+    uninstall: async (args) => { registry.uninstall({ name: args.name }); return null; },
+    evaluate: async (args) => {
+        const fn = new Function('pi', 'Type', 'harness', 'conversation', 'registry', 'context', 'args', `return (async () => { ${args.source}\n })()`);
+        return fn(pi, Type, harness, await conversation(args), registry, context, args.args);
+    },
+    close: async () => { for (const stream of watches.values())
+        await stream.stop(); watches.clear(); await harness.close(context); return null; },
+};
+globalThis.__dispatch = async (method, raw) => {
+    if (!Object.hasOwn(api, method))
+        throw new Error('Unknown guest method');
+    return JSON.stringify((await api[method](JSON.parse(raw))) ?? null);
+};

package/dist/guest/journal.d.ts

@@ -0,0 +1,6 @@
+import { MemoryStorage, type StorageWrite, type Seq } from '@earendil-works/pi-durable';
+export declare class JournalStorage extends MemoryStorage {
+    static open(): Promise<JournalStorage>;
+    commit(writes: readonly StorageWrite[]): Promise<Seq>;
+    close(): Promise<void>;
+}

package/dist/guest/journal.js

@@ -0,0 +1,21 @@
+import { MemoryStorage } from '@earendil-works/pi-durable';
+import { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';
+export class JournalStorage extends MemoryStorage {
+    static async open() {
+        const storage = new JournalStorage();
+        const commits = JSON.parse(await __host('load', '{}'));
+        let expected = 1;
+        for (const commit of commits) {
+            if (commit.seq !== expected++)
+                throw new Error('Journal sequence is corrupt');
+            storage.prepareCommit(commit.writes, commit.seq).apply();
+        }
+        return storage;
+    }
+    async commit(writes) {
+        const prepared = this.prepareCommit(writes);
+        await __host('append', JSON.stringify({ seq: prepared.seq, writes: prepared.writes }));
+        return prepared.apply();
+    }
+    async close() { await super.close(BACKGROUND_CONTEXT); }
+}

package/dist/guest/platform.d.ts

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

package/dist/guest/platform.js

@@ -0,0 +1,64 @@
+import { AbortController, AbortSignal } from 'abort-controller/dist/abort-controller.mjs';
+const abort = AbortController.prototype.abort;
+AbortController.prototype.abort = function (reason) {
+    if (this.signal.aborted)
+        return;
+    Object.defineProperty(this.signal, 'reason', { value: reason ?? new Error('Operation aborted') });
+    abort.call(this);
+};
+AbortSignal.prototype.throwIfAborted = function () { if (this.aborted)
+    throw this.reason; };
+AbortSignal.any = (signals) => {
+    const controller = new AbortController();
+    const handlers = new Map();
+    const stop = (signal) => {
+        controller.abort(signal.reason);
+        for (const [source, handler] of handlers)
+            source.removeEventListener('abort', handler);
+    };
+    for (const signal of signals) {
+        if (signal.aborted) {
+            stop(signal);
+            break;
+        }
+        const handler = () => stop(signal);
+        handlers.set(signal, handler);
+        signal.addEventListener('abort', handler, { once: true });
+    }
+    return controller.signal;
+};
+Object.assign(globalThis, {
+    AbortController, AbortSignal,
+    URL: class {
+        href;
+        constructor(input, base) { Object.assign(this, JSON.parse(__hostSync('url', JSON.stringify([String(input), base])))); }
+        toString() { return this.href; }
+        toJSON() { return this.href; }
+        static canParse(input, base) { try {
+            __hostSync('url', JSON.stringify([input, base]));
+            return true;
+        }
+        catch {
+            return false;
+        } }
+    },
+    setTimeout: (fn, ms = 0, ...args) => __timer(() => fn(...args), ms),
+    clearTimeout: __clearTimer,
+    performance: { now: () => Number(__hostSync('now', '')) },
+    queueMicrotask: (fn) => Promise.resolve().then(fn),
+    structuredClone: (value) => value === undefined ? undefined : JSON.parse(JSON.stringify(value)),
+    crypto: {
+        randomUUID: () => JSON.parse(__hostSync('uuid', '')),
+        getRandomValues: (array) => { array.set(JSON.parse(__hostSync('random', String(array.length)))); return array; },
+    },
+    TextEncoder: class {
+        encode(text = '') { return Uint8Array.from(JSON.parse(__hostSync('encode', text))); }
+    },
+    TextDecoder: class {
+        decode(bytes = new Uint8Array()) { return JSON.parse(__hostSync('decode', JSON.stringify(Array.from(bytes)))); }
+    },
+    console: { log() { }, warn() { }, error() { }, assert() { } },
+    DOMException: class extends Error {
+        constructor(message, name = "Error") { super(message); this.name = name; }
+    },
+});