gigaclaw 1.4.0

package/lib/ai/index.js

@@ -0,0 +1,342 @@
+import { HumanMessage, AIMessage } from '@langchain/core/messages';
+import { z } from 'zod';
+import { getJobAgent, getCodeAgent } from './agent.js';
+import { createModel } from './model.js';
+import { jobSummaryMd } from '../paths.js';
+import { render_md } from '../utils/render-md.js';
+import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
+
+/**
+ * Ensure a chat exists in the DB and save a message.
+ * Centralized so every channel gets persistence automatically.
+ *
+ * @param {string} threadId - Chat/thread ID
+ * @param {string} role - 'user' or 'assistant'
+ * @param {string} text - Message text
+ * @param {object} [options] - { userId, chatTitle }
+ */
+function persistMessage(threadId, role, text, options = {}) {
+  try {
+    if (!getChatById(threadId)) {
+      createChat(options.userId || 'unknown', options.chatTitle || 'New Chat', threadId);
+    }
+    saveMessage(threadId, role, text);
+  } catch (err) {
+    // DB persistence is best-effort — don't break chat if DB fails
+    console.error('Failed to persist message:', err);
+  }
+}
+
+/**
+ * Process a chat message through the LangGraph agent.
+ * Saves user and assistant messages to the DB automatically.
+ *
+ * @param {string} threadId - Conversation thread ID (from channel adapter)
+ * @param {string} message - User's message text
+ * @param {Array} [attachments=[]] - Normalized attachments from adapter
+ * @param {object} [options] - { userId, chatTitle } for DB persistence
+ * @returns {Promise<string>} AI response text
+ */
+async function chat(threadId, message, attachments = [], options = {}) {
+  const agent = await getJobAgent();
+
+  // Save user message to DB
+  persistMessage(threadId, 'user', message || '[attachment]', options);
+
+  // Build content blocks: text + any image attachments as base64 vision
+  const content = [];
+
+  if (message) {
+    content.push({ type: 'text', text: message });
+  }
+
+  for (const att of attachments) {
+    if (att.category === 'image') {
+      content.push({
+        type: 'image_url',
+        image_url: {
+          url: `data:${att.mimeType};base64,${att.data.toString('base64')}`,
+        },
+      });
+    }
+    // Documents: future handling
+  }
+
+  // If only text and no attachments, simplify to a string
+  const messageContent = content.length === 1 && content[0].type === 'text'
+    ? content[0].text
+    : content;
+
+  const result = await agent.invoke(
+    { messages: [new HumanMessage({ content: messageContent })] },
+    { configurable: { thread_id: threadId } }
+  );
+
+  const lastMessage = result.messages[result.messages.length - 1];
+
+  // LangChain message content can be a string or an array of content blocks
+  let response;
+  if (typeof lastMessage.content === 'string') {
+    response = lastMessage.content;
+  } else {
+    response = lastMessage.content
+      .filter((block) => block.type === 'text')
+      .map((block) => block.text)
+      .join('\n');
+  }
+
+  // Save assistant response to DB
+  persistMessage(threadId, 'assistant', response, options);
+
+  // Auto-generate title for new chats
+  if (options.userId && message) {
+    autoTitle(threadId, message).catch(() => {});
+  }
+
+  return response;
+}
+
+/**
+ * Process a chat message with streaming (for channels that support it).
+ * Saves user and assistant messages to the DB automatically.
+ *
+ * @param {string} threadId - Conversation thread ID
+ * @param {string} message - User's message text
+ * @param {Array} [attachments=[]] - Image/PDF attachments: { category, mimeType, dataUrl }
+ * @param {object} [options] - { userId, chatTitle, skipUserPersist } for DB persistence
+ * @returns {AsyncIterableIterator<string>} Stream of text chunks
+ */
+async function* chatStream(threadId, message, attachments = [], options = {}) {
+  let agent;
+
+  // Code mode: set up workspace + code agent
+  if (options.repo && options.branch) {
+    const existingChat = getChatById(threadId);
+    let workspaceId;
+
+    if (!existingChat) {
+      // First message: create workspace row, then chat, then link them
+      const { createCodeWorkspace } = await import('../db/code-workspaces.js');
+      const workspace = createCodeWorkspace(options.userId || 'unknown', {
+        repo: options.repo,
+        branch: options.branch,
+      });
+      workspaceId = workspace.id;
+      createChat(options.userId || 'unknown', 'New Chat', threadId);
+      linkChatToWorkspace(threadId, workspaceId);
+    } else {
+      workspaceId = existingChat.codeWorkspaceId;
+    }
+
+    agent = await getCodeAgent({
+      repo: options.repo,
+      branch: options.branch,
+      workspaceId,
+      chatId: threadId,
+    });
+  } else {
+    agent = await getJobAgent();
+  }
+
+  // Save user message to DB (skip on regeneration — message already exists)
+  if (!options.skipUserPersist) {
+    persistMessage(threadId, 'user', message || '[attachment]', options);
+  }
+
+  // Build content blocks: text + any image/PDF attachments as vision
+  const content = [];
+
+  if (message) {
+    content.push({ type: 'text', text: message });
+  }
+
+  for (const att of attachments) {
+    if (att.category === 'image') {
+      // Support both dataUrl (web) and Buffer (Telegram) formats
+      const url = att.dataUrl
+        ? att.dataUrl
+        : `data:${att.mimeType};base64,${att.data.toString('base64')}`;
+      content.push({
+        type: 'image_url',
+        image_url: { url },
+      });
+    }
+  }
+
+  // If only text and no attachments, simplify to a string
+  const messageContent = content.length === 1 && content[0].type === 'text'
+    ? content[0].text
+    : content;
+
+  try {
+    const stream = await agent.stream(
+      { messages: [new HumanMessage({ content: messageContent })] },
+      { configurable: { thread_id: threadId }, streamMode: 'messages' }
+    );
+
+    let fullText = '';
+    let webSearchInput = '';
+
+    for await (const event of stream) {
+      // streamMode: 'messages' yields [message, metadata] tuples
+      const msg = Array.isArray(event) ? event[0] : event;
+      const msgType = msg._getType?.();
+
+      if (msgType === 'ai') {
+        // Debug: log web search content blocks to see actual shape
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === 'server_tool_use' || block.type === 'server_tool_call' || block.type === 'web_search_tool_result') {
+              console.log(`[chatStream] ${block.type}:`, JSON.stringify(block));
+            }
+          }
+        }
+
+        // Tool calls — AIMessage.tool_calls is an array of { id, name, args }
+        if (msg.tool_calls?.length > 0) {
+          for (const tc of msg.tool_calls) {
+            yield {
+              type: 'tool-call',
+              toolCallId: tc.id,
+              toolName: tc.name,
+              args: tc.args,
+            };
+          }
+        }
+
+        // Text content (wrapped in structured object)
+        let text = '';
+        if (typeof msg.content === 'string') {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content
+            .filter((b) => b.type === 'text' && b.text)
+            .map((b) => b.text)
+            .join('');
+        }
+
+        if (text) {
+          fullText += text;
+          yield { type: 'text', text };
+        }
+      } else if (msgType === 'tool') {
+        // Tool result — ToolMessage has tool_call_id and content
+        yield {
+          type: 'tool-result',
+          toolCallId: msg.tool_call_id,
+          result: msg.content,
+        };
+      }
+      // Skip other message types (human, system)
+    }
+
+    // Save assistant response to DB
+    if (fullText) {
+      persistMessage(threadId, 'assistant', fullText, options);
+    }
+
+    // Auto-generate title for new chats
+    if (options.userId && message) {
+      autoTitle(threadId, message).catch(() => {});
+    }
+  } catch (err) {
+    console.error('[chatStream] error:', err);
+    throw err;
+  }
+}
+
+/**
+ * Auto-generate a chat title from the first user message (fire-and-forget).
+ * Uses structured output to avoid thinking-token leaks with extended-thinking models.
+ */
+async function autoTitle(threadId, firstMessage) {
+  try {
+    const chat = getChatById(threadId);
+    if (!chat || chat.title !== 'New Chat') return;
+
+    const model = await createModel({ maxTokens: 250 });
+    const response = await model.withStructuredOutput(z.object({ title: z.string() })).invoke([
+      ['system', 'Generate a descriptive (8-12 word) title for this chat based on the user\'s first message.'],
+      ['human', firstMessage],
+    ]);
+    if (response.title.trim()) {
+      updateChatTitle(threadId, response.title.trim());
+    }
+  } catch (err) {
+    console.error('[autoTitle] Failed to generate title:', err.message);
+  }
+}
+
+/**
+ * One-shot summarization with a different system prompt and no memory.
+ * Used for job completion summaries sent via GitHub webhook.
+ *
+ * @param {object} results - Job results from webhook payload
+ * @returns {Promise<string>} Summary text
+ */
+async function summarizeJob(results) {
+  try {
+    const model = await createModel({ maxTokens: 1024 });
+    const systemPrompt = render_md(jobSummaryMd);
+
+    if (!systemPrompt) {
+      console.error(`[summarizeJob] Empty system prompt — JOB_SUMMARY.md not found or empty at: ${jobSummaryMd}`);
+    }
+
+    const userMessage = [
+      results.job ? `## Task\n${results.job}` : '',
+      results.commit_message ? `## Commit Message\n${results.commit_message}` : '',
+      results.changed_files?.length ? `## Changed Files\n${results.changed_files.join('\n')}` : '',
+      results.status ? `## Status\n${results.status}` : '',
+      results.merge_result ? `## Merge Result\n${results.merge_result}` : '',
+      results.pr_url ? `## PR URL\n${results.pr_url}` : '',
+      results.run_url ? `## Run URL\n${results.run_url}` : '',
+      results.log ? `## Agent Log\n${results.log}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n\n');
+
+    console.log(`[summarizeJob] System prompt: ${systemPrompt.length} chars, user message: ${userMessage.length} chars`);
+
+    const response = await model.invoke([
+      ['system', systemPrompt],
+      ['human', userMessage],
+    ]);
+
+    const text =
+      typeof response.content === 'string'
+        ? response.content
+        : response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+
+    console.log(`[summarizeJob] Result: ${text.length} chars — ${text.slice(0, 200)}`);
+
+    return text.trim() || 'Job finished.';
+  } catch (err) {
+    console.error('[summarizeJob] Failed to summarize job:', err);
+    return 'Job finished.';
+  }
+}
+
+/**
+ * Inject a message into a thread's memory so the agent has context
+ * for future conversations (e.g., job completion summaries).
+ *
+ * @param {string} threadId - Conversation thread ID
+ * @param {string} text - Message text to inject as an assistant message
+ */
+async function addToThread(threadId, text) {
+  try {
+    const agent = await getJobAgent();
+    await agent.updateState(
+      { configurable: { thread_id: threadId } },
+      { messages: [new AIMessage(text)] }
+    );
+  } catch (err) {
+    console.error('Failed to add message to thread:', err);
+  }
+}
+
+export { chat, chatStream, summarizeJob, addToThread, persistMessage };

package/lib/ai/model.js

@@ -0,0 +1,180 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+
+const DEFAULT_MODELS = {
+  anthropic: 'claude-sonnet-4-20250514',
+  openai: 'gpt-4o',
+  google: 'gemini-2.5-pro',
+  pragatigpt: 'pragatigpt-1',
+  ollama: 'llama3.2',
+  custom: 'gpt-4o',
+};
+
+/**
+ * Create a LangChain chat model based on environment configuration.
+ *
+ * Supported providers (set via LLM_PROVIDER env var):
+ *   anthropic    — Claude models via Anthropic API (default)
+ *   openai       — GPT models via OpenAI API
+ *   google       — Gemini models via Google AI Studio
+ *   pragatigpt   — PragatiGPT via Gignaati edge API (India-first, on-premise)
+ *   ollama       — Any model running locally via Ollama (zero cloud dependency)
+ *   custom       — Any OpenAI-compatible API endpoint
+ *
+ * Config env vars:
+ *   LLM_PROVIDER          — Provider name (see above)
+ *   LLM_MODEL             — Model name override
+ *   LLM_MAX_TOKENS        — Max tokens (default: 4096)
+ *   ANTHROPIC_API_KEY     — Required for anthropic
+ *   OPENAI_API_KEY        — Required for openai
+ *   OPENAI_BASE_URL       — Custom base URL for openai/custom
+ *   GOOGLE_API_KEY        — Required for google
+ *   PRAGATIGPT_API_KEY    — Required for pragatigpt
+ *   PRAGATIGPT_BASE_URL   — PragatiGPT endpoint (default: https://api.pragatigpt.in/v1)
+ *   OLLAMA_BASE_URL       — Ollama server URL (default: http://localhost:11434)
+ *   CUSTOM_API_KEY        — API key for custom endpoints
+ *
+ * @param {object} [options]
+ * @param {number} [options.maxTokens=4096] - Max tokens for the response
+ * @returns {import('@langchain/core/language_models/chat_models').BaseChatModel}
+ */
+export async function createModel(options = {}) {
+  const provider = options.providerOverride || process.env.LLM_PROVIDER || 'anthropic';
+  const modelName = options.modelOverride || process.env.LLM_MODEL || DEFAULT_MODELS[provider] || DEFAULT_MODELS.anthropic;
+  const maxTokens = options.maxTokens || Number(process.env.LLM_MAX_TOKENS) || 4096;
+
+  switch (provider) {
+    case 'anthropic': {
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          'ANTHROPIC_API_KEY is required.\n' +
+          'Get your key at: https://platform.claude.com/settings/keys\n' +
+          'Then run: npx gigaclaw set-agent-secret ANTHROPIC_API_KEY'
+        );
+      }
+      return new ChatAnthropic({ modelName, maxTokens, anthropicApiKey: apiKey });
+    }
+
+    case 'openai': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const apiKey = process.env.OPENAI_API_KEY;
+      const baseURL = process.env.OPENAI_BASE_URL;
+      if (!apiKey) {
+        throw new Error(
+          'OPENAI_API_KEY is required.\n' +
+          'Get your key at: https://platform.openai.com/settings/organization/api-keys\n' +
+          'Then run: npx gigaclaw set-agent-secret OPENAI_API_KEY'
+        );
+      }
+      const config = { modelName, maxTokens, apiKey };
+      if (baseURL) config.configuration = { baseURL };
+      return new ChatOpenAI(config);
+    }
+
+    case 'google': {
+      const { ChatGoogleGenerativeAI } = await import('@langchain/google-genai');
+      const apiKey = process.env.GOOGLE_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          'GOOGLE_API_KEY is required.\n' +
+          'Get your key at: https://aistudio.google.com/apikey\n' +
+          'Then run: npx gigaclaw set-agent-secret GOOGLE_API_KEY'
+        );
+      }
+      return new ChatGoogleGenerativeAI({ model: modelName, maxOutputTokens: maxTokens, apiKey });
+    }
+
+    // PragatiGPT — India-first, edge-native AI by Gignaati
+    case 'pragatigpt': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const apiKey = process.env.PRAGATIGPT_API_KEY;
+      const baseURL = process.env.PRAGATIGPT_BASE_URL || 'https://api.pragatigpt.in/v1';
+      if (!apiKey) {
+        throw new Error(
+          'PRAGATIGPT_API_KEY is required.\n' +
+          'Get your key at: https://www.gignaati.com/pragatigpt\n' +
+          'Then run: npx gigaclaw set-agent-secret PRAGATIGPT_API_KEY'
+        );
+      }
+      return new ChatOpenAI({
+        modelName: modelName || 'pragatigpt-1',
+        maxTokens,
+        apiKey,
+        configuration: { baseURL },
+      });
+    }
+
+    // Ollama — run any model locally with zero cloud dependency
+    case 'ollama': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const baseURL = (process.env.OLLAMA_BASE_URL || 'http://localhost:11434') + '/v1';
+      return new ChatOpenAI({
+        modelName: modelName || 'llama3.2',
+        maxTokens,
+        apiKey: 'ollama',
+        configuration: { baseURL },
+      });
+    }
+
+    // Custom OpenAI-compatible endpoint (vLLM, LM Studio, Together AI, etc.)
+    case 'custom': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const apiKey = process.env.CUSTOM_API_KEY || 'not-needed';
+      const baseURL = process.env.OPENAI_BASE_URL;
+      if (!baseURL) {
+        throw new Error(
+          'OPENAI_BASE_URL is required for the custom provider.\n' +
+          'Examples:\n' +
+          '  http://localhost:11434/v1  (Ollama)\n' +
+          '  http://localhost:1234/v1   (LM Studio)\n' +
+          '  https://api.together.ai/v1 (Together AI)'
+        );
+      }
+      return new ChatOpenAI({ modelName, maxTokens, apiKey, configuration: { baseURL } });
+    }
+
+    default:
+      throw new Error(
+        `Unknown LLM provider: "${provider}"\n` +
+        'Supported: anthropic, openai, google, pragatigpt, ollama, custom\n' +
+        'Set LLM_PROVIDER in your .env file.'
+      );
+  }
+}
+
+/**
+ * Get a human-readable label for a provider.
+ * @param {string} provider
+ * @returns {string}
+ */
+export function getProviderLabel(provider) {
+  const labels = {
+    anthropic: 'Claude (Anthropic)',
+    openai: 'GPT (OpenAI)',
+    google: 'Gemini (Google)',
+    pragatigpt: 'PragatiGPT (Gignaati — India-first)',
+    ollama: 'Ollama (Local — Zero Cloud)',
+    custom: 'Custom OpenAI-Compatible API',
+  };
+  return labels[provider] || provider;
+}
+
+/**
+ * Validate that required env vars are set for a provider.
+ * @param {string} provider
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateProviderConfig(provider) {
+  const checks = {
+    anthropic: () => process.env.ANTHROPIC_API_KEY ? null : 'ANTHROPIC_API_KEY is not set',
+    openai: () => process.env.OPENAI_API_KEY ? null : 'OPENAI_API_KEY is not set',
+    google: () => process.env.GOOGLE_API_KEY ? null : 'GOOGLE_API_KEY is not set',
+    pragatigpt: () => process.env.PRAGATIGPT_API_KEY ? null : 'PRAGATIGPT_API_KEY is not set',
+    ollama: () => null,
+    custom: () => process.env.OPENAI_BASE_URL ? null : 'OPENAI_BASE_URL is not set',
+  };
+  const check = checks[provider];
+  if (!check) return { valid: false, error: `Unknown provider: ${provider}` };
+  const error = check();
+  return error ? { valid: false, error } : { valid: true };
+}