2020117-agent 0.1.0

package/dist/adapters/exec-processor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Exec processor — delegates to an external command via stdin/stdout.
+ *
+ * PROCESSOR=exec:./my-model.sh
+ *
+ * - verify(): checks the command file exists and is executable
+ * - generate(): spawns process, writes prompt to stdin, reads full stdout
+ * - generateStream(): same but yields stdout line-by-line
+ */
+import type { Processor } from '../processor.js';
+export declare class ExecProcessor implements Processor {
+    private cmd;
+    private args;
+    constructor(cmdSpec: string);
+    get name(): string;
+    verify(): Promise<void>;
+    generate(prompt: string): Promise<string>;
+    generateStream(prompt: string): AsyncGenerator<string>;
+}

package/dist/adapters/exec-processor.js

@@ -0,0 +1,75 @@
+/**
+ * Exec processor — delegates to an external command via stdin/stdout.
+ *
+ * PROCESSOR=exec:./my-model.sh
+ *
+ * - verify(): checks the command file exists and is executable
+ * - generate(): spawns process, writes prompt to stdin, reads full stdout
+ * - generateStream(): same but yields stdout line-by-line
+ */
+import { spawn } from 'child_process';
+import { access, constants } from 'fs/promises';
+export class ExecProcessor {
+    cmd;
+    args;
+    constructor(cmdSpec) {
+        const parts = cmdSpec.split(/\s+/);
+        this.cmd = parts[0];
+        this.args = parts.slice(1);
+    }
+    get name() {
+        return `exec:${this.cmd}`;
+    }
+    async verify() {
+        try {
+            await access(this.cmd, constants.X_OK);
+        }
+        catch {
+            throw new Error(`Exec processor: "${this.cmd}" is not executable or does not exist`);
+        }
+    }
+    generate(prompt) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.cmd, this.args, { stdio: ['pipe', 'pipe', 'pipe'] });
+            const chunks = [];
+            let stderr = '';
+            child.stdout.on('data', (data) => chunks.push(data));
+            child.stderr.on('data', (data) => { stderr += data.toString(); });
+            child.on('error', (err) => reject(new Error(`Exec spawn error: ${err.message}`)));
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Exec process exited with code ${code}: ${stderr}`));
+                }
+                else {
+                    resolve(Buffer.concat(chunks).toString('utf-8'));
+                }
+            });
+            child.stdin.write(prompt);
+            child.stdin.end();
+        });
+    }
+    async *generateStream(prompt) {
+        const child = spawn(this.cmd, this.args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        child.stdin.write(prompt);
+        child.stdin.end();
+        // Yield stdout line-by-line
+        let buffer = '';
+        try {
+            for await (const data of child.stdout) {
+                buffer += data.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop();
+                for (const line of lines) {
+                    yield line + '\n';
+                }
+            }
+            // Flush remaining
+            if (buffer.length > 0) {
+                yield buffer;
+            }
+        }
+        finally {
+            child.kill();
+        }
+    }
+}

package/dist/adapters/http-processor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP processor — delegates to a remote HTTP endpoint.
+ *
+ * PROCESSOR=http://localhost:8080/generate
+ *
+ * - verify(): HEAD request to check endpoint is reachable
+ * - generate(): POST JSON { prompt }, reads result/data/output field
+ * - generateStream(): POST with Accept: application/x-ndjson, yields lines
+ */
+import type { Processor } from '../processor.js';
+export declare class HttpProcessor implements Processor {
+    private url;
+    constructor(url: string);
+    get name(): string;
+    verify(): Promise<void>;
+    generate(prompt: string): Promise<string>;
+    generateStream(prompt: string): AsyncGenerator<string>;
+}

package/dist/adapters/http-processor.js

@@ -0,0 +1,102 @@
+/**
+ * HTTP processor — delegates to a remote HTTP endpoint.
+ *
+ * PROCESSOR=http://localhost:8080/generate
+ *
+ * - verify(): HEAD request to check endpoint is reachable
+ * - generate(): POST JSON { prompt }, reads result/data/output field
+ * - generateStream(): POST with Accept: application/x-ndjson, yields lines
+ */
+export class HttpProcessor {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    get name() {
+        return `http:${this.url}`;
+    }
+    async verify() {
+        try {
+            const res = await fetch(this.url, { method: 'HEAD' });
+            // Accept any response — we just need to know it's reachable
+            if (!res.ok && res.status !== 405) {
+                throw new Error(`HTTP ${res.status}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`HTTP processor: endpoint not reachable at ${this.url}: ${e.message}`);
+        }
+    }
+    async generate(prompt) {
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ prompt }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`HTTP processor error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        // Try common field names
+        const output = data.result ?? data.data ?? data.output ?? data.text ?? data.response;
+        if (output === undefined) {
+            throw new Error(`HTTP processor: response has no result/data/output/text/response field`);
+        }
+        return String(output);
+    }
+    async *generateStream(prompt) {
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/x-ndjson',
+            },
+            body: JSON.stringify({ prompt }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`HTTP processor stream error ${res.status}: ${text}`);
+        }
+        const reader = res.body?.getReader();
+        if (!reader)
+            throw new Error('HTTP processor: no response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    const chunk = obj.chunk ?? obj.data ?? obj.text ?? obj.token ?? obj.response;
+                    if (chunk !== undefined) {
+                        yield String(chunk);
+                    }
+                }
+                catch {
+                    // Not JSON — yield raw line
+                    yield line;
+                }
+            }
+        }
+        // Flush remaining
+        if (buffer.trim()) {
+            try {
+                const obj = JSON.parse(buffer);
+                const chunk = obj.chunk ?? obj.data ?? obj.text ?? obj.token ?? obj.response;
+                if (chunk !== undefined)
+                    yield String(chunk);
+            }
+            catch {
+                yield buffer;
+            }
+        }
+    }
+}

package/dist/adapters/none-processor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * None processor — pure pass-through, no local model needed.
+ *
+ * Use case: broker agents that receive tasks and delegate to sub-providers.
+ * generate() returns the prompt as-is so the pipeline can forward it.
+ */
+import type { Processor } from '../processor.js';
+export declare class NoneProcessor implements Processor {
+    readonly name = "none";
+    verify(): Promise<void>;
+    generate(prompt: string): Promise<string>;
+    generateStream(prompt: string): AsyncGenerator<string>;
+}

package/dist/adapters/none-processor.js

@@ -0,0 +1,18 @@
+/**
+ * None processor — pure pass-through, no local model needed.
+ *
+ * Use case: broker agents that receive tasks and delegate to sub-providers.
+ * generate() returns the prompt as-is so the pipeline can forward it.
+ */
+export class NoneProcessor {
+    name = 'none';
+    async verify() {
+        // No-op — nothing to check
+    }
+    async generate(prompt) {
+        return prompt;
+    }
+    async *generateStream(prompt) {
+        yield prompt;
+    }
+}

package/dist/adapters/ollama-processor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ollama processor — wraps existing ollama.ts into the Processor interface.
+ *
+ * Reads OLLAMA_MODEL env var (default "llama3.2").
+ * Zero behavior change from the previous hard-coded path in agent.ts.
+ */
+import type { Processor } from '../processor.js';
+export declare class OllamaProcessor implements Processor {
+    private model;
+    constructor();
+    get name(): string;
+    verify(): Promise<void>;
+    generate(prompt: string): Promise<string>;
+    generateStream(prompt: string): AsyncGenerator<string>;
+}

package/dist/adapters/ollama-processor.js

@@ -0,0 +1,29 @@
+/**
+ * Ollama processor — wraps existing ollama.ts into the Processor interface.
+ *
+ * Reads OLLAMA_MODEL env var (default "llama3.2").
+ * Zero behavior change from the previous hard-coded path in agent.ts.
+ */
+import { generate, generateStream, listModels } from './ollama.js';
+export class OllamaProcessor {
+    model;
+    constructor() {
+        this.model = process.env.OLLAMA_MODEL || 'llama3.2';
+    }
+    get name() {
+        return `ollama:${this.model}`;
+    }
+    async verify() {
+        const models = await listModels();
+        if (!models.some(m => m.startsWith(this.model))) {
+            throw new Error(`Model "${this.model}" not found. Available: ${models.join(', ')}\n` +
+                `Run: ollama pull ${this.model}`);
+        }
+    }
+    async generate(prompt) {
+        return generate({ model: this.model, prompt });
+    }
+    async *generateStream(prompt) {
+        yield* generateStream({ model: this.model, prompt });
+    }
+}

package/dist/adapters/ollama.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Ollama adapter — call local LLM via Ollama HTTP API
+ *
+ * Ollama runs on localhost:11434 by default.
+ * Supports streaming for real-time token delivery over Hyperswarm.
+ */
+export interface OllamaGenerateOptions {
+    model?: string;
+    prompt: string;
+    system?: string;
+    temperature?: number;
+    max_tokens?: number;
+}
+export interface OllamaChunk {
+    model: string;
+    response: string;
+    done: boolean;
+}
+/**
+ * Non-streaming generate — returns complete response
+ */
+export declare function generate(opts: OllamaGenerateOptions): Promise<string>;
+/**
+ * Streaming generate — yields tokens as they arrive
+ */
+export declare function generateStream(opts: OllamaGenerateOptions): AsyncGenerator<string>;
+/**
+ * Check if Ollama is running and list available models
+ */
+export declare function listModels(): Promise<string[]>;

package/dist/adapters/ollama.js

@@ -0,0 +1,86 @@
+/**
+ * Ollama adapter — call local LLM via Ollama HTTP API
+ *
+ * Ollama runs on localhost:11434 by default.
+ * Supports streaming for real-time token delivery over Hyperswarm.
+ */
+const OLLAMA_BASE = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+/**
+ * Non-streaming generate — returns complete response
+ */
+export async function generate(opts) {
+    const res = await fetch(`${OLLAMA_BASE}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model: opts.model || 'llama3.2',
+            prompt: opts.prompt,
+            system: opts.system,
+            stream: false,
+            options: {
+                temperature: opts.temperature ?? 0.7,
+                num_predict: opts.max_tokens ?? 2048,
+            },
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Ollama error ${res.status}: ${text}`);
+    }
+    const data = await res.json();
+    return data.response;
+}
+/**
+ * Streaming generate — yields tokens as they arrive
+ */
+export async function* generateStream(opts) {
+    const res = await fetch(`${OLLAMA_BASE}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model: opts.model || 'llama3.2',
+            prompt: opts.prompt,
+            system: opts.system,
+            stream: true,
+            options: {
+                temperature: opts.temperature ?? 0.7,
+                num_predict: opts.max_tokens ?? 2048,
+            },
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Ollama error ${res.status}: ${text}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error('No response body');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const chunk = JSON.parse(line);
+            if (chunk.response) {
+                yield chunk.response;
+            }
+        }
+    }
+}
+/**
+ * Check if Ollama is running and list available models
+ */
+export async function listModels() {
+    const res = await fetch(`${OLLAMA_BASE}/api/tags`);
+    if (!res.ok)
+        throw new Error(`Ollama not reachable at ${OLLAMA_BASE}`);
+    const data = await res.json();
+    return (data.models || []).map((m) => m.name);
+}

package/dist/agent.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Unified Agent Runtime — runs as a long-lived daemon that handles both:
+ *   1. Async platform tasks (inbox polling → accept → Ollama → submit result)
+ *   2. Real-time P2P streaming (Hyperswarm + Cashu micro-payments)
+ *
+ * Both channels share a single capacity counter so the agent never overloads.
+ *
+ * Usage:
+ *   AGENT=translator DVM_KIND=5302 OLLAMA_MODEL=qwen2.5:0.5b npm run agent
+ *   AGENT=my-agent DVM_KIND=5100 MAX_JOBS=5 npm run agent
+ *   DVM_KIND=5100 npm run agent          # no API key → P2P-only mode
+ *   AGENT=broker DVM_KIND=5302 PROCESSOR=none SUB_KIND=5100 npm run agent
+ *   AGENT=custom DVM_KIND=5100 PROCESSOR=exec:./my-model.sh npm run agent
+ *   AGENT=remote DVM_KIND=5100 PROCESSOR=http://localhost:8080 npm run agent
+ */
+export {};