wirejs-resources 0.1.130 → 0.1.132-llm

package/dist/index.d.ts

@@ -15,3 +15,4 @@ export * from './resources/background-job.js';
 export * from './resources/key-value-store.js';
 export * from './resources/endpoint.js';
 export * from './resources/system-attribute.js';
+export * from './services/llm.js';

package/dist/index.js

@@ -14,3 +14,4 @@ export * from './resources/background-job.js';
 export * from './resources/key-value-store.js';
 export * from './resources/endpoint.js';
 export * from './resources/system-attribute.js';
+export * from './services/llm.js';

package/dist/overrides.d.ts

@@ -4,6 +4,7 @@ import type { DistributedTable } from "./resources/distributed-table";
 import type { Endpoint } from "./resources/endpoint";
 import type { FileService } from "./services/file";
 import type { KeyValueStore } from "./resources/key-value-store";
+import type { LLM } from "./services/llm";
 import type { RealtimeService } from "./services/realtime";
 import type { Setting } from "./resources/setting";
 /**
@@ -16,6 +17,7 @@ export declare const overrides: {
     Endpoint?: typeof Endpoint;
     FileService?: typeof FileService;
     KeyValueStore?: typeof KeyValueStore;
+    LLM?: typeof LLM;
     RealtimeService?: typeof RealtimeService;
     Setting?: typeof Setting;
 };

package/dist/services/llm.d.ts

@@ -0,0 +1,21 @@
+import { Resource } from '../resource.js';
+export type LLMMessage = {
+    role: 'assistant' | 'user' | 'system' | 'tool';
+    content: string;
+};
+export type LLMChunk = {
+    created_at: string;
+    message: LLMMessage;
+    done: boolean;
+};
+export declare class LLM extends Resource {
+    models: string[];
+    constructor(scope: Resource | string, id: string, options: {
+        models: string[];
+    });
+    private stream;
+    private checkOllamaAvailable;
+    private checkModelExists;
+    private createStreamedString;
+    continueConversation(history: LLMMessage[], onChunk?: (chunk: LLMChunk) => void | Promise<void>): Promise<LLMMessage>;
+}

package/dist/services/llm.js

@@ -0,0 +1,117 @@
+import { Resource } from '../resource.js';
+export class LLM extends Resource {
+    models;
+    constructor(scope, id, options) {
+        super(scope, id);
+        this.models = options.models;
+    }
+    async stream(response, onChunk) {
+        if (!response.ok || !response.body) {
+            throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let role = 'assistant';
+        let content = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            const chunk = JSON.parse(decoder.decode(value, { stream: true }));
+            if (onChunk) {
+                try {
+                    await onChunk(chunk);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+            role = chunk.message.role;
+            content += chunk.message.content;
+        }
+        return { role, content };
+    }
+    async checkOllamaAvailable() {
+        try {
+            const response = await fetch('http://localhost:11434/api/tags', {
+                method: 'GET',
+            });
+            return response.ok;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async checkModelExists(model) {
+        try {
+            const response = await fetch('http://localhost:11434/api/tags');
+            if (!response.ok)
+                return false;
+            const data = await response.json();
+            return data.models?.some((m) => m.name === model || m.name.startsWith(model + ':'));
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    createStreamedString(message, onChunk) {
+        if (onChunk) {
+            try {
+                onChunk({
+                    created_at: new Date().toISOString(),
+                    done: true,
+                    message: {
+                        content: message,
+                        role: 'assistant'
+                    }
+                });
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+        return {
+            role: 'assistant',
+            content: message
+        };
+    }
+    async continueConversation(history, onChunk) {
+        const ollamaAvailable = await this.checkOllamaAvailable();
+        if (!ollamaAvailable) {
+            return this.createStreamedString('Ollama is not running locally. Please install and start Ollama:\n\n' +
+                '1. Visit https://ollama.com/ to download and install Ollama\n' +
+                '2. Start Ollama by running: ollama serve\n' +
+                '3. Pull a model (e.g., llama2): ollama pull llama2\n\n' +
+                'Models to try installing: ' + this.models.join(', '), onChunk);
+        }
+        // models should be in priority order. so, first one that works is the one we want.
+        for (const model of this.models) {
+            const modelExists = await this.checkModelExists(model);
+            if (!modelExists)
+                continue;
+            const stream = typeof onChunk === 'function';
+            const response = await fetch('http://localhost:11434/api/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: model,
+                    messages: [...history],
+                    stream,
+                })
+            });
+            if (response.ok) {
+                if (stream) {
+                    return this.stream(response, onChunk);
+                }
+                else {
+                    const chunk = await response.json();
+                    return chunk.message;
+                }
+            }
+        }
+        // if nothing works, we want to tell the user (the dev) how to install the dep.
+        return this.createStreamedString('None of the configured models are available. Please ensure Ollama is running and at least one of these models is installed:\n\n' +
+            this.models.map(m => `ollama pull ${m}`).join('\n') + '\n\n' +
+            'For more information, visit: https://ollama.com/', onChunk);
+    }
+}

package/dist/services/realtime.d.ts

@@ -18,6 +18,7 @@ export declare class RealtimeService<T = any> extends Resource {
      * The address the client will need to connect to.
      */
     address(context: Context): string;
