backend-manager 5.0.203 → 5.1.0

package/src/manager/libraries/ai/index.js

@@ -0,0 +1,162 @@
+/**
+ * Unified AI library — provider-agnostic surface for OpenAI, Anthropic, etc.
+ *
+ * Usage:
+ *   const ai = Manager.AI(assistant);
+ *   const result = await ai.request({ provider: 'openai', model: 'gpt-5-mini', ... });
+ *   const result = await ai.request({ provider: 'anthropic', model: 'claude-sonnet-4-6', ... });
+ *
+ * Each provider returns { content, output, tokens, raw } with a consistent shape.
+ *
+ * Default provider: openai (preserves backward compatibility with the old openai.js surface).
+ */
+const OpenAI = require('./providers/openai.js');
+const Anthropic = require('./providers/anthropic.js');
+const ClaudeCode = require('./providers/claude-code.js');
+
+const DEFAULT_PROVIDER = 'openai';
+
+function AI(assistant, key) {
+  const self = this;
+
+  self.assistant = assistant;
+  self.Manager = assistant?.Manager;
+
+  // Lazily instantiate providers — only the ones actually used pay the cost
+  self._providers = {};
+  self._defaultKey = key;
+
+  // Combined token counter across all provider calls in this AI instance
+  self.tokens = {
+    total:  { count: 0, price: 0 },
+    input:  { count: 0, price: 0 },
+    output: { count: 0, price: 0 },
+  };
+
+  return self;
+}
+
+/**
+ * Make an AI request. Dispatches to the configured provider.
+ *
+ * @param {object} options
+ * @param {'openai'|'anthropic'} [options.provider='openai']
+ * @param {string} [options.model]
+ * @param {string} [options.apiKey] - override provider-specific key
+ * @param {Array<{role,content}>} [options.messages]
+ * @param {object} [options.prompt] - { content: 'system prompt' }
+ * @param {object} [options.message] - { content: 'user message' }
+ * @param {'json'|'text'} [options.response]
+ * @param {object} [options.schema] - JSON schema for structured output
+ * @param {number} [options.maxTokens]
+ * @param {number} [options.temperature]
+ * @returns {Promise<{content, output, tokens, raw}>}
+ */
+AI.prototype.request = async function (options) {
+  const self = this;
+  const provider = (options || {}).provider || DEFAULT_PROVIDER;
+
+  // Normalize unified options shape into what each provider expects.
+  // Callers can pass either `messages: [{ role, content }]` (standard SDK style)
+  // or BEM's legacy `prompt.content` / `message.content`.
+  const normalized = normalizeOptions(options || {});
+
+  const client = self._getProvider(provider, normalized.apiKey);
+  const result = await client.request(normalized);
+
+  // Roll provider's token counts into the combined counter (best-effort — different
+  // providers report tokens slightly differently)
+  if (result?.tokens?.input?.count) {
+    self.tokens.input.count  += result.tokens.input.count  - (self._lastTokens?.[provider]?.input  || 0);
+    self.tokens.output.count += result.tokens.output.count - (self._lastTokens?.[provider]?.output || 0);
+    self.tokens.input.price  += result.tokens.input.price  - (self._lastTokens?.[provider]?.inputPrice  || 0);
+    self.tokens.output.price += result.tokens.output.price - (self._lastTokens?.[provider]?.outputPrice || 0);
+    self.tokens.total.count   = self.tokens.input.count + self.tokens.output.count;
+    self.tokens.total.price   = self.tokens.input.price + self.tokens.output.price;
+
+    self._lastTokens = self._lastTokens || {};
+    self._lastTokens[provider] = {
+      input:       result.tokens.input.count,
+      output:      result.tokens.output.count,
+      inputPrice:  result.tokens.input.price,
+      outputPrice: result.tokens.output.price,
+    };
+  }
+
+  return result;
+};
+
+AI.prototype._getProvider = function (provider, apiKey) {
+  const self = this;
+
+  if (!self._providers[provider]) {
+    const Provider = PROVIDERS[provider];
+
+    if (!Provider) {
+      throw new Error(`Unknown AI provider: ${provider}. Supported: ${Object.keys(PROVIDERS).join(', ')}`);
+    }
+
+    self._providers[provider] = new Provider(self.assistant, apiKey || self._defaultKey);
+  }
+
+  return self._providers[provider];
+};
+
+/**
+ * Translate a unified options object into the shape each provider expects.
+ *
+ * Accepts:
+ *   - messages: [{ role: 'system'|'user'|'assistant', content: string }]
+ *   - OR prompt.content (system) + message.content (user)
+ *
+ * Returns options with BOTH styles populated, so OpenAI's `prompt`/`message`
+ * fields and Anthropic's `messages` array both work.
+ */
+function normalizeOptions(opts) {
+  const out = { ...opts };
+
+  if (Array.isArray(opts.messages) && opts.messages.length) {
+    const system = opts.messages.find((m) => m.role === 'system');
+    const userTurns = opts.messages.filter((m) => m.role !== 'system');
+    const lastUser = userTurns[userTurns.length - 1];
+
+    if (system && !out.prompt?.content) {
+      out.prompt = { ...(out.prompt || {}), content: stringifyContent(system.content) };
+    }
+
+    if (lastUser && !out.message?.content) {
+      out.message = { ...(out.message || {}), content: stringifyContent(lastUser.content) };
+    }
+  }
+
+  return out;
+}
+
+function stringifyContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .filter((c) => c.type === 'input_text' || c.type === 'text')
+      .map((c) => c.text || '')
+      .join('\n');
+  }
+
+  return String(content || '');
+}
+
+const PROVIDERS = {
+  openai: OpenAI,
+  anthropic: Anthropic,
+  'claude-code': ClaudeCode,
+};
+
+// Expose the underlying provider classes for advanced callers
+AI.providers = PROVIDERS;
+AI.OpenAI = OpenAI;
+AI.Anthropic = Anthropic;
+AI.ClaudeCode = ClaudeCode;
+
+module.exports = AI;

