groove-dev 0.27.74 → 0.27.75

package/node_modules/@groove-dev/daemon/src/providers/grok.js

@@ -0,0 +1,156 @@
+// GROOVE — xAI Grok Provider
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { Provider } from './base.js';
+
+async function parseSSEStream(response, onEvent) {
+  const reader = response.body.getReader();
+  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.startsWith('data: ')) {
+        const data = line.slice(6);
+        if (data === '[DONE]') { onEvent({ done: true }); return; }
+        try { onEvent(JSON.parse(data)); } catch { /* skip malformed */ }
+      }
+    }
+  }
+}
+
+export class GrokProvider extends Provider {
+  static name = 'grok';
+  static displayName = 'xAI Grok';
+  static command = '';
+  static authType = 'api-key';
+  static envKey = 'XAI_API_KEY';
+  static models = [
+    { id: 'grok-4', name: 'Grok 4', tier: 'heavy', maxContext: 131072, pricing: { input: 0.003, output: 0.015 } },
+    { id: 'grok-4-1-fast', name: 'Grok 4.1 Fast', tier: 'medium', maxContext: 131072, pricing: { input: 0.0002, output: 0.0005 } },
+    { id: 'grok-code-fast-1', name: 'Grok Code Fast', tier: 'medium', maxContext: 131072, pricing: { input: 0.0002, output: 0.0015 } },
+    { id: 'grok-3', name: 'Grok 3', tier: 'heavy', maxContext: 131072, pricing: { input: 0.003, output: 0.015 } },
+    { id: 'grok-3-mini', name: 'Grok 3 Mini', tier: 'light', maxContext: 131072, pricing: { input: 0.0003, output: 0.0005 } },
+    { id: 'grok-imagine-image', name: 'Grok Imagine', tier: 'medium', type: 'image', pricing: { perImage: 0.07 } },
+  ];
+
+  static isInstalled() {
+    return true; // API-only, no CLI needed
+  }
+
+  static installCommand() {
+    return '';
+  }
+
+  buildSpawnCommand() {
+    return null; // No agent harness
+  }
+
+  buildHeadlessCommand() {
+    return null; // No CLI
+  }
+
+  switchModel() {
+    return false;
+  }
+
+  parseOutput() {
+    return null;
+  }
+
+  static estimateCost(tokens, modelId) {
+    const model = GrokProvider.models.find((m) => m.id === modelId);
+    if (!model?.pricing) return 0;
+    const inputTokens = Math.round(tokens * 0.75);
+    const outputTokens = tokens - inputTokens;
+    return (inputTokens / 1000) * model.pricing.input + (outputTokens / 1000) * model.pricing.output;
+  }
+
+  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+    if (!apiKey) return null;
+    const controller = new AbortController();
+    let finished = false;
+    const finish = () => { if (!finished) { finished = true; onDone(); } };
+    fetch('https://api.x.ai/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model || 'grok-4-1-fast',
+        messages,
+        stream: true,
+      }),
+      signal: controller.signal,
+    }).then((res) => {
+      if (!res.ok) {
+        return res.text().then((t) => { throw new Error(`xAI API ${res.status}: ${t.slice(0, 200)}`); });
+      }
+      return parseSSEStream(res, (event) => {
+        if (event.done) { finish(); return; }
+        const content = event.choices?.[0]?.delta?.content;
+        if (content) onChunk(content);
+      });
+    }).then(() => {
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
+  async generateImage(prompt, options = {}) {
+    const apiKey = options.apiKey;
+    if (!apiKey) throw new Error('XAI_API_KEY required for image generation');
+
+    const body = {
+      model: options.model || 'grok-imagine-image',
+      prompt,
+      n: 1,
+    };
+    if (options.size) body.size = options.size;
+
+    const res = await fetch('https://api.x.ai/v1/images/generations', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`xAI Image API ${res.status}: ${text.slice(0, 200)}`);
+    }
+
+    const data = await res.json();
+    const image = data.data?.[0];
+    return {
+      url: image?.url || null,
+      b64_json: image?.b64_json || null,
+      model: body.model,
+      provider: 'grok',
+    };
+  }
+
+  static setupGuide() {
+    return {
+      installSteps: [],
+      authMethods: ['api-key'],
+      authInstructions: {
+        apiKeyHelp: 'Get your API key from console.x.ai',
+      },
+    };
+  }
+
+  static authMethods() {
+    return ['api-key'];
+  }
+}

package/node_modules/@groove-dev/daemon/src/providers/index.js