+    getFullChannelName(channel: string): string;
     publish(channel: string, events: T[]): Promise<void>;
     getStream(context: Context, channel: string): Promise<MessageStream<T>>;
 }

package/dist/services/realtime.js

@@ -3,81 +3,65 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { Resource } from '../resource.js';
 import { Setting } from '../resources/setting.js';
 import { overrides } from '../overrides.js';
-const servers = new Map();
 const channels = new Map();
-export class RealtimeService extends Resource {
-    #channels;
-    #secret;
-    #server;
-    constructor(scope, id) {
-        super(scope, id);
-        this.#secret = new (overrides.Setting || Setting)(this, 'auth-secret', {
-            private: true, init: 'random',
-            description: "Used to sign realtime subscription authorization. Should generally not be changed."
-        });
-        if (servers.has(this.absoluteId)) {
-            console.log('existing realtime service found');
-            this.#server = servers.get(this.absoluteId);
+const secret = new (overrides.Setting || Setting)('wirejs', 'realtime-secret', {
+    private: true, init: 'random',
+    description: "Used to sign realtime subscription authorization. Should generally not be changed."
+});
+let _server;
+const server = () => {
+    if (_server)
+        return _server;
+    _server = new WebSocketServer({ port: 3001 });
+    _server.on('connection', async (ws, req) => {
+        const encodedChannel = req.url?.split('/')[1];
+        let channel;
+        const protocol = ws.protocol;
+        console.log('ws connection', { encodedChannel, protocol });
+        if (!encodedChannel) {
+            console.log('No channel specified');
+            ws.close(4000, 'Channel not specified');
+            return;
         }
-        if (channels.has(this.absoluteId)) {
-            console.log('existing channel entries found');
-            this.#channels = channels.get(this.absoluteId);
+        try {
+            channel = Buffer.from(encodedChannel, 'base64').toString('utf-8');
+            console.log('Decoded channel:', channel);
         }
-        else {
-            this.#channels = new Map();
-            channels.set(this.absoluteId, this.#channels);
+        catch (err) {
+            console.log('Invalid channel encoding');
+            ws.close(4004, 'Invalid channel encoding');
+            return;
         }
-    }
-    #requireServer() {
-        if (this.#server)
+        if (!protocol) {
+            console.log('No protocol specified');
+            ws.close(4001, 'Protocol not specified');
             return;
-        console.log('Starting WebSocket server...');
-        this.#server = new WebSocketServer({ port: 3001 });
-        servers.set(this.absoluteId, this.#server);
-        this.#server.on('connection', async (ws, req) => {
-            const encodedChannel = req.url?.split('/')[1];
-            let channel;
-            const protocol = ws.protocol;
-            console.log('ws connection', { encodedChannel, protocol });
-            if (!encodedChannel) {
-                console.log('No channel specified');
-                ws.close(4000, 'Channel not specified');
-                return;
-            }
-            try {
-                channel = Buffer.from(encodedChannel, 'base64').toString('utf-8');
-                console.log('Decoded channel:', channel);
-            }
-            catch (err) {
-                console.log('Invalid channel encoding');
-                ws.close(4004, 'Invalid channel encoding');
-                return;
-            }
-            if (!protocol) {
-                console.log('No protocol specified');
-                ws.close(4001, 'Protocol not specified');
-                return;
-            }
-            try {
-                const { payload } = await jose.jwtVerify(protocol, new TextEncoder().encode(await this.#secret.read()));
-                if (payload.channel !== channel) {
-                    console.log('Channel mismatch');
-                    ws.close(4003, 'Channel mismatch');
-                    return;
-                }
-            }
-            catch (err) {
-                console.log('Invalid token', err);
-                ws.close(4002, 'Invalid token');
+        }
+        try {
+            const { payload } = await jose.jwtVerify(protocol, new TextEncoder().encode(await secret.read()));
+            if (payload.channel !== channel) {
+                console.log('Channel mismatch', payload.channel, 'is not', channel);
+                ws.close(4003, 'Channel mismatch');
                 return;
             }
-            this.#channels.set(channel, this.#channels.get(channel) || []);
-            this.#channels.get(channel).push(ws);
-            ws.onclose = () => {
-                this.#channels.set(channel, this.#channels.get(channel).filter((w) => w !== ws));
-            };
-            console.log('WebSocket connection established:', channel);
-        });
+        }
+        catch (err) {
+            console.log('Invalid token', err);
+            ws.close(4002, 'Invalid token');
+            return;
+        }
+        channels.set(channel, channels.get(channel) || []);
+        channels.get(channel).push(ws);
+        ws.onclose = () => {
+            channels.set(channel, channels.get(channel).filter((w) => w !== ws));
+        };
+        console.log('WebSocket connection established:', channel);
+    });
+    return _server;
+};
+export class RealtimeService extends Resource {
+    constructor(scope, id) {
+        super(scope, id);
     }
     /**
      * Ensures channel name will be supported by known, major cloud provers using
@@ -101,8 +85,7 @@ export class RealtimeService extends Resource {
      * The address the client will need to connect to.
      */
     address(context) {
-        this.#requireServer();
-        const address = this.#server.address();
+        const address = server().address();
         if (typeof address === 'string') {
             return address;
         }
@@ -114,11 +97,13 @@ export class RealtimeService extends Resource {
             throw new Error('Server address is not available');
         }
     }
+    getFullChannelName(channel) {
+        return `${this.absoluteId}/${channel}`;
+    }
     async publish(channel, events) {
-        this.#requireServer();
         this.#validateChannelName(channel);
-        console.log('Publishing to channel:', channel, events);
-        (this.#channels.get(channel) || []).forEach((ws) => {
+        const fullChannelName = this.getFullChannelName(channel);
+        (channels.get(fullChannelName) || []).forEach((ws) => {
             if (ws.readyState === WebSocket.OPEN) {
                 for (const event of events) {
                     ws.send(JSON.stringify({ data: event }));
@@ -127,15 +112,15 @@ export class RealtimeService extends Resource {
         });
     }
     async getStream(context, channel) {
-        this.#requireServer();
         this.#validateChannelName(channel);
-        const channelString = Buffer.from(channel).toString('base64');
-        const payload = { channel };
+        const fullChannelName = this.getFullChannelName(channel);
+        const channelString = Buffer.from(fullChannelName).toString('base64');
+        const payload = { channel: fullChannelName };
         const jwt = await new jose.SignJWT(payload)
             .setProtectedHeader({ alg: 'HS256' })
             .setIssuedAt()
             .setExpirationTime(`10s`)
-            .sign(new TextEncoder().encode(await this.#secret.read()));
+            .sign(new TextEncoder().encode(await secret.read()));
         // The type we return is not at all what we actually return.
         // It's the metadata needed to satisfy the contract client-side.
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-resources",
-	"version": "0.1.130",
+	"version": "0.1.132-llm",
 	"description": "Basic services and server-side resources for wirejs apps",
 	"type": "module",
 	"main": "./dist/index.js",