wirejs-resources 0.1.148-llm → 0.1.150-llm

package/dist/services/llm.d.ts

@@ -1,29 +1,93 @@
 import { Resource } from '../resource.js';
+export type ToolCall = {
+    /** Unique identifier for this tool call */
+    id?: string;
+    /** Function to be called */
+    function: {
+        /** Name of the function to call */
+        name: string;
+        /** Arguments to pass to the function (JSON object) */
+        arguments: Record<string, any>;
+    };
+};
 export type LLMMessage = {
-    role: 'assistant' | 'user';
+    /** Standard user or assistant message */
+    role: 'user' | 'assistant';
+    /** Text content of the message */
+    content: string;
+    /** Tool calls requested by the assistant (only for assistant messages) */
+    tool_calls?: ToolCall[];
+} | {
+    /** Tool execution result message */
+    role: 'tool';
+    /** Result content from the tool execution */
     content: string;
+    /** Name of the tool that was executed */
+    tool_name: string;
+    /** ID linking this result to the original tool call */
+    tool_call_id: string;
 };
 export type LLMChunk = {
     created_at: string;
     message: LLMMessage;
     done: boolean;
 };
+type ToolParameterProperty = {
+    /** The property's data type */
+    type: string;
+    /** Human-readable description of this property */
+    description?: string;
+    /** Allowed values for this property (for constrained inputs) */
+    enum?: string[] | number[];
+    /** Schema for array elements when this property's type is 'array' */
+    items?: {
+        type: string;
+        description?: string;
+    };
+    /** Minimum value for numeric properties */
+    minimum?: number;
+    /** Maximum value for numeric properties */
+    maximum?: number;
+};
+export type ToolDefinition = {
+    /** The name of the tool function */
+    name: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** JSON Schema definition for the tool's parameters - defines named function parameters */
+    parameters: {
+        /** Always 'object' - functions must have named parameters */
+        type: 'object';
+        /** Named function parameters and their schemas */
+        properties: Record<string, ToolParameterProperty>;
+        /** Array of parameter names that must be provided */
+        required?: string[];
+    };
+};
 export type ContinueConversationOptions = {
     history: LLMMessage[];
     onChunk?: (chunk: LLMChunk) => void | Promise<void>;
     timeoutSeconds?: number;
     systemPrompt?: string;
+    models?: string[];
+    tools?: ToolDefinition[];
+    targetContextSize?: number;
 };
 export declare class LLM extends Resource {
     models: string[];
     systemPrompt: string | undefined;
+    targetContextSize: number;
+    tools: ToolDefinition[];
     constructor(scope: Resource | string, id: string, options: {
         models: string[];
         systemPrompt?: string;
+        targetContextSize?: number;
+        tools?: ToolDefinition[];
     });
     private stream;
     private checkOllamaAvailable;
     private checkModelExists;
     private createStreamedString;
-    continueConversation({ history, onChunk, timeoutSeconds, systemPrompt, }: ContinueConversationOptions): Promise<LLMMessage>;
+    continueConversation({ history, onChunk, timeoutSeconds, systemPrompt, targetContextSize, models, tools, }: ContinueConversationOptions): Promise<LLMMessage>;
 }
+export {};

package/dist/services/llm.js

@@ -2,10 +2,14 @@ import { Resource } from '../resource.js';
 export class LLM extends Resource {
     models;
     systemPrompt;
+    targetContextSize;
+    tools;
     constructor(scope, id, options) {
         super(scope, id);
         this.models = options.models;
         this.systemPrompt = options.systemPrompt;
+        this.targetContextSize = options.targetContextSize ?? 16384;
+        this.tools = options.tools ?? [];
     }
     async stream(response, onChunk) {
         if (!response.ok || !response.body) {
@@ -15,6 +19,7 @@ export class LLM extends Resource {
         const decoder = new TextDecoder('utf-8');
         let role = 'assistant';
         let content = '';
+        let tool_calls;
         while (true) {
             const { value, done } = await reader.read();
             if (done)
@@ -30,8 +35,22 @@ export class LLM extends Resource {
             }
             role = chunk.message.role;
             content += chunk.message.content;
+            // Capture tool calls if present in the chunk
+            if ('tool_calls' in chunk.message && chunk.message.tool_calls) {
+                tool_calls = chunk.message.tool_calls;
+            }
+        }
+        // Ensure we have a valid role, default to assistant if unexpected
+        const finalRole = (role === 'user' || role === 'assistant') ? role : 'assistant';
+        // Build the result message
+        const result = {
+            role: finalRole,
+            content
+        };
+        if (tool_calls) {
+            result.tool_calls = tool_calls;
         }
-        return { role, content };
+        return result;
     }
     async checkOllamaAvailable() {
         try {
@@ -77,7 +96,7 @@ export class LLM extends Resource {
             content: message
         };
     }
-    async continueConversation({ history, onChunk, timeoutSeconds, systemPrompt, }) {
+    async continueConversation({ history, onChunk, timeoutSeconds, systemPrompt, targetContextSize, models, tools, }) {
         const ollamaAvailable = await this.checkOllamaAvailable();
         if (!ollamaAvailable) {
             return this.createStreamedString('Ollama is not running locally. Please install and start Ollama:\n\n' +
@@ -87,7 +106,7 @@ export class LLM extends Resource {
                 '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) {
+        for (const model of models ?? this.models) {
             const modelExists = await this.checkModelExists(model);
             if (!modelExists)
                 continue;
@@ -100,6 +119,16 @@ export class LLM extends Resource {
                 }, timeoutSeconds * 1000);
             }
             const finalSystemPrompt = systemPrompt ?? this.systemPrompt;
+            const finalTools = tools ?? this.tools;
+            // Transform our ToolDefinition format to Ollama's expected format
+            const ollamaTools = finalTools.map(tool => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters
+                }
+            }));
             try {
                 const response = await fetch('http://localhost:11434/api/chat', {
                     method: 'POST',
@@ -116,6 +145,10 @@ export class LLM extends Resource {
                             ...history
                         ],
                         stream,
+                        ...(ollamaTools.length > 0 ? { tools: ollamaTools } : {}),
+                        options: {
+                            num_ctx: targetContextSize ?? this.targetContextSize
+                        }
                     }),
                     signal: controller.signal
                 });

package/package.json

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