package/src/manager/libraries/ai/providers/anthropic.js

@@ -0,0 +1,193 @@
+/**
+ * Anthropic provider for the unified AI library.
+ *
+ * Public surface matches the OpenAI provider:
+ *   new Anthropic(assistant, key).request(options) → { content, output, tokens, raw }
+ *
+ * Maps the Claude Messages API onto the OpenAI provider's option shape so callers
+ * can swap providers without rewriting call sites.
+ */
+const _ = require('lodash');
+const JSON5 = require('json5');
+
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+
+// Pricing per 1M tokens (USD). Update when Anthropic changes their pricing page.
+const MODEL_TABLE = {
+  'claude-opus-4-7':   { input: 15.00, output: 75.00, features: { json: true, temperature: true, reasoning: true } },
+  'claude-opus-4-6':   { input: 15.00, output: 75.00, features: { json: true, temperature: true, reasoning: true } },
+  'claude-sonnet-4-6': { input: 3.00,  output: 15.00, features: { json: true, temperature: true, reasoning: true } },
+  'claude-haiku-4-5':  { input: 1.00,  output: 5.00,  features: { json: true, temperature: true, reasoning: false } },
+};
+
+function Anthropic(assistant, key) {
+  const self = this;
+
+  self.assistant = assistant;
+  self.Manager = assistant?.Manager;
+  self.user = assistant?.user;
+  self.key = key
+    || self.Manager?.config?.anthropic?.key
+    || process.env.ANTHROPIC_API_KEY
+    || process.env.BACKEND_MANAGER_ANTHROPIC_API_KEY;
+
+  self.tokens = {
+    total:  { count: 0, price: 0 },
+    input:  { count: 0, price: 0 },
+    output: { count: 0, price: 0 },
+  };
+
+  return self;
+}
+
+Anthropic.prototype.request = async function (options) {
+  const self = this;
+  const assistant = self.assistant;
+
+  options = _.merge({}, options);
+  options.model = options.model || DEFAULT_MODEL;
+  options.maxTokens = options.maxTokens || 2048;
+  options.temperature = typeof options.temperature === 'undefined' ? 0.7 : options.temperature;
+  options.timeout = options.timeout || 120000;
+
+  if (!self.key) {
+    throw new Error('Anthropic API key not configured (set BACKEND_MANAGER_ANTHROPIC_API_KEY)');
+  }
+
+  // Lazy-require the SDK so projects that don't use Anthropic don't need it installed
+  const SDK = require('@anthropic-ai/sdk');
+  const client = new SDK({ apiKey: self.key });
+
+  // Build messages from the OpenAI-style option shape (prompt + message) or pass-through messages
+  const { system, messages } = buildMessages(options);
+
+  // JSON output via system prompt instruction (Anthropic's structured output is via prompt, not a flag)
+  let systemFinal = system;
+
+  if (options.response === 'json') {
+    systemFinal = `${systemFinal || ''}\n\nYou MUST respond with valid JSON only. No prose, no markdown fences, no explanation — just the JSON object.${options.schema ? `\n\nThe JSON must conform to this schema:\n${JSON.stringify(options.schema)}` : ''}`.trim();
+  }
+
+  const requestBody = {
+    model: options.model,
+    max_tokens: options.maxTokens,
+    messages,
+  };
+
+  if (systemFinal) {
+    requestBody.system = systemFinal;
+  }
+
+  if (options.temperature !== undefined) {
+    requestBody.temperature = options.temperature;
+  }
+
+  let raw;
+
+  try {
+    raw = await client.messages.create(requestBody);
+  } catch (e) {
+    assistant?.error?.(`Anthropic request failed: ${e.message}`, e);
+    throw e;
+  }
+
+  // Extract text from content blocks (concatenate text blocks; ignore tool_use/etc for now)
+  const outputText = (raw.content || [])
+    .filter((c) => c.type === 'text')
+    .map((c) => c.text.trim())
+    .join('\n')
+    .trim();
+
+  // Update token counters
+  const modelConfig = MODEL_TABLE[options.model] || MODEL_TABLE[DEFAULT_MODEL];
+
+  self.tokens.input.count  += raw.usage?.input_tokens || 0;
+  self.tokens.output.count += raw.usage?.output_tokens || 0;
+  self.tokens.total.count   = self.tokens.input.count + self.tokens.output.count;
+  self.tokens.input.price   = (self.tokens.input.count * modelConfig.input) / 1_000_000;
+  self.tokens.output.price  = (self.tokens.output.count * modelConfig.output) / 1_000_000;
+  self.tokens.total.price   = self.tokens.input.price + self.tokens.output.price;
+
+  // Parse JSON if requested
+  let parsed = outputText;
+
+  if (options.response === 'json') {
+    parsed = parseJsonLoose(outputText);
+  }
+
+  return {
+    output: raw.content || [],
+    content: parsed,
+    tokens: self.tokens,
+    raw,
+  };
+};
+
+/**
+ * Build Anthropic system + messages from the unified option shape.
+ *
+ * Accepts either:
+ *   - options.messages: [{ role: 'system'|'user'|'assistant', content: string }]
+ *   - options.prompt.content (system) + options.message.content (user)
+ */
+function buildMessages(options) {
+  // If caller passed `messages` directly (OpenAI-style), translate it
+  if (Array.isArray(options.messages) && options.messages.length) {
+    const system = options.messages.find((m) => m.role === 'system')?.content;
+    const messages = options.messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({ role: m.role, content: stringifyContent(m.content) }));
+
+    return { system, messages };
+  }
+
+  // Otherwise build from prompt/message
+  const system = options.prompt?.content || '';
+  const userContent = stringifyContent(options.message?.content || '');
+
+  return {
+    system,
+    messages: [{ role: 'user', content: userContent }],
+  };
+}
+
+function stringifyContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  // OpenAI sometimes uses [{ type: 'input_text', text: '...' }] — flatten to string
+  if (Array.isArray(content)) {
+    return content
+      .filter((c) => c.type === 'input_text' || c.type === 'text')
+      .map((c) => c.text || '')
+      .join('\n');
+  }
+
+  return String(content || '');
+}
+
+/**
+ * Parse JSON from Claude output. Claude usually obeys the "JSON only" instruction
+ * but occasionally wraps responses in ```json fences or adds a sentence before.
+ * Strip fences and try JSON5 for robustness.
+ */
+function parseJsonLoose(text) {
+  let cleaned = text.trim();
+
+  // Strip ```json ... ``` fences
+  cleaned = cleaned.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '');
+
+  // Find first { or [ and last } or ] to handle preamble text
+  const firstBrace = Math.min(
+    ...[cleaned.indexOf('{'), cleaned.indexOf('[')].filter((i) => i >= 0),
+  );
+
+  if (firstBrace > 0) {
+    cleaned = cleaned.slice(firstBrace);
+  }
+
+  return JSON5.parse(cleaned);
+}
+
+module.exports = Anthropic;

