algochat-ai 1.0.0

package/src/client.js

@@ -0,0 +1,380 @@
+'use strict';
+
+/**
+ * AlgoChatClient — core HTTP client for algochat.app
+ *
+ * Handles:
+ *  1. GET  /api/csrf           → csrf_token cookie
+ *  2. POST /api/session        → zola_sid (anonymous userId)
+ *  3. POST /api/create-chat    → chatId
+ *  4. POST /api/files          → (optional) image upload
+ *  5. POST /api/chat           → SSE stream  ← the actual AI response
+ *
+ * Sessions are cached for 25 minutes and refreshed automatically on 401/403.
+ */
+
+const axios = require('axios');
+const FormData = require('form-data');
+const { v4: uuidv4 } = require('uuid');
+
+const ALGOCHAT_BASE = 'https://algochat.app';
+const SESSION_TTL_MS = 25 * 60 * 1000; // 25 minutes
+
+const UA =
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function parseCookies(setCookieHeaders = []) {
+  const cookies = {};
+  for (const cookie of setCookieHeaders) {
+    const [nameValue] = cookie.split(';');
+    const idx = nameValue.indexOf('=');
+    if (idx === -1) continue;
+    cookies[nameValue.slice(0, idx).trim()] = nameValue.slice(idx + 1).trim();
+  }
+  return cookies;
+}
+
+function buildCookieHeader(cookies) {
+  return Object.entries(cookies)
+    .map(([k, v]) => `${k}=${v}`)
+    .join('; ');
+}
+
+function randomId(length = 16) {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+}
+
+function buildDefaultSystemPrompt() {
+  const date = new Date().toLocaleDateString('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  });
+  return `Date: ${date}\n\nYou are a helpful AI assistant. Respond clearly and concisely. Use markdown formatting when appropriate.`;
+}
+
+// ─── Session management ───────────────────────────────────────────────────────
+
+class AlgoChatClient {
+  constructor(options = {}) {
+    this._sessionCache = null;
+    this._sessionFetchedAt = 0;
+    this._debug = options.debug === true;
+    this._timeout = options.timeout || 90000;
+  }
+
+  _log(...args) {
+    if (this._debug) console.log('[AlgoChat]', ...args);
+  }
+
+  _warn(...args) {
+    if (this._debug) console.warn('[AlgoChat]', ...args);
+  }
+
+  async _fetchSession() {
+    this._log('Initializing session...');
+    const cookies = {};
+
+    // Step 1: CSRF token
+    const csrfRes = await axios.get(`${ALGOCHAT_BASE}/api/csrf`, {
+      headers: { 'User-Agent': UA, Accept: 'application/json, */*', Referer: ALGOCHAT_BASE },
+    });
+    Object.assign(cookies, parseCookies(csrfRes.headers['set-cookie']));
+    this._log('Got csrf_token:', !!cookies['csrf_token']);
+
+    // Step 2: Anonymous session (zola_sid)
+    const sessionRes = await axios.post(
+      `${ALGOCHAT_BASE}/api/session`,
+      {},
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'User-Agent': UA,
+          Cookie: buildCookieHeader(cookies),
+          Origin: ALGOCHAT_BASE,
+          Referer: ALGOCHAT_BASE,
+        },
+      }
+    );
+    Object.assign(cookies, parseCookies(sessionRes.headers['set-cookie']));
+    this._log('Got zola_sid:', cookies['zola_sid'] ? 'yes' : 'no');
+
+    return cookies;
+  }
+
+  async _getSession() {
+    const now = Date.now();
+    if (!this._sessionCache || now - this._sessionFetchedAt > SESSION_TTL_MS) {
+      this._sessionCache = await this._fetchSession();
+      this._sessionFetchedAt = now;
+    }
+    return this._sessionCache;
+  }
+
+  _invalidateSession() {
+    this._sessionCache = null;
+    this._sessionFetchedAt = 0;
+  }
+
+  async _createChat(cookies, model) {
+    const res = await axios.post(
+      `${ALGOCHAT_BASE}/api/create-chat`,
+      { title: 'New Chat', model: model || 'gemini-3-flash-preview' },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'User-Agent': UA,
+          Cookie: buildCookieHeader(cookies),
+          Origin: ALGOCHAT_BASE,
+          Referer: ALGOCHAT_BASE,
+        },
+      }
+    );
+    const chatId = res.data?.chat?.id || res.data?.id;
+    if (!chatId) throw new Error('create-chat did not return a chatId');
+    this._log('Created chatId:', chatId);
+    return chatId;
+  }
+
+  /**
+   * Upload an image to AlgoChat /api/files.
+   * @param {string} imageSource - base64 data URI or https URL
+   * @param {object} cookies - session cookies
+   * @param {string} [filename]
+   * @returns {Promise<{url: string, filename: string, mediaType: string}>}
+   */
+  async uploadImage(imageSource, cookies, filename = 'image.jpg') {
+    let imageBuffer;
+    let mediaType = 'image/jpeg';
+
+    if (imageSource.startsWith('data:')) {
+      const match = imageSource.match(/^data:([^;]+);base64,(.+)$/);
+      if (!match) throw new Error('Invalid base64 data URI format');
+      mediaType = match[1];
+      imageBuffer = Buffer.from(match[2], 'base64');
+      const ext = mediaType.split('/')[1]?.replace('jpeg', 'jpg') || 'jpg';
+      if (!filename || filename === 'image.jpg') filename = `image.${ext}`;
+    } else if (imageSource.startsWith('http://') || imageSource.startsWith('https://')) {
+      const imgRes = await axios.get(imageSource, { responseType: 'arraybuffer', timeout: 30000 });
+      imageBuffer = Buffer.from(imgRes.data);
+      mediaType = imgRes.headers['content-type']?.split(';')[0] || 'image/jpeg';
+      const urlFilename = imageSource.split('/').pop()?.split('?')[0];
+      if (urlFilename && urlFilename.includes('.')) filename = urlFilename;
+    } else {
+      throw new Error('Image source must be a base64 data URI or an https URL');
+    }
+
+    const form = new FormData();
+    form.append('file', imageBuffer, { filename, contentType: mediaType });
+
+    this._log(`Uploading image: ${filename} (${mediaType}, ${imageBuffer.length} bytes)`);
+
+    const res = await axios.post(`${ALGOCHAT_BASE}/api/files`, form, {
+      headers: {
+        ...form.getHeaders(),
+        'User-Agent': UA,
+        Cookie: buildCookieHeader(cookies),
+        Origin: ALGOCHAT_BASE,
+        Referer: ALGOCHAT_BASE,
+      },
+      timeout: 60000,
+    });
+
+    const fileId = res.data?.id || res.data?.fileId || res.data?.file?.id;
+    if (!fileId) throw new Error(`Image upload failed – unexpected response: ${JSON.stringify(res.data)}`);
+
+    const fileUrl = `/api/files/${fileId}`;
+    this._log(`Image uploaded → ${fileUrl}`);
+    return { url: fileUrl, filename, mediaType };
+  }
+
+  async _contentToParts(content, cookies) {
+    if (typeof content === 'string') return [{ type: 'text', text: content }];
+    if (!Array.isArray(content)) return [{ type: 'text', text: String(content) }];
+
+    const parts = [];
+    for (const item of content) {
+      if (item.type === 'text') {
+        parts.push({ type: 'text', text: item.text || '' });
+      } else if (item.type === 'image_url') {
+        const imageUrl = item.image_url?.url || item.image_url;
+        if (!imageUrl) continue;
+
+        // Strategy 1: Try /api/files upload
+        try {
+          const uploaded = await this.uploadImage(imageUrl, cookies);
+          parts.push({ type: 'file', url: uploaded.url, filename: uploaded.filename, mediaType: uploaded.mediaType });
+          continue;
+        } catch (uploadErr) {
+          const status = uploadErr.response?.status;
+          const isAuthErr = status === 401 || status === 403;
+          if (!isAuthErr) {
+            this._warn('Image upload failed:', uploadErr.message);
+            parts.push({ type: 'text', text: '[Image could not be processed]' });
+            continue;
+          }
+          this._warn('/api/files upload denied. Using direct URL fallback.');
+        }
+
+        // Strategy 2: Pass URL/base64 directly
+        if (imageUrl.startsWith('data:')) {
+          const match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+          if (match) {
+            parts.push({
+              type: 'file',
+              url: imageUrl,
+              mediaType: match[1],
+              filename: `image.${match[1].split('/')[1]?.replace('jpeg', 'jpg') || 'jpg'}`,
+            });
+          } else {
+            parts.push({ type: 'text', text: '[Invalid base64 image]' });
+          }
+        } else {
+          const urlFilename = imageUrl.split('/').pop()?.split('?')[0] || 'image.jpg';
+          const guessedMediaType = urlFilename.endsWith('.png') ? 'image/png'
+            : urlFilename.endsWith('.webp') ? 'image/webp'
+            : urlFilename.endsWith('.gif') ? 'image/gif'
+            : 'image/jpeg';
+          parts.push({ type: 'file', url: imageUrl, filename: urlFilename, mediaType: guessedMediaType });
+        }
+      }
+    }
+    return parts.length > 0 ? parts : [{ type: 'text', text: '' }];
+  }
+
+  async _convertMessages(messages, cookies) {
+    const results = [];
+    for (const msg of messages) {
+      const parts = await this._contentToParts(msg.content, cookies);
+      results.push({
+        id: randomId(8),
+        role: msg.role === 'assistant' ? 'assistant' : 'user',
+        parts,
+      });
+    }
+    return results;
+  }
+
+  /**
+   * Create a chat and return the raw SSE stream.
+   *
+   * @param {object} params
+   * @param {string} [params.model]
+   * @param {Array}  params.messages  - Array of {role, content} objects
+   * @param {string} [params.systemPrompt]
+   * @returns {Promise<{stream: import('stream').Readable, chatId: string}>}
+   */
+  async createChatStream({ model, messages, systemPrompt }) {
+    const resolvedModel = model || 'gemini-3-flash-preview';
+    let session = await this._getSession();
+
+    let chatId;
+    try {
+      chatId = await this._createChat(session, resolvedModel);
+    } catch (err) {
+      if (err.response?.status === 401 || err.response?.status === 403) {
+        this._invalidateSession();
+        session = await this._getSession();
+        chatId = await this._createChat(session, resolvedModel);
+      } else {
+        throw err;
+      }
+    }
+
+    const convertedMessages = await this._convertMessages(messages, session);
+
+    const requestBody = {
+      chatId,
+      userId: session['zola_sid'],
+      model: resolvedModel,
+      isAuthenticated: false,
+      systemPrompt: systemPrompt || buildDefaultSystemPrompt(),
+      enableSearch: false,
+      id: randomId(16),
+      messages: convertedMessages,
+      trigger: 'submit-message',
+    };
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'User-Agent': UA,
+      Cookie: buildCookieHeader(session),
+      Origin: ALGOCHAT_BASE,
+      Referer: `${ALGOCHAT_BASE}/c/${chatId}`,
+      'x-vercel-ai-ui-message-stream': 'v1',
+      Accept: 'text/event-stream',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Cache-Control': 'no-cache',
+    };
+
+    this._log(`POST /api/chat | model=${resolvedModel} | chatId=${chatId}`);
+
+    let response;
+    try {
+      response = await axios.post(`${ALGOCHAT_BASE}/api/chat`, requestBody, {
+        headers,
+        responseType: 'stream',
+        timeout: this._timeout,
+      });
+    } catch (err) {
+      const status = err.response?.status;
+      if (status === 401 || status === 403) {
+        this._invalidateSession();
+        session = await this._getSession();
+        chatId = await this._createChat(session, resolvedModel);
+        requestBody.chatId = chatId;
+        requestBody.userId = session['zola_sid'];
+        headers.Cookie = buildCookieHeader(session);
+        headers.Referer = `${ALGOCHAT_BASE}/c/${chatId}`;
+        response = await axios.post(`${ALGOCHAT_BASE}/api/chat`, requestBody, {
+          headers,
+          responseType: 'stream',
+          timeout: this._timeout,
+        });
+      } else {
+        throw err;
+      }
+    }
+
+    return { stream: response.data, chatId };
+  }
+
+  /**
+   * Collect the full SSE stream into a plain text string.
+   * @param {import('stream').Readable} stream
+   * @returns {Promise<string>}
+   */
+  async streamToText(stream) {
+    return new Promise((resolve, reject) => {
+      let fullText = '';
+      let buffer = '';
+
+      stream.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith('data:')) continue;
+          const jsonStr = trimmed.slice(5).trim();
+          if (!jsonStr || jsonStr === '[DONE]') continue;
+          try {
+            const parsed = JSON.parse(jsonStr);
+            if (parsed.type === 'text-delta' && parsed.delta) fullText += parsed.delta;
+          } catch {
+            // skip malformed chunks
+          }
+        }
+      });
+
+      stream.on('end', () => resolve(fullText));
+      stream.on('error', reject);
+    });
+  }
+}
+
+module.exports = AlgoChatClient;