@@ -7,6 +7,8 @@ import { ClaudeCodeProvider } from './claude-code.js';
 import { CodexProvider } from './codex.js';
 import { GeminiProvider } from './gemini.js';
 import { OllamaProvider } from './ollama.js';
+import { GrokProvider } from './grok.js';
+import { NanaBananaProvider } from './nano-banana.js';
 import { LocalProvider } from './local.js';
 import { GrooveNetworkProvider } from './groove-network.js';
 
@@ -67,7 +69,9 @@ const providers = {
   'claude-code': new ClaudeCodeProvider(),
   'codex': new CodexProvider(),
   'gemini': new GeminiProvider(),
+  'grok': new GrokProvider(),
   'ollama': new OllamaProvider(),
+  'nano-banana': new NanaBananaProvider(),
   'local': new LocalProvider(),
   'groove-network': new GrooveNetworkProvider(),
 };
@@ -93,7 +97,7 @@ export function getProvider(name) {
 
 // Providers hidden from UI but kept for backward compatibility
 // (existing agents with provider='ollama' still resolve via getProvider)
-const HIDDEN_PROVIDERS = new Set(['ollama']);
+const HIDDEN_PROVIDERS = new Set(['ollama', 'nano-banana']);
 
 export function listProviders() {
   return Object.entries(providers)

package/node_modules/@groove-dev/daemon/src/providers/nano-banana.js

@@ -0,0 +1,103 @@
+// GROOVE — Nano Banana Provider (Google Image Generation)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Nano Banana is Google's image generation family built on Gemini models:
+//   - Nano Banana 2 (Gemini 3.1 Flash Image) — fast generation
+//   - Nano Banana Pro (Gemini 3 Pro Image) — professional quality, up to 4K
+// Uses the Gemini API with responseModalities: ["IMAGE"].
+
+import { Provider } from './base.js';
+
+export class NanaBananaProvider extends Provider {
+  static name = 'nano-banana';
+  static displayName = 'Nano Banana';
+  static command = '';
+  static authType = 'api-key';
+  static envKey = 'GEMINI_API_KEY';
+  static models = [
+    { id: 'nano-banana-2', name: 'Nano Banana 2', tier: 'medium', type: 'image', geminiModel: 'gemini-2.0-flash-preview-image-generation', pricing: { perImage: 0.02 } },
+    { id: 'nano-banana-pro', name: 'Nano Banana Pro', tier: 'heavy', type: 'image', geminiModel: 'gemini-2.0-flash-preview-image-generation', pricing: { perImage: 0.05 } },
+  ];
+
+  static isInstalled() {
+    return true; // API-only, shares GEMINI_API_KEY
+  }
+
+  static installCommand() {
+    return '';
+  }
+
+  buildSpawnCommand() {
+    return null;
+  }
+
+  buildHeadlessCommand() {
+    return null;
+  }
+
+  switchModel() {
+    return false;
+  }
+
+  parseOutput() {
+    return null;
+  }
+
+  async generateImage(prompt, options = {}) {
+    const apiKey = options.apiKey;
+    if (!apiKey) throw new Error('GEMINI_API_KEY required for Nano Banana image generation');
+
+    const modelEntry = NanaBananaProvider.models.find((m) => m.id === (options.model || 'nano-banana-2'));
+    const geminiModel = modelEntry?.geminiModel || 'gemini-2.0-flash-preview-image-generation';
+
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:generateContent?key=${apiKey}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: prompt }] }],
+          generationConfig: {
+            responseModalities: ['TEXT', 'IMAGE'],
+          },
+        }),
+      },
+    );
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Nano Banana API ${res.status}: ${text.slice(0, 200)}`);
+    }
+
+    const data = await res.json();
+    const parts = data.candidates?.[0]?.content?.parts || [];
+    const imagePart = parts.find((p) => p.inlineData);
+
+    if (!imagePart) {
+      const textPart = parts.find((p) => p.text);
+      throw new Error(textPart?.text || 'No image generated');
+    }
+
+    return {
+      url: null,
+      b64_json: imagePart.inlineData.data,
+      mimeType: imagePart.inlineData.mimeType || 'image/png',
+      model: options.model || 'nano-banana-2',
+      provider: 'nano-banana',
+    };
+  }
+
+  static setupGuide() {
+    return {
+      installSteps: [],
+      authMethods: ['api-key'],
+      authInstructions: {
+        apiKeyHelp: 'Uses your Gemini API key — get one at aistudio.google.com',
+      },
+    };
+  }
+
+  static authMethods() {
+    return ['api-key'];
+  }
+}