package/src/manager/libraries/ai/providers/claude-code.js

@@ -0,0 +1,206 @@
+/**
+ * Claude Code provider — uses @anthropic-ai/claude-agent-sdk to call Claude via
+ * the local user's Claude Code subscription (no API key, no Anthropic credits).
+ *
+ * Pass `forceLoginMethod: 'claudeai'` so the SDK auths via the OS keychain
+ * OAuth session that the user already logged into via the `claude` CLI.
+ *
+ * This is strictly a local-development provider:
+ *   - Requires a logged-in Claude Code session on the host machine
+ *   - Will not work in Cloud Functions / CI / production
+ *   - Subject to your Claude Pro/Max rate limits (not API-tier limits)
+ *
+ * Returns the same { content, output, tokens, raw } shape as the other providers
+ * so callers don't care which is in use.
+ */
+const DEFAULT_MODEL = 'claude-opus-4-7';
+
+// Lazy import — only load the SDK if this provider is actually used
+let _query;
+
+function loadQuery() {
+  if (!_query) {
+    _query = require('@anthropic-ai/claude-agent-sdk').query;
+  }
+
+  return _query;
+}
+
+function ClaudeCode(assistant, key) {
+  const self = this;
+
+  self.assistant = assistant;
+  self.Manager = assistant?.Manager;
+  self.user = assistant?.user;
+  // key is ignored — claude-code uses OS keychain OAuth via forceLoginMethod: 'claudeai'
+
+  self.tokens = {
+    total:  { count: 0, price: 0 },
+    input:  { count: 0, price: 0 },
+    output: { count: 0, price: 0 },
+  };
+
+  return self;
+}
+
+ClaudeCode.prototype.request = async function (options) {
+  const self = this;
+  const assistant = self.assistant;
+
+  options = options || {};
+  const model = options.model || DEFAULT_MODEL;
+
+  // Build prompt + system from the unified options shape
+  const { system, prompt } = extractPromptAndSystem(options);
+
+  if (!prompt) {
+    throw new Error('claude-code provider requires options.message.content or options.messages with a user turn');
+  }
+
+  const query = loadQuery();
+  const startTime = Date.now();
+
+  // Build SDK options
+  const sdkOptions = {
+    model,
+    forceLoginMethod: 'claudeai',  // Use Claude Pro/Max subscription, not API key
+    allowedTools: [],               // Disable all built-in tools — we just want text/JSON in/out
+    settingSources: [],             // Don't load .claude/ or ~/.claude/ settings
+    includePartialMessages: false,
+  };
+
+  if (system) {
+    sdkOptions.systemPrompt = system;
+  }
+
+  if (options.response === 'json' && options.schema) {
+    sdkOptions.outputFormat = {
+      type: 'json_schema',
+      schema: options.schema,
+    };
+  }
+
+  let resultText = '';
+  let structuredOutput = null;
+  let usage = null;
+  let totalCostUSD = 0;
+
+  try {
+    for await (const message of query({ prompt, options: sdkOptions })) {
+      // Collect text from assistant messages
+      if (message.type === 'assistant') {
+        for (const block of message.message?.content || []) {
+          if (block.type === 'text') {
+            resultText += block.text;
+          }
+        }
+      }
+
+      // Capture final result + usage from the result message
+      if (message.type === 'result') {
+        if (message.subtype === 'success') {
+          structuredOutput = message.structured_output || null;
+          resultText = message.result || resultText;
+        }
+
+        usage = message.usage;
+        totalCostUSD = message.total_cost_usd || 0;
+
+        if (message.is_error) {
+          throw new Error(`claude-code: ${resultText || 'unknown error'}`);
+        }
+      }
+    }
+  } catch (e) {
+    assistant?.error?.(`claude-code request failed: ${e.message}`);
+    throw e;
+  }
+
+  // Update token counters
+  if (usage) {
+    self.tokens.input.count  += usage.input_tokens  || 0;
+    self.tokens.output.count += usage.output_tokens || 0;
+    self.tokens.total.count   = self.tokens.input.count + self.tokens.output.count;
+    self.tokens.total.price   = totalCostUSD;
+  }
+
+  // Resolve content — prefer structured_output (validated against schema)
+  let content;
+
+  if (structuredOutput != null) {
+    content = structuredOutput;
+  } else if (options.response === 'json') {
+    content = parseJsonLoose(resultText);
+  } else {
+    content = resultText;
+  }
+
+  assistant?.log?.(`claude-code: ${Date.now() - startTime}ms, ${usage?.output_tokens || 0} output tokens, $${totalCostUSD?.toFixed(4) || '0.0000'}`);
+
+  return {
+    output: [{ type: 'output_text', text: resultText }],
+    content,
+    tokens: self.tokens,
+    raw: { usage, totalCostUSD },
+  };
+};
+
+/**
+ * Map unified options into a system prompt + a single user prompt string.
+ */
+function extractPromptAndSystem(options) {
+  if (Array.isArray(options.messages) && options.messages.length) {
+    const system = options.messages.find((m) => m.role === 'system')?.content;
+    const lastUser = [...options.messages].reverse().find((m) => m.role !== 'system');
+
+    return {
+      system: stringifyContent(system),
+      prompt: stringifyContent(lastUser?.content),
+    };
+  }
+
+  return {
+    system: stringifyContent(options.prompt?.content),
+    prompt: stringifyContent(options.message?.content),
+  };
+}
+
+function stringifyContent(content) {
+  if (!content) {
+    return '';
+  }
+
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .filter((c) => c.type === 'input_text' || c.type === 'text')
+      .map((c) => c.text || '')
+      .join('\n');
+  }
+
+  return String(content);
+}
+
+function parseJsonLoose(text) {
+  if (!text) return text;
+
+  let cleaned = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '');
+  const firstObj = cleaned.indexOf('{');
+  const firstArr = cleaned.indexOf('[');
+  const start = [firstObj, firstArr].filter((i) => i >= 0).sort((a, b) => a - b)[0];
+
+  if (start > 0) {
+    cleaned = cleaned.slice(start);
+  }
+
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    return text;
+  }
+}
+
+module.exports = ClaudeCode;