cactus-react-native 0.2.8 → 0.2.10

package/src/lm.ts

@@ -11,7 +11,7 @@ import type {
 } from './index'
 
 import { Telemetry } from './telemetry'
-import { setCactusToken, getVertexAIEmbedding } from './remote'
+import { setCactusToken, getVertexAIEmbedding, getTextCompletion } from './remote'
 import { ConversationHistoryManager } from './chat'
 
 interface CactusLMReturn {
@@ -139,7 +139,50 @@ export class CactusLM {
 
   completion = async (
     messages: CactusOAICompatibleMessage[],
-    params: CompletionParams = {},
+    params: CompletionParams & { mode?: string } = {},
+    callback?: (data: any) => void,
+  ): Promise<NativeCompletionResult> => {
+    const mode = params.mode || 'local';
+
+    let result: NativeCompletionResult;
+    let lastError: Error | null = null;
+
+    if (mode === 'remote') {
+      result = await this._handleRemoteCompletion(messages, callback);
+    } else if (mode === 'local') {
+      result = await this._handleLocalCompletion(messages, params, callback);
+    } else if (mode === 'localfirst') {
+      try {
+        result = await this._handleLocalCompletion(messages, params, callback);
+      } catch (e) {
+        lastError = e as Error;
+        try {
+          result = await this._handleRemoteCompletion(messages, callback);
+        } catch (remoteError) {
+          throw lastError;
+        }
+      }
+    } else if (mode === 'remotefirst') {
+      try {
+        result = await this._handleRemoteCompletion(messages, callback);
+      } catch (e) {
+        lastError = e as Error;
+        try {
+          result = await this._handleLocalCompletion(messages, params, callback);
+        } catch (localError) {
+          throw lastError;
+        }
+      }
+    } else {
+      throw new Error('Invalid mode: ' + mode + '. Must be "local", "remote", "localfirst", or "remotefirst"');
+    }
+
+    return result;
+  }
+
+  private _handleLocalCompletion = async(
+    messages: CactusOAICompatibleMessage[],
+    params: CompletionParams,
     callback?: (data: any) => void,
   ): Promise<NativeCompletionResult> => {
     const { newMessages, requiresReset } =
@@ -166,6 +209,46 @@ export class CactusLM {
     return result;
   }
 
+  private async _handleRemoteCompletion(
+    messages: CactusOAICompatibleMessage[],
+    callback?: (data: any) => void,
+  ): Promise<NativeCompletionResult> {
+    const prompt = messages.map((m) => `${m.role}: ${m.content}`).join('\n');
+    
+    const responseText = await getTextCompletion(messages);
+    
+    if (callback) {
+      for (let i = 0; i < responseText.length; i++) {
+        callback({ token: responseText[i] });
+      }
+    }
+    
+    return {
+      text: responseText,
+      reasoning_content: '',
+      tool_calls: [],
+      content: responseText,
+      tokens_predicted: responseText.split(' ').length,
+      tokens_evaluated: prompt.split(' ').length,
+      truncated: false,
+      stopped_eos: true,
+      stopped_word: '',
+      stopped_limit: 0,
+      stopping_word: '',
+      tokens_cached: 0,
+      timings: {
+        prompt_n: prompt.split(' ').length,
+        prompt_ms: 0,
+        prompt_per_token_ms: 0,
+        prompt_per_second: 0,
+        predicted_n: responseText.split(' ').length,
+        predicted_ms: 0,
+        predicted_per_token_ms: 0,
+        predicted_per_second: 0,
+      },
+    };
+  }
+
   async embedding(
     text: string,
     params?: EmbeddingParams,
@@ -235,4 +318,7 @@ export class CactusLM {
     return await this.run(() => this.context.stopCompletion())
   }
 
+  isJinjaSupported(): boolean {
+    return this.context.isJinjaSupported();
+  }
 } 

package/src/remote.ts

@@ -1,3 +1,5 @@
+import type { CactusOAICompatibleMessage } from "./chat";
+
 let _cactusToken: string | null = null;
 
 export function setCactusToken(token: string | null): void {
@@ -5,58 +7,12 @@ export function setCactusToken(token: string | null): void {
 }
 
 export async function getVertexAIEmbedding(text: string): Promise<number[]> {
-  if (_cactusToken === null) {
-    throw new Error('CactusToken not set. Please call CactusLM.init with cactusToken parameter.');
-  }
-
-  const projectId = 'cactus-v1-452518';
-  const location = 'us-central1';
-  const modelId = 'text-embedding-005';
-  
-  const endpoint = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:predict`;
-
-  const headers = {
-    'Authorization': `Bearer ${_cactusToken}`,
-    'Content-Type': 'application/json',
-  };
-
-  const requestBody = {
-    instances: [{ content: text }]
-  };
-
-  const response = await fetch(endpoint, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(requestBody),
-  });
-
-  if (response.status === 401) {
-    _cactusToken = null;
-    throw new Error('Authentication failed. Please update your cactusToken.');
-  } else if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`HTTP ${response.status}: ${errorText}`);
-  }
-
-  const responseBody = await response.json();
-  
-  if (responseBody.error) {
-    throw new Error(`API Error: ${responseBody.error.message}`);
-  }
-  
-  const predictions = responseBody.predictions;
-  if (!predictions || predictions.length === 0) {
-    throw new Error('No predictions in response');
-  }
-  
-  const embeddings = predictions[0].embeddings;
-  const values = embeddings.values;
-  
-  return values;
+  text = text
+  throw new Error('Remote embedding is not currently supported. The Cactus library is in active development - if you need this functionality, please contact us at founders@cactuscompute.com');
 }
 
 export async function getVertexAICompletion(
-  textPrompt: string,
+  messages: CactusOAICompatibleMessage[],
   imageData?: string,
   imagePath?: string,
   mimeType?: string,
@@ -64,48 +20,48 @@ export async function getVertexAICompletion(
   if (_cactusToken === null) {
     throw new Error('CactusToken not set. Please call CactusVLM.init with cactusToken parameter.');
   }
-
-  const projectId = 'cactus-v1-452518';
-  const location = 'global';
-  const modelId = 'gemini-2.5-flash-lite-preview-06-17';
-  
-  const endpoint = `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:generateContent`;
+  const endpoint = 'https://openrouter.ai/api/v1/chat/completions';
 
   const headers = {
     'Authorization': `Bearer ${_cactusToken}`,
     'Content-Type': 'application/json',
   };
 
-  const parts: any[] = [];
-  
+  const requestBody = {
+    model: 'google/gemini-2.5-flash-lite',
+    messages: messages,
+  };
+
+  let imageUrl = ''
   if (imageData) {
-    const detectedMimeType = mimeType || 'image/jpeg';
-    parts.push({
-      inlineData: {
-        mimeType: detectedMimeType,
-        data: imageData
-      }
-    });
+    imageUrl = `data:${mimeType || 'image/jpeg'};base64,${imageData}`
   } else if (imagePath) {
-    const detectedMimeType = mimeType || detectMimeType(imagePath);
     const RNFS = require('react-native-fs');
     const base64Data = await RNFS.readFile(imagePath, 'base64');
-    parts.push({
-      inlineData: {
-        mimeType: detectedMimeType,
-        data: base64Data
-      }
-    });
+    imageUrl = `data:${mimeType || detectMimeType(imagePath)};base64,${base64Data}`
   }
-  
-  parts.push({ text: textPrompt });
 
-  const requestBody = {
-    contents: {
-      role: 'user',
-      parts: parts,
+  if (imageUrl) {
+    if (requestBody.messages[requestBody.messages.length - 1]?.role === 'user') {
+      requestBody.messages[requestBody.messages.length - 1] = {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: requestBody.messages[requestBody.messages.length - 1]?.content || ''
+          },
+          {
+            type: 'image_url',
+            image_url: {
+              url: imageUrl
+            }
+          }
+        ]
+      }
+    }else{
+      console.warn('Image data provided but message is not a user message: ', requestBody.messages);
     }
-  };
+  }
 
   const response = await fetch(endpoint, {
     method: 'POST',
@@ -122,39 +78,21 @@ export async function getVertexAICompletion(
   }
 
   const responseBody = await response.json();
-  
-  if (Array.isArray(responseBody)) {
-    throw new Error('Unexpected response format: received array instead of object');
-  }
-  
-  if (responseBody.error) {
-    throw new Error(`API Error: ${responseBody.error.message}`);
-  }
-  
-  const candidates = responseBody.candidates;
-  if (!candidates || candidates.length === 0) {
-    throw new Error('No candidates in response');
-  }
-  
-  const content = candidates[0].content;
-  const responseParts = content.parts;
-  if (!responseParts || responseParts.length === 0) {
-    throw new Error('No parts in response');
-  }
-  
-  return responseParts[0].text || '';
+  const responseText = responseBody.choices[0].message.content;
+
+  return responseText;
 }
 
-export async function getTextCompletion(prompt: string): Promise<string> {
-  return getVertexAICompletion(prompt);
+export async function getTextCompletion(messages: CactusOAICompatibleMessage[]): Promise<string> {
+  return getVertexAICompletion(messages);
 }
 
-export async function getVisionCompletion(prompt: string, imagePath: string): Promise<string> {
-  return getVertexAICompletion(prompt, undefined, imagePath);
+export async function getVisionCompletion(messages: CactusOAICompatibleMessage[], imagePath: string): Promise<string> {
+  return getVertexAICompletion(messages, undefined, imagePath);
 }
 
-export async function getVisionCompletionFromData(prompt: string, imageData: string, mimeType?: string): Promise<string> {
-  return getVertexAICompletion(prompt, imageData, undefined, mimeType);
+export async function getVisionCompletionFromData(messages: CactusOAICompatibleMessage[], imageData: string, mimeType?: string): Promise<string> {
+  return getVertexAICompletion(messages, imageData, undefined, mimeType);
 }
 
 function detectMimeType(filePath: string): string {

package/src/tools.ts

@@ -1,5 +1,18 @@
 import type { NativeCompletionResult } from "./NativeCactus";
 
+export type OpenAIToolSchema = {
+  type: "function",
+  function: {
+    name: string,
+    description: string,
+    parameters: {
+      type: "object", 
+      properties: {[key: string]: Parameter},
+      required: string[]
+    }
+  }
+}
+
 interface Parameter {
   type: string,
   description: string,
@@ -32,7 +45,7 @@ export class Tools {
       return func;
     }
   
-  getSchemas() {
+  getSchemas(): OpenAIToolSchema[] {
       return Array.from(this.tools.entries()).map(([name, { description, parameters, required }]) => ({
         type: "function",
         function: {

package/src/vlm.ts

@@ -221,9 +221,9 @@ export class CactusVLM {
     
     let responseText: string;
     if (imagePath) {
-      responseText = await getVisionCompletion(prompt, imagePath);
+      responseText = await getVisionCompletion(messages, imagePath);
     } else {
-      responseText = await getTextCompletion(prompt);
+      responseText = await getTextCompletion(messages);
     }
     
     if (callback) {
@@ -269,4 +269,8 @@ export class CactusVLM {
   async stopCompletion(): Promise<void> {
     return await this.context.stopCompletion()
   }
+
+  isJinjaSupported(): boolean {
+    return this.context.isJinjaSupported();
+  }
 }