@genkaku/protocol 0.0.0-stage → 0.1.1

package/dist/workerSession.js

@@ -0,0 +1,97 @@
+// GENKAKU: worker session service (mode B/C).
+// One metered worker session: /genkaku/open handshake → stream completion from
+// the local source → token frames out. Settle wiring is P4.4; the receipt side
+// is validated at session end against the receipts the client piped in.
+export function createWorkerSession(envelope, deps) {
+    const sessionId = envelope.jobId;
+    let tokens = 0;
+    let aborted = false;
+    return {
+        sessionId,
+        tokens: () => tokens,
+        abort() { aborted = true; },
+        async run() {
+            const mode = deps.modeManager.current();
+            if (!mode.sharingActive) {
+                deps.emit({ type: 'session-error', message: 'worker listeners not installed (mode guard)' });
+                return;
+            }
+            deps.emit({ type: 'session-open', sessionId, escrowId: envelope.escrowId, model: envelope.model });
+            // Receipts stream IN while the session runs (client pays on a timer in
+            // P4.3 time-billing). Each arrival must be strictly increasing — the
+            // ledger rejects stale/non-increasing offers (P2 §3).
+            let lastSeq = 0;
+            const checkReceipts = () => {
+                const latest = deps.latestReceipt();
+                if (latest == null || latest.seq <= lastSeq) {
+                    return;
+                }
+                const verdict = deps.ledger.offer(sessionId, latest.seq, latest.amount);
+                if (verdict.accepted) {
+                    deps.emit({ type: 'receipt-accepted', seq: latest.seq, amount: latest.amount });
+                }
+                lastSeq = latest.seq;
+            };
+            checkReceipts();
+            const req = {
+                model: envelope.model,
+                prompt: envelope.prompt,
+                system: envelope.system,
+                maxTokens: envelope.maxTokens,
+            };
+            const chat = envelope.proto === 'open/1' ? envelope : null;
+            try {
+                if (chat != null) {
+                    if (deps.chatSource == null) {
+                        throw new Error('worker cannot serve open/1: no chat source configured');
+                    }
+                    await deps.chatSource.streamChat({
+                        model: chat.model,
+                        messages: chat.messages,
+                        ...(chat.tools === undefined ? {} : { tools: chat.tools }),
+                        ...(chat.maxTokens === undefined ? {} : { maxTokens: chat.maxTokens }),
+                    }, (event) => {
+                        if (aborted) {
+                            return;
+                        }
+                        if (event.type === 'text') {
+                            tokens += 1;
+                            deps.emit({ type: 'token-count', tokens });
+                            deps.onDelta(event.text);
+                        }
+                        else {
+                            deps.onToolCall?.({
+                                index: event.index,
+                                id: event.id ?? `call_${event.index}`,
+                                name: event.name ?? '',
+                                argumentsDelta: event.argumentsDelta,
+                            });
+                        }
+                        checkReceipts();
+                    }, deps.abortSignal ?? undefined);
+                }
+                else {
+                    await deps.source.stream(req, (delta) => {
+                        if (aborted) {
+                            return;
+                        }
+                        tokens += 1; // one delta ≈ one token frame from the local source
+                        deps.emit({ type: 'token-count', tokens });
+                        deps.onDelta(delta);
+                        checkReceipts();
+                    }, deps.abortSignal ?? undefined);
+                }
+                deps.emit({ type: 'session-end', sessionId, tokens });
+            }
+            catch (err) {
+                if (aborted) {
+                    deps.emit({ type: 'session-end', sessionId, tokens });
+                }
+                else {
+                    deps.emit({ type: 'session-error', message: err instanceof Error ? err.message : String(err) });
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=workerSession.js.map

package/dist/workerSession.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workerSession.test.d.ts.map

package/dist/workerSession.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerSession.test.d.ts","sourceRoot":"","sources":["../src/workerSession.test.ts"],"names":[],"mappings":""}

package/dist/workerSession.test.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createWorkerSession } from "./workerSession.js";
+const envelope = {
+    proto: 'open/1',
+    jobId: 'j1',
+    escrowId: '0',
+    model: 'm',
+    prompt: 'hi',
+    clientPeer: 'peer',
+    messages: [{ role: 'user', content: 'hi' }],
+    tools: [{ name: 'read', description: 'read a file', parameters: {} }],
+};
+test('an open/1 session serves chat and relays tool calls', async () => {
+    const text = [];
+    const calls = [];
+    const session = createWorkerSession(envelope, {
+        modeManager: { current: () => ({ sharingActive: true }) },
+        source: { stream: async () => ({ promptTokens: 0, completionTokens: 0, model: 'm' }) },
+        chatSource: {
+            async streamChat(_req, onEvent) {
+                onEvent({ type: 'text', text: 'let me look' });
+                onEvent({ type: 'tool-call', index: 0, name: 'read', argumentsDelta: '{"path":"a"}' });
+                return { completionTokens: 3, model: 'm' };
+            },
+        },
+        ledger: { offer: () => ({ accepted: true }) },
+        emit: () => { },
+        onDelta: delta => text.push(delta),
+        onToolCall: call => calls.push(call),
+        latestReceipt: () => null,
+    });
+    await session.run();
+    assert.deepEqual(text, ['let me look']);
+    assert.deepEqual(calls, [{ index: 0, id: 'call_0', name: 'read', argumentsDelta: '{"path":"a"}' }]);
+});
+test('an open/1 session without a chat source fails loudly instead of answering empty', async () => {
+    const session = createWorkerSession(envelope, {
+        modeManager: { current: () => ({ sharingActive: true }) },
+        source: { stream: async () => ({ promptTokens: 0, completionTokens: 0, model: 'm' }) },
+        ledger: { offer: () => ({ accepted: true }) },
+        emit: () => { },
+        onDelta: () => { },
+        latestReceipt: () => null,
+    });
+    await session.run();
+    assert.equal(session.tokens(), 0);
+});
+//# sourceMappingURL=workerSession.test.js.map

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@genkaku/protocol",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "GenKaKu protocol core: on-chain worker directory, USDC escrow billing, libp2p transport, Ollama lifecycle",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@chainsafe/libp2p-noise": "15.1.2",
+    "@chainsafe/libp2p-yamux": "6.0.2",
+    "@libp2p/crypto": "4.1.9",
+    "@libp2p/identify": "2.1.5",
+    "@libp2p/peer-id-factory": "4.2.4",
+    "@libp2p/tcp": "9.1.6",
+    "@multiformats/multiaddr": "12.5.1",
+    "libp2p": "1.9.4",
+    "viem": "2.57.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mlaimail77/genkaku-plugin.git",
+    "directory": "packages/protocol"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "GenKaKu Labs",
+  "homepage": "https://staging.genkaku.app",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "p2p",
+    "libp2p",
+    "ollama",
+    "usdc",
+    "base"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test dist/*.test.js"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.