@contentgrowth/llm-service 0.8.3 → 0.8.5

package/src/llm/json-utils.js

@@ -1,147 +0,0 @@
-/**
- * Extracts and parses JSON from a text response (e.g., from an LLM).
- * Handles JSON in markdown code blocks or plain JSON objects.
- * 
- * TODO: improveme for better performance
- * 
- * @param {string} text - The text containing JSON
- * @returns {object|null} - The parsed JSON object, or null if no valid JSON found
- */
-export function extractJsonFromResponse(text) {
-  if (!text || typeof text !== 'string') {
-    return null;
-  }
-
-  // Helper to sanitize JSON strings with unescaped control characters
-  function sanitizeJsonString(str) {
-    // Find all JSON strings: "..."
-    // Handle escaped quotes \" and backslashes \\
-    return str.replace(/"(?:[^"\\]|\\.)*"/g, (match) => {
-      // Replace unescaped control characters inside the string
-      return match
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
-    });
-  }
-
-  // Helper function to attempt JSON parsing with escape sequence normalization
-  function tryParseJson(jsonStr) {
-    // First, try to parse as-is
-    try {
-      return JSON.parse(jsonStr);
-    } catch (e) {
-      // If that fails, check if the LLM over-escaped the content
-      // This is a common issue where LLMs return \\\\n instead of \\n
-
-      // Only attempt normalization if we detect the problematic pattern
-      if (jsonStr.includes('\\\\\\\\')) {
-        // Log the first parse attempt failure for debugging
-        console.warn('Initial JSON parse failed, attempting normalization:', e.message);
-
-        try {
-          // Strategy: The LLM sometimes escapes strings that are already escaped
-          // For example: "content": "text\\\\nmore" should be "content": "text\\nmore"
-          // Replace quadruple backslashes with double (handles over-escaping)
-          let normalized = jsonStr.replace(/\\\\\\\\/g, '\\\\');
-
-          return JSON.parse(normalized);
-        } catch (e2) {
-          // Log this failure too
-          console.warn('Normalized JSON parse also failed:', e2.message);
-          // Fall through to sanitization
-        }
-      }
-
-      // Try sanitizing unescaped control characters (common LLM error)
-      try {
-        const sanitized = sanitizeJsonString(jsonStr);
-        return JSON.parse(sanitized);
-      } catch (e3) {
-        // If all attempts fail, throw the original error
-        throw e;
-      }
-    }
-  }
-
-  // Regular expression to find a JSON object within markdown code fences.
-  // It's flexible with or without the 'json' language specifier.
-  const jsonRegex = /```(?:json)?\s*({[\s\S]*?})\s*```/;
-  const match = text.match(jsonRegex);
-
-  // If a fenced JSON block is found, try to parse it.
-  if (match && match[1]) {
-    try {
-      return tryParseJson(match[1]);
-    } catch (e) {
-      // If parsing fails, log the error and fall through to the next method.
-      console.warn('Could not parse the content of a matched JSON block.', e.message);
-    }
-  }
-
-  // Fallback for cases where the AI might not use markdown fences correctly.
-  // Find the first opening brace and the last closing brace.
-  const firstBrace = text.indexOf('{');
-  const lastBrace = text.lastIndexOf('}');
-
-  if (firstBrace !== -1 && lastBrace > firstBrace) {
-    const potentialJson = text.substring(firstBrace, lastBrace + 1);
-    try {
-      return tryParseJson(potentialJson);
-    } catch (e) {
-      // This substring is not valid JSON.
-      console.error('Error parsing JSON extracted in { and }', e);
-    }
-  }
-
-  // If no valid JSON could be extracted by any method, return null.
-  return null;
-}
-
-/**
- * Generic helper to separate conversational text from a structured JSON payload.
- * Supports both "Text + JSON" and "JSON + Text" patterns.
- * 
- * @param {string} input - The full response string
- * @returns {{text: string, json: object|null}} 
- */
-export function extractTextAndJson(input) {
-  if (!input) return { text: '', json: null };
-
-  // 1. Try to extract JSON using the existing robust extractor
-  const json = extractJsonFromResponse(input);
-
-  // 2. If no JSON found, return full input as text
-  if (!json) {
-    return { text: input, json: null };
-  }
-
-  // 3. If JSON found, we need to remove the JSON block to get the clean text
-  let text = input;
-
-  // Try fenced block first (most reliable) - same regex as extractJsonFromResponse
-  const fencedRegex = /```(?:json)?\s*({[\s\S]*?})\s*```/;
-  const fencedMatch = input.match(fencedRegex);
-
-  if (fencedMatch) {
-    // Replace the entire fenced block with empty string to leave just the text
-    // This handles both "Text + JSON" and "JSON + Text" patterns
-    text = input.replace(fencedMatch[0], '').trim();
-    return { text, json };
-  }
-
-  // Try brace extraction as fallback - same logic as extractJsonFromResponse
-  const firstBrace = input.indexOf('{');
-  const lastBrace = input.lastIndexOf('}');
-
-  if (firstBrace !== -1 && lastBrace > firstBrace) {
-    // Remove the brace block, keeping text before and after
-    const pre = input.substring(0, firstBrace);
-    const post = input.substring(lastBrace + 1);
-    text = (pre + post).trim();
-    return { text, json };
-  }
-
-  // Fallback: Return original text if we couldn't cleanly separate it
-  return { text: input, json };
-}

