dr-claw 1.1.2

package/server/utils/zotero-client.js

@@ -0,0 +1,136 @@
+/**
+ * Zotero Client — interface for local Zotero desktop API.
+ *
+ * Local API:  http://localhost:23119/api  (Zotero desktop, no auth)
+ */
+
+const LOCAL_BASE = 'http://localhost:23119/api';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function fetchJson(url, options = {}) {
+  const res = await fetch(url, { ...options, signal: AbortSignal.timeout(15000) });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Zotero API ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+
+async function fetchBuffer(url, options = {}) {
+  const res = await fetch(url, { ...options, signal: AbortSignal.timeout(60000) });
+  if (!res.ok) {
+    throw new Error(`Zotero file fetch ${res.status}`);
+  }
+  const arrayBuffer = await res.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+
+function mapZoteroItem(raw) {
+  const d = raw.data || raw;
+  const creators = (d.creators || []).map((c) => ({
+    family: c.lastName || '',
+    given: c.firstName || '',
+  }));
+  return {
+    sourceId: d.key || raw.key,
+    title: d.title || 'Untitled',
+    authors: creators,
+    year: d.date ? parseInt(d.date.match(/\b(\d{4})\b/)?.[1], 10) || null : null,
+    abstract: d.abstractNote || null,
+    doi: d.DOI || null,
+    url: d.url || null,
+    journal: d.publicationTitle || d.journalAbbreviation || null,
+    itemType: d.itemType || 'article',
+    keywords: (d.tags || []).map((t) => t.tag),
+    citationKey: d.citationKey || d.extra?.match(/Citation Key:\s*(\S+)/i)?.[1] || null,
+    rawData: raw,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Local client  (Zotero Desktop — localhost:23119)
+// ---------------------------------------------------------------------------
+
+export class ZoteroLocalClient {
+  constructor() {
+    this.base = LOCAL_BASE;
+  }
+
+  /** Detailed status: { available, running, apiDisabled }. */
+  async checkStatus() {
+    try {
+      const res = await fetch(`${this.base}/users/0/items?limit=1`, { signal: AbortSignal.timeout(3000) });
+      if (res.ok) return { available: true, running: true, apiDisabled: false };
+      // 403 means Zotero is running but local API is disabled
+      return { available: false, running: true, apiDisabled: true };
+    } catch {
+      return { available: false, running: false, apiDisabled: false };
+    }
+  }
+
+  /** Returns true if the Zotero desktop app is reachable with API enabled. */
+  async isAvailable() {
+    const { available } = await this.checkStatus();
+    return available;
+  }
+
+  async getLibraries() {
+    // Local API only has the personal library (users/0).
+    return [{ id: 0, type: 'user', name: 'My Library' }];
+  }
+
+  async getCollections(libraryId = 0) {
+    const raw = await fetchJson(`${this.base}/users/${libraryId}/collections`);
+    return raw.map((c) => ({
+      key: c.data?.key || c.key,
+      name: c.data?.name || c.name || '',
+      parentKey: c.data?.parentCollection || null,
+    }));
+  }
+
+  async getItems(libraryId = 0, { collectionKey, query, limit = 50, start = 0 } = {}) {
+    const params = new URLSearchParams({ limit: String(limit), start: String(start), itemType: '-attachment' });
+    if (query) params.set('q', query);
+    const base = collectionKey
+      ? `${this.base}/users/${libraryId}/collections/${encodeURIComponent(collectionKey)}/items`
+      : `${this.base}/users/${libraryId}/items`;
+    const raw = await fetchJson(`${base}?${params}`);
+    return raw.map(mapZoteroItem);
+  }
+
+  async searchItems(libraryId = 0, query) {
+    return this.getItems(libraryId, { query });
+  }
+
+  async getItemPdf(libraryId = 0, itemKey) {
+    // Fetch children to find the PDF attachment.
+    const children = await fetchJson(`${this.base}/users/${libraryId}/items/${encodeURIComponent(itemKey)}/children`);
+    const pdfAttachment = children.find(
+      (c) => (c.data?.contentType || c.contentType) === 'application/pdf',
+    );
+    if (!pdfAttachment) return null;
+    const attachKey = pdfAttachment.data?.key || pdfAttachment.key;
+    return fetchBuffer(`${this.base}/users/${libraryId}/items/${attachKey}/file`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory: local-only
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns {client, mode} where mode is 'local' | null.
+ */
+export async function getZoteroClient() {
+  const local = new ZoteroLocalClient();
+  const localStatus = await local.checkStatus();
+
+  if (localStatus.available) {
+    return { client: local, mode: 'local', localRunning: true, localApiDisabled: false };
+  }
+
+  return { client: null, mode: null, localRunning: localStatus.running, localApiDisabled: localStatus.apiDisabled };
+}

package/shared/errorClassifier.js

@@ -0,0 +1,102 @@
+/**
+ * Shared error classification for all agent providers.
+ * Single source of truth for error type detection and retryability.
+ */
+
+export const ERROR_TYPES = /** @type {const} */ ({
+  USAGE_LIMIT: 'usage_limit',
+  OVERLOADED: 'overloaded',
+  NETWORK: 'network',
+  AUTH: 'auth',
+  UNKNOWN: 'unknown',
+});
+
+const RE_USAGE_LIMIT = /usage[_ ]limit|rate[_ ]limit|Too Many Requests|\b429\b|RESOURCE_EXHAUSTED|capacity exhausted|quota/i;
+const RE_OVERLOADED = /overloaded|MODEL_CAPACITY_EXHAUSTED|No capacity available|server[_ ]error/i;
+const RE_NETWORK = /network|ECONNREFUSED|ETIMEDOUT|ECONNRESET|ENOTFOUND|socket hang up/i;
+const RE_AUTH = /\bauth\b|unauthorized|forbidden|authentication[_ ]failed|billing[_ ]error|invalid[_ ]api[_ ]key/i;
+
+function makeResult(errorType) {
+  return { errorType, isRetryable: errorType !== ERROR_TYPES.AUTH };
+}
+
+/** @param {string} message */
+export function classifyError(message) {
+  const msg = String(message || '');
+
+  if (RE_USAGE_LIMIT.test(msg)) return makeResult(ERROR_TYPES.USAGE_LIMIT);
+  if (RE_OVERLOADED.test(msg)) return makeResult(ERROR_TYPES.OVERLOADED);
+  if (RE_NETWORK.test(msg)) return makeResult(ERROR_TYPES.NETWORK);
+  if (RE_AUTH.test(msg)) return makeResult(ERROR_TYPES.AUTH);
+
+  return makeResult(ERROR_TYPES.UNKNOWN);
+}
+
+export const TRANSIENT_ERROR_TYPES = /** @type {const} */ ([
+  ERROR_TYPES.NETWORK,
+  ERROR_TYPES.OVERLOADED,
+]);
+
+/**
+ * Per-provider SDK error code → ERROR_TYPES mappings.
+ *
+ * Claude (AssistantMessageError):
+ *   'authentication_failed' | 'billing_error' | 'rate_limit' |
+ *   'invalid_request' | 'server_error' | 'max_output_tokens' | 'unknown'
+ *
+ * Codex (ResponseError.code):
+ *   'server_error' | 'rate_limit_exceeded' | 'invalid_prompt' | ...
+ *
+ * Gemini (structured error codes from CLI stderr):
+ *   'RESOURCE_EXHAUSTED' | 'PERMISSION_DENIED' | 'INTERNAL' | ...
+ */
+const CLAUDE_ERROR_MAP = {
+  rate_limit: ERROR_TYPES.USAGE_LIMIT,
+  authentication_failed: ERROR_TYPES.AUTH,
+  billing_error: ERROR_TYPES.AUTH,
+  server_error: ERROR_TYPES.OVERLOADED,
+  invalid_request: ERROR_TYPES.UNKNOWN,
+  max_output_tokens: ERROR_TYPES.UNKNOWN,
+  unknown: ERROR_TYPES.UNKNOWN,
+};
+
+const CODEX_ERROR_MAP = {
+  rate_limit_exceeded: ERROR_TYPES.USAGE_LIMIT,
+  server_error: ERROR_TYPES.OVERLOADED,
+  invalid_prompt: ERROR_TYPES.UNKNOWN,
+};
+
+const GEMINI_ERROR_MAP = {
+  RESOURCE_EXHAUSTED: ERROR_TYPES.USAGE_LIMIT,
+  PERMISSION_DENIED: ERROR_TYPES.AUTH,
+  UNAUTHENTICATED: ERROR_TYPES.AUTH,
+  INTERNAL: ERROR_TYPES.OVERLOADED,
+  UNAVAILABLE: ERROR_TYPES.OVERLOADED,
+};
+
+const PROVIDER_ERROR_MAPS = {
+  claude: CLAUDE_ERROR_MAP,
+  codex: CODEX_ERROR_MAP,
+  gemini: GEMINI_ERROR_MAP,
+};
+
+/**
+ * Classify from a provider SDK structured error code.
+ * @param {string} sdkErrorCode - e.g. 'rate_limit', 'rate_limit_exceeded', 'RESOURCE_EXHAUSTED'
+ * @param {'claude' | 'codex' | 'gemini'} [provider] - provider name for precise mapping; omit to search all
+ * @returns {{ errorType: string, isRetryable: boolean }}
+ */
+export function classifySDKError(sdkErrorCode, provider) {
+  let errorType;
+
+  if (provider && PROVIDER_ERROR_MAPS[provider]) {
+    errorType = PROVIDER_ERROR_MAPS[provider][sdkErrorCode];
+  } else {
+    for (const map of Object.values(PROVIDER_ERROR_MAPS)) {
+      errorType = map[sdkErrorCode];
+      if (errorType) break;
+    }
+  }
+
+  return makeResult(errorType || ERROR_TYPES.UNKNOWN);
+}

package/shared/geminiThinkingSupport.d.ts

@@ -0,0 +1,22 @@
+export type GeminiThinkingModeId =
+  | 'default'
+  | 'minimal'
+  | 'low'
+  | 'medium'
+  | 'high'
+  | 'dynamic'
+  | 'off'
+  | 'light'
+  | 'balanced'
+  | 'deep'
+  | 'max';
+
+export type GeminiThinkingFamily = 'gemini-3' | 'gemini-2.5' | null;
+
+export function getGeminiThinkingFamily(model: string): GeminiThinkingFamily;
+export function getSupportedGeminiThinkingModes(model: string): GeminiThinkingModeId[];
+export function supportsExplicitGeminiThinkingMode(model: string): boolean;
+export function buildGeminiThinkingConfig(
+  model: string,
+  mode?: GeminiThinkingModeId | null,
+): { thinkingLevel?: 'MINIMAL' | 'LOW' | 'MEDIUM' | 'HIGH'; thinkingBudget?: number } | null;

package/shared/geminiThinkingSupport.js

@@ -0,0 +1,96 @@
+export const GEMINI_THINKING_MODE_IDS = [
+  'default',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'dynamic',
+  'off',
+  'light',
+  'balanced',
+  'deep',
+  'max',
+];
+
+function isGemini3Model(model) {
+  return typeof model === 'string' && model.startsWith('gemini-3');
+}
+
+function isGemini25Model(model) {
+  return typeof model === 'string' && model.startsWith('gemini-2.5');
+}
+
+export function getGeminiThinkingFamily(model) {
+  if (isGemini3Model(model)) return 'gemini-3';
+  if (isGemini25Model(model)) return 'gemini-2.5';
+  return null;
+}
+
+export function getSupportedGeminiThinkingModes(model) {
+  switch (model) {
+    case 'gemini-3.1-pro-preview':
+      return ['default', 'low', 'medium', 'high'];
+    case 'gemini-3.1-flash-lite-preview':
+    case 'gemini-3-flash-preview':
+      return ['default', 'minimal', 'low', 'medium', 'high'];
+    case 'gemini-2.5-pro':
+      return ['default', 'dynamic', 'light', 'balanced', 'deep', 'max'];
+    case 'gemini-2.5-flash':
+    case 'gemini-2.5-flash-lite':
+      return ['default', 'dynamic', 'off', 'light', 'balanced', 'deep'];
+    default:
+      return ['default'];
+  }
+}
+
+export function supportsExplicitGeminiThinkingMode(model) {
+  return getSupportedGeminiThinkingModes(model).length > 1;
+}
+
+export function buildGeminiThinkingConfig(model, mode) {
+  if (!model || !mode || mode === 'default') {
+    return null;
+  }
+
+  if (isGemini3Model(model)) {
+    const levelMap = {
+      minimal: 'MINIMAL',
+      low: 'LOW',
+      medium: 'MEDIUM',
+      high: 'HIGH',
+    };
+    const thinkingLevel = levelMap[mode];
+    return thinkingLevel ? { thinkingLevel } : null;
+  }
+
+  if (isGemini25Model(model)) {
+    const budgetMapByModel = {
+      'gemini-2.5-pro': {
+        dynamic: -1,
+        light: 1024,
+        balanced: 8192,
+        deep: 24576,
+        max: 32768,
+      },
+      'gemini-2.5-flash': {
+        dynamic: -1,
+        off: 0,
+        light: 1024,
+        balanced: 8192,
+        deep: 24576,
+      },
+      'gemini-2.5-flash-lite': {
+        dynamic: -1,
+        off: 0,
+        light: 512,
+        balanced: 8192,
+        deep: 24576,
+      },
+    };
+
+    const budget = budgetMapByModel[model]?.[mode];
+    return Number.isInteger(budget) ? { thinkingBudget: budget } : null;
+  }
+
+  return null;
+}

package/shared/geminiThoughtParser.d.ts

@@ -0,0 +1,8 @@
+export type LegacyGeminiThoughtSegment = {
+  content: string;
+  isThinking: boolean;
+};
+
+export function splitLegacyGeminiThoughtContent(
+  text: string,
+): LegacyGeminiThoughtSegment[] | null;

package/shared/geminiThoughtParser.js

@@ -0,0 +1,30 @@
+/**
+ * Splits Gemini legacy "[Thought: true]" markers in assistant text
+ * into structured segments with thinking/final flags.
+ *
+ * Shared between server (gemini-cli.js) and client (chatFormatting.ts)
+ * to ensure consistent parsing behavior.
+ *
+ * @param {string} text - The assistant message text to parse.
+ * @returns {{ content: string, isThinking: boolean }[] | null}
+ *   Array of segments if markers are found, null otherwise.
+ */
+export function splitLegacyGeminiThoughtContent(text) {
+  if (!text || typeof text !== 'string' || !/\[Thought:\s*true\]/i.test(text)) {
+    return null;
+  }
+
+  const segments = text
+    .split(/\n?\s*\[Thought:\s*true\]\s*/i)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  if (segments.length < 2) {
+    return null;
+  }
+
+  return segments.map((segment, index) => ({
+    content: segment,
+    isThinking: index < segments.length - 1,
+  }));
+}

package/shared/modelConstants.js

@@ -0,0 +1,139 @@
+/**
+ * Centralized Model Definitions
+ * Single source of truth for all supported AI models
+ */
+
+/**
+ * Claude (Anthropic) Models
+ *
+ * Note: Claude uses two different formats:
+ * - SDK format ('sonnet', 'opus') - used by the UI and claude-sdk.js
+ * - API format ('claude-sonnet-4.5') - used by slash commands for display
+ */
+export const CLAUDE_MODELS = {
+  // Models in SDK format (what the actual SDK accepts)
+  OPTIONS: [
+    { value: 'sonnet', label: 'Sonnet' },
+    { value: 'opus', label: 'Opus' },
+    { value: 'haiku', label: 'Haiku' },
+    { value: 'opusplan', label: 'Opus (Plan Mode Only)' },
+    { value: 'sonnet[1m]', label: 'Sonnet [1M]' },
+    { value: 'claude-opus-4-6', label: 'Opus 4.6' }
+  ],
+
+  DEFAULT: (typeof process !== 'undefined' && process.env?.ANTHROPIC_MODEL) || 'claude-opus-4-6'
+};
+
+/**
+ * Cursor Models
+ */
+export const CURSOR_MODELS = {
+  OPTIONS: [
+    { value: 'gpt-5.2-high', label: 'GPT-5.2 High' },
+    { value: 'gemini-3-pro', label: 'Gemini 3 Pro' },
+    { value: 'opus-4.5-thinking', label: 'Claude 4.5 Opus (Thinking)' },
+    { value: 'gpt-5.2', label: 'GPT-5.2' },
+    { value: 'gpt-5.1', label: 'GPT-5.1' },
+    { value: 'gpt-5.1-high', label: 'GPT-5.1 High' },
+    { value: 'composer-1', label: 'Composer 1' },
+    { value: 'auto', label: 'Auto' },
+    { value: 'sonnet-4.5', label: 'Claude 4.5 Sonnet' },
+    { value: 'sonnet-4.5-thinking', label: 'Claude 4.5 Sonnet (Thinking)' },
+    { value: 'opus-4.5', label: 'Claude 4.5 Opus' },
+    { value: 'gpt-5.1-codex', label: 'GPT-5.1 Codex' },
+    { value: 'gpt-5.1-codex-high', label: 'GPT-5.1 Codex High' },
+    { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max' },
+    { value: 'gpt-5.1-codex-max-high', label: 'GPT-5.1 Codex Max High' },
+    { value: 'opus-4.1', label: 'Claude 4.1 Opus' },
+    { value: 'grok', label: 'Grok' }
+  ],
+
+  DEFAULT: 'gpt-5'
+};
+
+/**
+ * Codex (OpenAI) Models
+ */
+export const CODEX_MODELS = {
+  OPTIONS: [
+    { value: 'gpt-5.4', label: 'GPT-5.4' },
+    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+    { value: 'gpt-5.2-codex', label: 'GPT-5.2 Codex' },
+    { value: 'gpt-5.2', label: 'GPT-5.2' },
+    { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max' },
+    { value: 'o3', label: 'O3' },
+    { value: 'o4-mini', label: 'O4-mini' }
+  ],
+
+  DEFAULT: 'gpt-5.4'
+};
+
+/**
+ * OpenRouter Models
+ * Users can also type any model slug from https://openrouter.ai/models
+ */
+export const OPENROUTER_MODELS = {
+  OPTIONS: [
+    // Anthropic
+    { value: 'anthropic/claude-sonnet-4', label: 'Claude Sonnet 4 (Anthropic)' },
+    { value: 'anthropic/claude-opus-4', label: 'Claude Opus 4 (Anthropic)' },
+    { value: 'anthropic/claude-haiku-3.5', label: 'Claude 3.5 Haiku (Anthropic)' },
+    // OpenAI
+    { value: 'openai/gpt-5', label: 'GPT-5 (OpenAI)' },
+    { value: 'openai/gpt-4.1', label: 'GPT-4.1 (OpenAI)' },
+    { value: 'openai/gpt-4.1-mini', label: 'GPT-4.1 Mini (OpenAI)' },
+    { value: 'openai/o3', label: 'O3 (OpenAI)' },
+    { value: 'openai/o4-mini', label: 'O4 Mini (OpenAI)' },
+    // Google
+    { value: 'google/gemini-2.5-pro', label: 'Gemini 2.5 Pro (Google)' },
+    { value: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash (Google)' },
+    // DeepSeek
+    { value: 'deepseek/deepseek-r1', label: 'DeepSeek R1' },
+    { value: 'deepseek/deepseek-chat-v3-0324', label: 'DeepSeek V3 0324' },
+    // Meta
+    { value: 'meta-llama/llama-4-maverick', label: 'Llama 4 Maverick (Meta)' },
+    { value: 'meta-llama/llama-4-scout', label: 'Llama 4 Scout (Meta)' },
+    // Mistral
+    { value: 'mistralai/mistral-large', label: 'Mistral Large' },
+    { value: 'mistralai/codestral', label: 'Codestral (Mistral)' },
+    // Qwen
+    { value: 'qwen/qwen3-235b-a22b', label: 'Qwen3 235B' },
+    { value: 'qwen/qwen3-32b', label: 'Qwen3 32B' },
+    // xAI
+    { value: 'x-ai/grok-3', label: 'Grok 3 (xAI)' },
+    { value: 'x-ai/grok-3-mini', label: 'Grok 3 Mini (xAI)' },
+    // Cohere
+    { value: 'cohere/command-a', label: 'Command A (Cohere)' },
+  ],
+
+  ALLOWS_CUSTOM: true,
+
+  DEFAULT: (typeof process !== 'undefined' && process.env?.OPENROUTER_MODEL) || 'anthropic/claude-sonnet-4'
+};
+
+/**
+ * Local GPU Models (open-source models for self-hosted deployment)
+ */
+export const LOCAL_MODELS = {
+  OPTIONS: [],
+
+  IS_LOCAL: true,
+
+  DEFAULT: ''
+};
+
+/**
+ * Gemini (Google) Models
+ */
+export const GEMINI_MODELS = {
+  OPTIONS: [
+    { value: 'gemini-3.1-pro-preview', label: 'Gemini 3.1 Pro Preview' },
+    { value: 'gemini-3.1-flash-lite-preview', label: 'Gemini 3.1 Flash Lite Preview' },
+    { value: 'gemini-3-flash-preview', label: 'Gemini 3 Flash Preview' },
+    { value: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
+    { value: 'gemini-2.5-flash-lite', label: 'Gemini 2.5 Flash Lite' }
+  ],
+
+  DEFAULT: 'gemini-3-flash-preview'
+};