nothumanallowed 9.8.0 → 9.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "9.8.0",
+  "version": "9.8.1",
   "description": "NotHumanAllowed — 38 AI agents, 53 tools. Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, GitHub, Notion, Slack, voice chat, 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '9.8.0';
+export const VERSION = '9.8.1';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/llm.mjs

@@ -276,110 +276,141 @@ export async function callLLM(config, systemPrompt, userMessage, opts = {}) {
 }
 
 /**
- * Call LLM with multimodal (vision) messages — supports image content.
- * Uses the provider's native vision format.
- * @param {object} config
- * @param {Array} messages - Array of { role, content } where content can be string or array of content blocks
- * @returns {Promise<string>}
+ * Call an LLM provider with streaming enabled.
+ * Calls onToken(chunk) for each token, returns full text at the end.
+ * @returns {Promise<string>} The full LLM response text.
  */
-export async function callLLMVision(config, messages) {
-  const provider = config.llm.provider || 'anthropic';
-  const model = config.llm.model || null;
+export async function callLLMStream(config, systemPrompt, userMessage, onToken, opts = {}) {
+  const provider = opts.provider || config.llm.provider || 'anthropic';
+  const model = opts.model || config.llm.model || null;
   const apiKey = getApiKey(config, provider);
-  if (!apiKey) throw new Error(`No API key for ${provider}. Vision requires Claude, GPT-4, or Gemini.`);
+  if (!apiKey) throw new Error(`No API key for ${provider}`);
 
-  if (provider === 'anthropic') {
-    // Anthropic format: system separate, messages with content blocks
-    const systemMsg = messages.find(m => m.role === 'system');
-    const userMsgs = messages.filter(m => m.role !== 'system');
-
-    // Convert OpenAI-style image_url to Anthropic format
-    const anthropicMessages = userMsgs.map(m => {
-      if (typeof m.content === 'string') return m;
-      const blocks = m.content.map(block => {
-        if (block.type === 'text') return block;
-        if (block.type === 'image_url') {
-          const url = block.image_url.url;
-          const match = url.match(/^data:image\/(png|jpeg|gif|webp);base64,(.+)$/);
-          if (match) {
-            return { type: 'image', source: { type: 'base64', media_type: `image/${match[1]}`, data: match[2] } };
-          }
-        }
-        return block;
-      });
-      return { role: m.role, content: blocks };
-    });
+  const callFn = getProviderCall(provider);
+  if (!callFn) throw new Error(`Unknown provider: ${provider}`);
+
+  // Gemini and Cohere don't support streaming — fall back to non-streaming
+  if (provider === 'gemini' || provider === 'cohere') {
+    const text = await callFn(apiKey, model, systemPrompt, userMessage, false);
+    if (onToken) onToken(text);
+    return text;
+  }
+
+  const format = provider === 'anthropic' ? 'anthropic' : 'openai';
+  const body = buildRequestBody(provider, model, systemPrompt, userMessage, true);
+  const url = getProviderUrl(provider, model, apiKey);
+  const headers = getProviderHeaders(provider, apiKey);
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`${provider} ${res.status}: ${err}`);
+  }
 
-    const body = {
+  return streamSSEWithCallback(res, format, onToken);
+}
+
+/** Build request body for a provider */
+function buildRequestBody(provider, model, systemPrompt, userMessage, stream) {
+  if (provider === 'anthropic') {
+    return {
       model: model || 'claude-sonnet-4-20250514',
-      max_tokens: 4096,
-      system: systemMsg?.content || '',
-      messages: anthropicMessages,
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+      stream,
     };
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw new Error(`Anthropic vision ${res.status}: ${await res.text()}`);
-    const data = await res.json();
-    return data.content?.[0]?.text || '';
   }
+  // OpenAI-compatible format (OpenAI, DeepSeek, Grok, Mistral)
+  const modelDefaults = {
+    openai: 'gpt-4o',
+    deepseek: 'deepseek-chat',
+    grok: 'grok-3-latest',
+    mistral: 'mistral-large-latest',
+  };
+  return {
+    model: model || modelDefaults[provider] || 'gpt-4o',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+}
+
+/** Get provider API URL */
+function getProviderUrl(provider, model, apiKey) {
+  const urls = {
+    anthropic: 'https://api.anthropic.com/v1/messages',
+    openai: 'https://api.openai.com/v1/chat/completions',
+    deepseek: 'https://api.deepseek.com/v1/chat/completions',
+    grok: 'https://api.x.ai/v1/chat/completions',
+    mistral: 'https://api.mistral.ai/v1/chat/completions',
+  };
+  return urls[provider] || urls.openai;
+}
 
-  if (provider === 'openai' || provider === 'deepseek' || provider === 'grok' || provider === 'mistral') {
-    // OpenAI-compatible format — works with GPT-4V, DeepSeek VL, etc.
-    const url = provider === 'openai' ? 'https://api.openai.com/v1/chat/completions'
-              : provider === 'deepseek' ? 'https://api.deepseek.com/chat/completions'
-              : provider === 'grok' ? 'https://api.x.ai/v1/chat/completions'
-              : 'https://api.mistral.ai/v1/chat/completions';
-
-    const visionModel = model || (provider === 'openai' ? 'gpt-4o' : model);
-    const body = { model: visionModel, max_tokens: 4096, messages };
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw new Error(`${provider} vision ${res.status}: ${await res.text()}`);
-    const data = await res.json();
-    return data.choices?.[0]?.message?.content || '';
+/** Get provider request headers */
+function getProviderHeaders(provider, apiKey) {
+  if (provider === 'anthropic') {
+    return {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    };
   }
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey}`,
+  };
+}
+
+/** SSE stream parser with onToken callback (does NOT write to stdout directly) */
+async function streamSSEWithCallback(res, format, onToken) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullText = '';
+
+  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.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') continue;
+
+      try {
+        const json = JSON.parse(data);
+        let chunk = '';
 
-  if (provider === 'gemini') {
-    // Gemini format — inline_data with base64
-    const systemMsg = messages.find(m => m.role === 'system');
-    const userMsgs = messages.filter(m => m.role !== 'system');
-    const parts = [];
-    for (const msg of userMsgs) {
-      if (typeof msg.content === 'string') {
-        parts.push({ text: msg.content });
-      } else {
-        for (const block of msg.content) {
-          if (block.type === 'text') parts.push({ text: block.text });
-          if (block.type === 'image_url') {
-            const match = block.image_url.url.match(/^data:image\/(.*?);base64,(.+)$/);
-            if (match) parts.push({ inline_data: { mime_type: `image/${match[1]}`, data: match[2] } });
+        if (format === 'anthropic') {
+          if (json.type === 'content_block_delta') {
+            chunk = json.delta?.text || '';
           }
+        } else {
+          chunk = json.choices?.[0]?.delta?.content || '';
         }
-      }
-    }
 
-    const geminiModel = model || 'gemini-2.0-flash';
-    const body = {
-      contents: [{ parts }],
-      systemInstruction: systemMsg ? { parts: [{ text: systemMsg.content }] } : undefined,
-    };
-    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:generateContent?key=${apiKey}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw new Error(`Gemini vision ${res.status}: ${await res.text()}`);
-    const data = await res.json();
-    return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        if (chunk) {
+          fullText += chunk;
+          if (onToken) onToken(chunk);
+        }
+      } catch {}
+    }
   }
 
-  throw new Error(`Vision not supported for provider: ${provider}. Use Claude, GPT-4, or Gemini.`);
+  return fullText;
 }
 
 /**