package/src/index.d.ts

@@ -0,0 +1,144 @@
+// Type definitions for algochat-ai
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface ChatOptions {
+  /** AlgoChat model ID or OpenAI alias. Default: 'gemini-3-flash-preview' */
+  model?: string;
+  /** Override the system prompt. */
+  systemPrompt?: string;
+  /** Enable verbose debug logging. Default: false */
+  debug?: boolean;
+  /** Request timeout in milliseconds. Default: 90000 */
+  timeout?: number;
+}
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system';
+  content: string | ContentPart[];
+}
+
+export interface ContentPart {
+  type: 'text' | 'image_url';
+  text?: string;
+  image_url?: { url: string };
+}
+
+export interface ChatCompletion {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: { role: string; content: string };
+    finish_reason: string;
+    logprobs: null;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+  system_fingerprint: null;
+}
+
+export interface ModelInfo {
+  id: string;
+  object: 'model';
+  created: number;
+  owned_by: string;
+  permission: any[];
+  root: string;
+  parent: null;
+  requiresAuth: boolean;
+}
+
+export interface UploadedFile {
+  url: string;
+  filename: string;
+  mediaType: string;
+}
+
+export interface AlgoChatClientOptions {
+  /** Enable verbose debug logging. Default: false */
+  debug?: boolean;
+  /** Request timeout in milliseconds. Default: 90000 */
+  timeout?: number;
+}
+
+export interface CreateChatStreamParams {
+  model?: string;
+  messages: Message[];
+  systemPrompt?: string;
+}
+
+export interface CreateChatStreamResult {
+  stream: NodeJS.ReadableStream;
+  chatId: string;
+}
+
+export declare class AlgoChatClient {
+  constructor(options?: AlgoChatClientOptions);
+
+  createChatStream(params: CreateChatStreamParams): Promise<CreateChatStreamResult>;
+  streamToText(stream: NodeJS.ReadableStream): Promise<string>;
+  uploadImage(imageSource: string, cookies: Record<string, string>, filename?: string): Promise<UploadedFile>;
+}
+
+/**
+ * Send a message and get the full AI response as a string.
+ *
+ * @param input - A string message or an OpenAI-style messages array
+ * @param options - Optional configuration
+ */
+export declare function chat(input: string | Message[], options?: ChatOptions): Promise<string>;
+
+/**
+ * Stream the AI response chunk by chunk.
+ * Calls onChunk(delta) for every piece of text received.
+ * Returns the full accumulated response when the stream ends.
+ *
+ * @param input   - A string message or an OpenAI-style messages array
+ * @param onChunk - Callback invoked with each text delta
+ * @param options - Optional configuration
+ */
+export declare function chatStream(
+  input: string | Message[],
+  onChunk: (chunk: string) => void,
+  options?: ChatOptions
+): Promise<string>;
+
+/**
+ * Send a message together with an image (multimodal).
+ *
+ * @param text     - The text question about the image
+ * @param imageUrl - An https:// URL or a base64 data URI (data:image/...)
+ * @param options  - Optional configuration
+ */
+export declare function chatWithImage(text: string, imageUrl: string, options?: ChatOptions): Promise<string>;
+
+/**
+ * Get a full OpenAI-compatible chat completion object (non-streaming).
+ *
+ * @param messages - OpenAI-style messages array
+ * @param options  - Optional configuration
+ */
+export declare function createCompletion(messages: Message[], options?: ChatOptions): Promise<ChatCompletion>;
+
+/** Resolve a model name (OpenAI alias or native) to an AlgoChat model ID. */
+export declare function resolveModel(requestedModel: string): string;
+
+/** Return all supported models in OpenAI /v1/models format. */
+export declare function getModelList(): ModelInfo[];
+
+/** All supported AlgoChat models with metadata. */
+export declare const ALGOCHAT_MODELS: Record<string, {
+  id: string;
+  displayName: string;
+  contextWindow: number;
+  maxOutputTokens: number;
+  requiresAuth: boolean;
+}>;
+
+/** Default model ID used when none is specified. */
+export declare const DEFAULT_MODEL: string;