package/src/llm/providers/base-provider.js

@@ -1,134 +0,0 @@
-/**
- * Standardized finish reasons across all LLM providers.
- * Providers map their native values to these standard constants.
- */
-export const FINISH_REASONS = {
-    COMPLETED: 'completed',      // Normal completion (OpenAI: stop, Gemini: STOP, Anthropic: end_turn)
-    TRUNCATED: 'truncated',      // Hit max tokens (OpenAI: length, Gemini: MAX_TOKENS, Anthropic: max_tokens)
-    CONTENT_FILTER: 'content_filter', // Content was filtered
-    TOOL_CALL: 'tool_call',      // Stopped for tool call
-    UNKNOWN: 'unknown',          // Unknown/unmapped reason
-};
-
-/**
- * Abstract base class for LLM Providers.
- * Defines the standard interface that all providers must implement.
- */
-export class BaseLLMProvider {
-    constructor(config) {
-        this.config = config;
-    }
-
-    /**
-     * Normalize provider-specific finish reason to standard value.
-     * Override in subclass if provider uses different values.
-     * @param {string} providerReason - The provider's native finish reason
-     * @returns {string} Standardized finish reason from FINISH_REASONS
-     */
-    normalizeFinishReason(providerReason) {
-        // Default mappings - providers can override
-        const upperReason = (providerReason || '').toUpperCase();
-
-        // Completed mappings
-        if (['STOP', 'END_TURN'].includes(upperReason)) {
-            return FINISH_REASONS.COMPLETED;
-        }
-
-        // Truncated mappings
-        if (['LENGTH', 'MAX_TOKENS'].includes(upperReason)) {
-            return FINISH_REASONS.TRUNCATED;
-        }
-
-        // Content filter mappings
-        if (['CONTENT_FILTER', 'SAFETY'].includes(upperReason)) {
-            return FINISH_REASONS.CONTENT_FILTER;
-        }
-
-        // Tool call mappings
-        if (['TOOL_CALLS', 'TOOL_USE', 'FUNCTION_CALL'].includes(upperReason)) {
-            return FINISH_REASONS.TOOL_CALL;
-        }
-
-        return FINISH_REASONS.UNKNOWN;
-    }
-
-    /**
-     * Simple chat interface for single-turn conversations
-     * @param {string} userMessage 
-     * @param {string} systemPrompt 
-     * @param {Object} options 
-     */
-    async chat(userMessage, systemPrompt, options) {
-        throw new Error('Method not implemented');
-    }
-
-    /**
-     * Advanced chat completion with tool support
-     * @param {Array} messages 
-     * @param {string} systemPrompt 
-     * @param {Array} tools 
-     * @param {Object} options - Generation options (responseFormat, temperature, etc.)
-     */
-    async chatCompletion(messages, systemPrompt, tools, options = {}) {
-        throw new Error('Method not implemented');
-    }
-
-    /**
-     * Execute tools requested by the LLM
-     * @param {Array} toolCalls 
-     * @param {Array} messages 
-     * @param {string} tenantId 
-     * @param {Object} toolImplementations 
-     * @param {Object} env 
-     */
-    async executeTools(toolCalls, messages, tenantId, toolImplementations, env) {
-        throw new Error('Method not implemented');
-    }
-
-    /**
-     * Generate image
-     * Subclasses should override this method.
-     * Model can be overridden via options.model, otherwise uses config.models.image
-     * @param {string} prompt - Text description of the image
-     * @param {string} systemPrompt - System instructions for generation
-     * @param {Object} options - Generation options (aspectRatio, images, model, etc.)
-     * @returns {Promise<{imageData: string, mimeType: string}>}
-     */
-    async imageGeneration(prompt, systemPrompt, options = {}) {
-        throw new Error('Image generation not supported by this provider');
-    }
-
-
-    /**
-     * Start video generation (returns operation name for polling)
-     * @param {string} prompt
-     * @param {Array} images
-     * @param {string} modelName
-     * @param {string} systemPrompt
-     * @param {Object} options
-     * @returns {Promise<{operationName: string}>}
-     */
-    async startVideoGeneration(prompt, images, modelName, systemPrompt, options) {
-        throw new Error('Video generation not supported by this provider');
-    }
-
-    /**
-     * Get video generation status (poll operation)
-     * @param {string} operationName
-     * @returns {Promise<{done: boolean, progress: number, state: string, videoUri?: string, error?: object}>}
-     */
-    async getVideoGenerationStatus(operationName) {
-        throw new Error('Video generation not supported by this provider');
-    }
-
-    /**
-     * Helper to get the last 6 digits of the API key for logging.
-     * @returns {string} "..." + last 6 chars, or "not_set"
-     */
-    _getMaskedApiKey() {
-        const key = this.config.apiKey;
-        if (!key) return 'not_set';
-        if (key.length <= 6) return '...';
-        return '...' + key.slice(-6);
-    }
-}