@contentgrowth/llm-service 0.8.2 → 0.8.4

package/dist/index.js

@@ -0,0 +1,1478 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/llm/config-provider.js
+var BaseConfigProvider = class {
+  /**
+   * Retrieve configuration for a specific tenant.
+   * @param {string} tenantId 
+   * @param {Object} env 
+   * @returns {Promise<Object>} Configuration object
+   */
+  async getConfig(tenantId, env) {
+    throw new Error("Method not implemented");
+  }
+};
+var DefaultConfigProvider = class extends BaseConfigProvider {
+  async getConfig(tenantId, env) {
+    var _a;
+    if (!tenantId) {
+      return this._getSystemConfig(env);
+    }
+    const cacheKey = `tenant:${tenantId}:llm_config`;
+    const cached = await ((_a = env.TENANT_LLM_CONFIG) == null ? void 0 : _a.get(cacheKey));
+    if (cached !== null && cached !== void 0) {
+      if (cached === "{}") {
+        return this._getSystemConfig(env);
+      }
+      const config = JSON.parse(cached);
+      return this._buildTenantConfig(config, env);
+    }
+    const tenantConfig = await this._loadFromTenantDO(tenantId, env);
+    if (tenantConfig && tenantConfig.enabled && tenantConfig.api_key) {
+      if (env.TENANT_LLM_CONFIG) {
+        await env.TENANT_LLM_CONFIG.put(
+          cacheKey,
+          JSON.stringify(tenantConfig),
+          { expirationTtl: 3600 }
+          // 1 hour
+        );
+      }
+      return this._buildTenantConfig(tenantConfig, env);
+    } else {
+      if (env.TENANT_LLM_CONFIG) {
+        await env.TENANT_LLM_CONFIG.put(
+          cacheKey,
+          "{}",
+          { expirationTtl: 3600 }
+          // 1 hour
+        );
+      }
+      return this._getSystemConfig(env);
+    }
+  }
+  async _loadFromTenantDO(tenantId, env) {
+    try {
+      if (!env.TENANT_DO) return null;
+      const doId = env.TENANT_DO.idFromName(tenantId);
+      const stub = env.TENANT_DO.get(doId);
+      const response = await stub.fetch(new Request(`http://do/llm-config/${tenantId}`));
+      if (response.ok) {
+        const config = await response.json();
+        return config;
+      }
+      return null;
+    } catch (error) {
+      console.error(`[ConfigManager] Failed to load from TenantDO for tenant ${tenantId}:`, error);
+      return null;
+    }
+  }
+  _buildTenantConfig(tenantConfig, env) {
+    return {
+      provider: tenantConfig.provider,
+      apiKey: tenantConfig.api_key,
+      models: MODEL_CONFIGS[tenantConfig.provider],
+      temperature: parseFloat(env.DEFAULT_TEMPERATURE || "0.7"),
+      maxTokens: parseInt(env.DEFAULT_MAX_TOKENS || "16384"),
+      capabilities: tenantConfig.capabilities || { chat: true, image: false, video: false },
+      isTenantOwned: true
+    };
+  }
+  _getSystemConfig(env) {
+    var _a;
+    const provider = ((_a = env.LLM_PROVIDER) == null ? void 0 : _a.toLowerCase()) || "openai";
+    const providerDefaults = MODEL_CONFIGS[provider] || MODEL_CONFIGS["openai"];
+    let apiKey;
+    let models = { ...providerDefaults };
+    if (provider === "openai") {
+      apiKey = env.OPENAI_API_KEY;
+      models = {
+        default: env.OPENAI_MODEL || providerDefaults.default,
+        edge: env.OPENAI_MODEL_EDGE || providerDefaults.edge,
+        fast: env.OPENAI_MODEL_FAST || providerDefaults.fast,
+        cost: env.OPENAI_MODEL_COST || providerDefaults.cost,
+        free: env.OPENAI_MODEL_FREE || providerDefaults.free
+      };
+    } else if (provider === "gemini") {
+      apiKey = env.GEMINI_API_KEY;
+      models = {
+        default: env.GEMINI_MODEL || providerDefaults.default,
+        edge: env.GEMINI_MODEL_EDGE || providerDefaults.edge,
+        fast: env.GEMINI_MODEL_FAST || providerDefaults.fast,
+        cost: env.GEMINI_MODEL_COST || providerDefaults.cost,
+        free: env.GEMINI_MODEL_FREE || providerDefaults.free,
+        image: env.GEMINI_IMAGE_MODEL || providerDefaults.image,
+        video: env.GEMINI_VIDEO_MODEL || providerDefaults.video
+      };
+    }
+    return {
+      provider,
+      apiKey,
+      models,
+      temperature: parseFloat(env.DEFAULT_TEMPERATURE || "0.7"),
+      maxTokens: parseInt(env.DEFAULT_MAX_TOKENS || "16384")
+    };
+  }
+};
+
+// src/llm/config-manager.js
+var MODEL_CONFIGS = {
+  openai: {
+    default: "gpt-4o",
+    edge: "gpt-4o",
+    fast: "gpt-4o-mini",
+    cost: "gpt-4o-mini",
+    free: "gpt-4o-mini"
+  },
+  gemini: {
+    default: "gemini-3-flash-preview",
+    // 'gemini-2.5-flash',
+    edge: "gemini-3-pro-preview",
+    // 'gemini-2.5-pro',
+    fast: "gemini-3-flash-preview",
+    // 'gemini-2.5-flash-lite',
+    cost: "gemini-3-flash-preview",
+    // 'gemini-2.5-flash-lite',
+    free: "gemini-3-flash-preview",
+    // 'gemini-2.0-flash-lite',
+    video: "veo",
+    image: "gemini-3-pro-image-preview"
+    // Default image generation model
+  }
+};
+var ConfigManager = class {
+  /**
+   * Set a custom configuration provider.
+   * @param {BaseConfigProvider} provider 
+   */
+  static setConfigProvider(provider) {
+    this._provider = provider;
+  }
+  static async getConfig(tenantId, env) {
+    return this._provider.getConfig(tenantId, env);
+  }
+};
+__publicField(ConfigManager, "_provider", new DefaultConfigProvider());
+
+// src/llm/providers/openai-provider.js
+import OpenAI from "openai";
+
+// src/llm/providers/base-provider.js
+var 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
+};
+var BaseLLMProvider = class {
+  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) {
+    const upperReason = (providerReason || "").toUpperCase();
+    if (["STOP", "END_TURN"].includes(upperReason)) {
+      return FINISH_REASONS.COMPLETED;
+    }
+    if (["LENGTH", "MAX_TOKENS"].includes(upperReason)) {
+      return FINISH_REASONS.TRUNCATED;
+    }
+    if (["CONTENT_FILTER", "SAFETY"].includes(upperReason)) {
+      return FINISH_REASONS.CONTENT_FILTER;
+    }
+    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);
+  }
+};
+
+// src/llm/json-utils.js
+function extractJsonFromResponse(text) {
+  if (!text || typeof text !== "string") {
+    return null;
+  }
+  function sanitizeJsonString(str) {
+    return str.replace(/"(?:[^"\\]|\\.)*"/g, (match2) => {
+      return match2.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+    });
+  }
+  function tryParseJson(jsonStr) {
+    try {
+      return JSON.parse(jsonStr);
+    } catch (e) {
+      if (jsonStr.includes("\\\\\\\\")) {
+        console.warn("Initial JSON parse failed, attempting normalization:", e.message);
+        try {
+          let normalized = jsonStr.replace(/\\\\\\\\/g, "\\\\");
+          return JSON.parse(normalized);
+        } catch (e2) {
+          console.warn("Normalized JSON parse also failed:", e2.message);
+        }
+      }
+      try {
+        const sanitized = sanitizeJsonString(jsonStr);
+        return JSON.parse(sanitized);
+      } catch (e3) {
+        throw e;
+      }
+    }
+  }
+  const jsonRegex = /```(?:json)?\s*({[\s\S]*?})\s*```/;
+  const match = text.match(jsonRegex);
+  if (match && match[1]) {
+    try {
+      return tryParseJson(match[1]);
+    } catch (e) {
+      console.warn("Could not parse the content of a matched JSON block.", e.message);
+    }
+  }
+  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) {
+      console.error("Error parsing JSON extracted in { and }", e);
+    }
+  }
+  return null;
+}
+function extractTextAndJson(input) {
+  if (!input) return { text: "", json: null };
+  const json = extractJsonFromResponse(input);
+  if (!json) {
+    return { text: input, json: null };
+  }
+  let text = input;
+  const fencedRegex = /```(?:json)?\s*({[\s\S]*?})\s*```/;
+  const fencedMatch = input.match(fencedRegex);
+  if (fencedMatch) {
+    text = input.replace(fencedMatch[0], "").trim();
+    return { text, json };
+  }
+  const firstBrace = input.indexOf("{");
+  const lastBrace = input.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    const pre = input.substring(0, firstBrace);
+    const post = input.substring(lastBrace + 1);
+    text = (pre + post).trim();
+    return { text, json };
+  }
+  return { text: input, json };
+}
+
+// src/llm/providers/openai-provider.js
+var OpenAIProvider = class extends BaseLLMProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({ apiKey: config.apiKey });
+    this.models = config.models;
+    this.defaultModel = config.models.default;
+  }
+  async chat(userMessage, systemPrompt = "", options = {}) {
+    const messages = [{ role: "user", content: userMessage }];
+    const tier = options.tier || "default";
+    const effectiveModel = this._getModelForTier(tier);
+    const effectiveMaxTokens = options.maxTokens || this.config.maxTokens;
+    const effectiveTemperature = options.temperature !== void 0 ? options.temperature : this.config.temperature;
+    const response = await this._chatCompletionWithModel(
+      messages,
+      systemPrompt,
+      null,
+      effectiveModel,
+      effectiveMaxTokens,
+      effectiveTemperature
+    );
+    return { text: response.content };
+  }
+  async chatCompletion(messages, systemPrompt, tools = null, options = {}) {
+    return this._chatCompletionWithModel(
+      messages,
+      systemPrompt,
+      tools,
+      this.defaultModel,
+      this.config.maxTokens,
+      this.config.temperature,
+      options
+    );
+  }
+  async _chatCompletionWithModel(messages, systemPrompt, tools, modelName, maxTokens, temperature, options = {}) {
+    var _a, _b;
+    const requestPayload = {
+      model: modelName,
+      temperature: (_a = options.temperature) != null ? _a : temperature,
+      max_tokens: (_b = options.maxTokens) != null ? _b : maxTokens,
+      messages: [{ role: "system", content: systemPrompt }, ...messages],
+      tools,
+      tool_choice: tools ? "auto" : void 0
+    };
+    if (options.responseFormat) {
+      requestPayload.response_format = this._buildResponseFormat(options);
+    }
+    let response;
+    try {
+      response = await this.client.chat.completions.create(requestPayload);
+    } catch (error) {
+      console.error(`[OpenAIProvider] chat completion failed (API Key: ${this._getMaskedApiKey()}):`, error);
+      throw error;
+    }
+    const message = response.choices[0].message;
+    if (!message.content && (!message.tool_calls || message.tool_calls.length === 0)) {
+      console.error("[OpenAIProvider] Model returned empty response (no text, no tool calls)");
+      throw new LLMServiceException(
+        "Model returned empty response. This usually means the prompt or schema is confusing the model.",
+        500
+      );
+    }
+    const rawFinishReason = response.choices[0].finish_reason;
+    const normalizedFinishReason = this.normalizeFinishReason(rawFinishReason);
+    return {
+      content: message.content,
+      tool_calls: message.tool_calls,
+      finishReason: normalizedFinishReason,
+      // Standardized: 'completed', 'truncated', etc.
+      _rawFinishReason: rawFinishReason,
+      // Keep original for debugging
+      // Add metadata about response format
+      _responseFormat: options.responseFormat,
+      // Auto-parse JSON if requested
+      ...options.responseFormat && this._shouldAutoParse(options) ? {
+        parsedContent: this._safeJsonParse(message.content)
+      } : {}
+    };
+  }
+  _buildResponseFormat(options) {
+    var _a, _b;
+    if (!options.responseFormat) {
+      return void 0;
+    }
+    const formatType = typeof options.responseFormat === "string" ? options.responseFormat : options.responseFormat.type;
+    const schema = typeof options.responseFormat === "object" ? options.responseFormat.schema : options.responseSchema || null;
+    switch (formatType) {
+      case "json":
+        if (schema) {
+          console.log("[OpenAIProvider] Using Strict JSON mode with schema");
+          return {
+            type: "json_schema",
+            json_schema: {
+              name: options.schemaName || "response_schema",
+              strict: (_a = options.strictSchema) != null ? _a : true,
+              schema
+            }
+          };
+        } else {
+          console.warn("[OpenAIProvider] Using legacy json_object mode without schema - may produce markdown wrappers");
+          return { type: "json_object" };
+        }
+      case "json_schema":
+        if (!schema) {
+          throw new Error("responseSchema required when using json_schema format");
+        }
+        console.log("[OpenAIProvider] Using Strict JSON mode with schema");
+        return {
+          type: "json_schema",
+          json_schema: {
+            name: options.schemaName || "response_schema",
+            strict: (_b = options.strictSchema) != null ? _b : true,
+            schema
+          }
+        };
+      default:
+        return void 0;
+    }
+  }
+  _shouldAutoParse(options) {
+    return options.autoParse !== false;
+  }
+  _safeJsonParse(content) {
+    if (!content) return null;
+    const parsed = extractJsonFromResponse(content);
+    if (parsed) {
+      console.log("[OpenAIProvider] Successfully parsed JSON from response");
+    } else {
+      console.error("[OpenAIProvider] Failed to extract valid JSON from response");
+      console.error("[OpenAIProvider] Content preview:", content.substring(0, 200));
+    }
+    return parsed;
+  }
+  async executeTools(tool_calls, messages, tenantId, toolImplementations, env) {
+    const toolResults = await Promise.all(
+      tool_calls.map(async (toolCall) => {
+        const toolName = toolCall.function.name;
+        const tool = toolImplementations[toolName];
+        console.log(`[Tool Call] ${toolName} with arguments:`, toolCall.function.arguments);
+        if (!tool) {
+          console.error(`[Tool Error] Tool '${toolName}' not found`);
+          return { tool_call_id: toolCall.id, output: JSON.stringify({ error: `Tool '${toolName}' not found.` }) };
+        }
+        try {
+          const output = await tool(toolCall.function.arguments, { env, tenantId });
+          console.log(`[Tool Result] ${toolName} returned:`, output.substring(0, 200) + (output.length > 200 ? "..." : ""));
+          return { tool_call_id: toolCall.id, output };
+        } catch (error) {
+          console.error(`[Tool Error] ${toolName} failed:`, error.message);
+          return { tool_call_id: toolCall.id, output: JSON.stringify({ error: `Error executing tool '${toolName}': ${error.message}` }) };
+        }
+      })
+    );
+    toolResults.forEach((result) => messages.push({ role: "tool", tool_call_id: result.tool_call_id, content: result.output }));
+  }
+  _getModelForTier(tier) {
+    return this.models[tier] || this.models.default;
+  }
+  async videoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
+    throw new Error("Video generation is not supported by OpenAI provider yet.");
+  }
+  async startDeepResearch(prompt, options = {}) {
+    throw new Error("Deep Research is not supported by OpenAI provider.");
+  }
+  async getDeepResearchStatus(operationId) {
+    throw new Error("Deep Research is not supported by OpenAI provider.");
+  }
+};
+
+// src/llm/providers/gemini-provider.js
+import { GoogleGenAI } from "@google/genai";
+var GeminiProvider = class extends BaseLLMProvider {
+  constructor(config) {
+    super(config);
+    const clientConfig = {};
+    if (config.project || config.location) {
+      console.log(`[GeminiProvider] Initializing with Vertex AI (Project: ${config.project}, Location: ${config.location || "us-central1"})`);
+      clientConfig.vertexAI = {
+        project: config.project,
+        location: config.location || "us-central1"
+      };
+    } else {
+      clientConfig.apiKey = config.apiKey;
+    }
+    this.client = new GoogleGenAI(clientConfig);
+    this.models = config.models;
+    this.defaultModel = config.models.default;
+    this._pendingOperations = /* @__PURE__ */ new Map();
+  }
+  async chat(userMessage, systemPrompt = "", options = {}) {
+    const messages = [{ role: "user", content: userMessage }];
+    const tier = options.tier || "default";
+    const effectiveModel = this._getModelForTier(tier);
+    const effectiveMaxTokens = options.maxTokens || this.config.maxTokens;
+    const effectiveTemperature = options.temperature !== void 0 ? options.temperature : this.config.temperature;
+    const response = await this._chatCompletionWithModel(
+      messages,
+      systemPrompt,
+      null,
+      effectiveModel,
+      effectiveMaxTokens,
+      effectiveTemperature
+    );
+    return { text: response.content };
+  }
+  async chatCompletion(messages, systemPrompt, tools = null, options = {}) {
+    return this._chatCompletionWithModel(
+      messages,
+      systemPrompt,
+      tools,
+      this.defaultModel,
+      this.config.maxTokens,
+      this.config.temperature,
+      options
+    );
+  }
+  async _chatCompletionWithModel(messages, systemPrompt, tools, modelName, maxTokens, temperature, options = {}) {
+    var _a, _b, _c, _d;
+    const generationConfig = {
+      temperature: (_a = options.temperature) != null ? _a : temperature,
+      maxOutputTokens: (_b = options.maxTokens) != null ? _b : maxTokens
+    };
+    if (options.responseFormat) {
+      const formatConfig = this._buildGenerationConfig(options, maxTokens, temperature);
+      Object.assign(generationConfig, formatConfig);
+    }
+    const geminiMessages = [];
+    let systemContentBuffer = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemContentBuffer.push(msg.content);
+      } else {
+        if (msg.role === "user" && systemContentBuffer.length > 0) {
+          const fullContent = `${systemContentBuffer.join("\n")}
+
+${msg.content}`;
+          geminiMessages.push({ ...msg, content: fullContent });
+          systemContentBuffer = [];
+        } else {
+          geminiMessages.push(msg);
+        }
+      }
+    }
+    const contents = geminiMessages.map((msg, index) => {
+      var _a2, _b2, _c2, _d2;
+      let role = "";
+      let parts2;
+      switch (msg.role) {
+        case "user":
+          role = "user";
+          parts2 = [{ text: msg.content }];
+          if (index === geminiMessages.length - 1) {
+            let reminder = "";
+            if (options.responseFormat === "json" || ((_a2 = options.responseFormat) == null ? void 0 : _a2.type) === "json_schema" || options.responseSchema) {
+              reminder = "\n\n[SYSTEM NOTE: The output MUST be valid JSON as per the schema. Do not include markdown formatting or explanations.]";
+            } else {
+              reminder = "\n\n[SYSTEM NOTE: Please ensure your response adheres strictly to the constraints defined in the System Prompt.]";
+            }
+            const lastPart = parts2.find((p) => p.text);
+            if (lastPart) {
+              lastPart.text += reminder;
+            } else {
+              parts2.push({ text: reminder });
+            }
+          }
+          break;
+        case "assistant":
+          role = "model";
+          const isLastAssistantMessage = index === geminiMessages.map((m, i) => m.role === "assistant" ? i : -1).filter((i) => i >= 0).pop();
+          if (msg.tool_calls) {
+            parts2 = msg.tool_calls.map((tc) => {
+              const part = {
+                functionCall: { name: tc.function.name, args: tc.function.arguments || tc.function.args }
+              };
+              if (tc.thought_signature) {
+                console.log(`[GeminiProvider] Sending thought_signature in tool_call (${tc.thought_signature.length} chars)`);
+                part.thoughtSignature = tc.thought_signature;
+              }
+              return part;
+            });
+          } else {
+            const part = { text: msg.content || "" };
+            if (isLastAssistantMessage && msg.thought_signature) {
+              console.log(`[GeminiProvider] Sending thought_signature in text message (${msg.thought_signature.length} chars)`);
+              part.thoughtSignature = msg.thought_signature;
+            }
+            parts2 = [part];
+          }
+          break;
+        case "tool":
+          role = "user";
+          const preceding_message = messages[index - 1];
+          const tool_call = (_b2 = preceding_message == null ? void 0 : preceding_message.tool_calls) == null ? void 0 : _b2.find((tc) => tc.id === msg.tool_call_id);
+          parts2 = [{
+            functionResponse: {
+              name: ((_c2 = tool_call == null ? void 0 : tool_call.function) == null ? void 0 : _c2.name) || "unknown_tool",
+              response: { content: msg.content }
+            }
+          }];
+          if (options.responseFormat === "json" || ((_d2 = options.responseFormat) == null ? void 0 : _d2.type) === "json_schema" || options.responseSchema) {
+            parts2.push({ text: "\n\n[SYSTEM NOTE: The output MUST be valid JSON as per the schema. Do not include markdown formatting or explanations.]" });
+          } else {
+            parts2.push({ text: "\n\n[SYSTEM NOTE: Please ensure your response adheres strictly to the constraints defined in the System Prompt.]" });
+          }
+          break;
+        default:
+          return null;
+      }
+      return { role, parts: parts2 };
+    }).filter(Boolean);
+    while (contents.length > 0 && contents[0].role !== "user") {
+      contents.shift();
+    }
+    if (contents.length === 0) {
+      throw new LLMServiceException("Cannot process a conversation with no user messages.", 400);
+    }
+    const requestOptions = {
+      model: modelName,
+      contents,
+      config: generationConfig
+    };
+    if (systemPrompt) {
+      requestOptions.config.systemInstruction = { parts: [{ text: systemPrompt }] };
+    }
+    if (tools && tools.length > 0) {
+      requestOptions.config.tools = [{ functionDeclarations: tools.map((t) => t.function) }];
+      if (requestOptions.config.responseMimeType === "application/json") {
+        console.warn("[GeminiProvider] Disabling strict JSON mode because tools are present. Relying on system prompt.");
+        delete requestOptions.config.responseMimeType;
+        delete requestOptions.config.responseSchema;
+      }
+    }
+    let response;
+    try {
+      response = await this.client.models.generateContent(requestOptions);
+    } catch (error) {
+      console.error(`[GeminiProvider] generateContent failed (API Key: ${this._getMaskedApiKey()}):`, error);
+      throw error;
+    }
+    const candidate = (_c = response.candidates) == null ? void 0 : _c[0];
+    if (!candidate) {
+      throw new LLMServiceException("No candidates returned from model", 500);
+    }
+    const parts = ((_d = candidate.content) == null ? void 0 : _d.parts) || [];
+    let textContent = "";
+    let toolCalls = null;
+    let responseThoughtSignature = null;
+    for (const part of parts) {
+      if (part.text) {
+        textContent += part.text;
+        if (part.thought_signature || part.thoughtSignature) {
+          responseThoughtSignature = part.thought_signature || part.thoughtSignature;
+        }
+      }
+      if (part.functionCall) {
+        if (!toolCalls) toolCalls = [];
+        const sig = part.thought_signature || part.thoughtSignature;
+        if (sig) {
+          part.functionCall.thought_signature = sig;
+          if (!responseThoughtSignature) responseThoughtSignature = sig;
+        }
+        toolCalls.push(part.functionCall);
+      }
+      if (!part.text && !part.functionCall && (part.thought_signature || part.thoughtSignature)) {
+        responseThoughtSignature = part.thought_signature || part.thoughtSignature;
+      }
+    }
+    if (!textContent && (!toolCalls || toolCalls.length === 0)) {
+      console.error("[GeminiProvider] Model returned empty response (no text, no tool calls)");
+      console.error("[GeminiProvider] Finish Reason:", candidate.finishReason);
+      console.error("[GeminiProvider] Safety Ratings:", JSON.stringify(candidate.safetyRatings, null, 2));
+      console.error("[GeminiProvider] Full Candidate:", JSON.stringify(candidate, null, 2));
+      throw new LLMServiceException(
+        `Model returned empty response. Finish Reason: ${candidate.finishReason}.`,
+        500
+      );
+    }
+    const normalizedFinishReason = this.normalizeFinishReason(candidate.finishReason);
+    return {
+      content: textContent,
+      thought_signature: responseThoughtSignature,
+      // Return signature to caller
+      tool_calls: toolCalls ? (Array.isArray(toolCalls) ? toolCalls : [toolCalls]).map((fc) => ({
+        type: "function",
+        function: fc,
+        thought_signature: fc.thought_signature
+      })) : null,
+      finishReason: normalizedFinishReason,
+      // Standardized: 'completed', 'truncated', etc.
+      _rawFinishReason: candidate.finishReason,
+      // Keep original for debugging
+      _responseFormat: options.responseFormat,
+      ...options.responseFormat && this._shouldAutoParse(options) ? {
+        parsedContent: this._safeJsonParse(textContent)
+      } : {}
+    };
+  }
+  _buildGenerationConfig(options, maxTokens, temperature) {
+    var _a, _b;
+    const config = {
+      temperature: (_a = options.temperature) != null ? _a : temperature,
+      maxOutputTokens: (_b = options.maxTokens) != null ? _b : maxTokens
+    };
+    if (options.responseFormat) {
+      const formatType = typeof options.responseFormat === "string" ? options.responseFormat : options.responseFormat.type;
+      const schema = typeof options.responseFormat === "object" ? options.responseFormat.schema : options.responseSchema || null;
+      if (formatType === "json" || formatType === "json_schema") {
+        config.responseMimeType = "application/json";
+        if (schema) {
+          config.responseSchema = this._convertToGeminiSchema(schema);
+        } else {
+          console.warn("[GeminiProvider] Using legacy JSON mode without schema - may produce markdown wrappers");
+        }
+      }
+    }
+    return config;
+  }
+  _convertToGeminiSchema(jsonSchema) {
+    const convertType = (type) => {
+      switch (type) {
+        case "string":
+          return "STRING";
+        case "number":
+          return "NUMBER";
+        case "integer":
+          return "INTEGER";
+        case "boolean":
+          return "BOOLEAN";
+        case "array":
+          return "ARRAY";
+        case "object":
+          return "OBJECT";
+        default:
+          return "STRING";
+      }
+    };
+    const convert = (schema) => {
+      const result = {
+        type: convertType(schema.type)
+      };
+      if (schema.properties) {
+        result.properties = {};
+        for (const [key, value] of Object.entries(schema.properties)) {
+          result.properties[key] = convert(value);
+        }
+      }
+      if (schema.items) {
+        result.items = convert(schema.items);
+      }
+      if (schema.required) {
+        result.required = schema.required;
+      }
+      if (schema.nullable) {
+        result.nullable = schema.nullable;
+      }
+      if (schema.description) {
+        result.description = schema.description;
+      }
+      return result;
+    };
+    return convert(jsonSchema);
+  }
+  _shouldAutoParse(options) {
+    return options.autoParse !== false;
+  }
+  _safeJsonParse(content) {
+    if (!content) return null;
+    const parsed = extractJsonFromResponse(content);
+    if (!parsed) {
+      console.error("[GeminiProvider] Failed to extract valid JSON from response");
+      console.error("[GeminiProvider] Content preview:", content.substring(0, 200));
+    }
+    return parsed;
+  }
+  async executeTools(tool_calls, messages, tenantId, toolImplementations, env) {
+    const toolResults = await Promise.all(
+      tool_calls.map(async (toolCall, index) => {
+        const toolName = toolCall.function.name;
+        const tool = toolImplementations[toolName];
+        const tool_call_id = `gemini-tool-call-${index}`;
+        toolCall.id = tool_call_id;
+        if (!tool) {
+          console.error(`[Tool Error] Tool '${toolName}' not found`);
+          return { tool_call_id, output: JSON.stringify({ error: `Tool '${toolName}' not found.` }) };
+        }
+        try {
+          const output = await tool(toolCall.function.args, { env, tenantId });
+          return { tool_call_id, output };
+        } catch (error) {
+          console.error(`[Tool Error] ${toolName} failed:`, error.message);
+          return { tool_call_id, output: JSON.stringify({ error: `Error executing tool '${toolName}': ${error.message}` }) };
+        }
+      })
+    );
+    toolResults.forEach((result) => messages.push({ role: "tool", tool_call_id: result.tool_call_id, content: result.output }));
+  }
+  async imageGeneration(prompt, systemPrompt, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    const modelName = options.model || this.models.image || "gemini-3-pro-image-preview";
+    console.log(`[GeminiProvider] Generating image with model: ${modelName}`);
+    const generationConfig = {
+      responseModalities: ["IMAGE"]
+    };
+    if (options.aspectRatio) {
+      generationConfig.imageConfig = {
+        aspectRatio: options.aspectRatio
+      };
+    }
+    const parts = [{ text: prompt }];
+    if (options.images && options.images.length > 0) {
+      options.images.forEach((img) => {
+        parts.push({
+          inlineData: {
+            data: img.data,
+            mimeType: img.mimeType
+          }
+        });
+      });
+    }
+    const requestOptions = {
+      model: modelName,
+      contents: [{
+        role: "user",
+        parts
+      }],
+      config: generationConfig
+    };
+    if (systemPrompt) {
+      requestOptions.config.systemInstruction = { parts: [{ text: systemPrompt }] };
+    }
+    const response = await this.client.models.generateContent(requestOptions);
+    const imagePart = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.find(
+      (part) => {
+        var _a2;
+        return part.inlineData && ((_a2 = part.inlineData.mimeType) == null ? void 0 : _a2.startsWith("image/"));
+      }
+    );
+    if (!imagePart || !imagePart.inlineData) {
+      const textPart = (_h = (_g = (_f = (_e = response.candidates) == null ? void 0 : _e[0]) == null ? void 0 : _f.content) == null ? void 0 : _g.parts) == null ? void 0 : _h.find((p) => p.text);
+      const candidate = (_i = response.candidates) == null ? void 0 : _i[0];
+      console.error("[GeminiProvider] Image generation failed (no image data)");
+      if (candidate) {
+        console.error("[GeminiProvider] Finish Reason:", candidate.finishReason);
+        console.error("[GeminiProvider] Safety Ratings:", JSON.stringify(candidate.safetyRatings, null, 2));
+        console.error("[GeminiProvider] Full Candidate:", JSON.stringify(candidate, null, 2));
+      }
+      if (textPart) {
+        console.warn("[GeminiProvider] Model returned text instead of image:", textPart.text);
+      }
+      throw new Error(`No image data in response. Finish Reason: ${candidate == null ? void 0 : candidate.finishReason}`);
+    }
+    let thoughtSignature = null;
+    if (imagePart.thought_signature || imagePart.thoughtSignature) {
+      thoughtSignature = imagePart.thought_signature || imagePart.thoughtSignature;
+    } else {
+      const signaturePart = (_m = (_l = (_k = (_j = response.candidates) == null ? void 0 : _j[0]) == null ? void 0 : _k.content) == null ? void 0 : _l.parts) == null ? void 0 : _m.find((p) => p.thought_signature || p.thoughtSignature);
+      if (signaturePart) {
+        thoughtSignature = signaturePart.thought_signature || signaturePart.thoughtSignature;
+      }
+    }
+    if (thoughtSignature && thoughtSignature.length > 5e4) {
+      console.warn(`[GeminiProvider] \u26A0\uFE0F  Thought signature is abnormally large (${thoughtSignature.length} chars). Replacing with bypass token to save context.`);
+      thoughtSignature = "skip_thought_signature_validator";
+    }
+    return {
+      imageData: imagePart.inlineData.data,
+      mimeType: imagePart.inlineData.mimeType,
+      thought_signature: thoughtSignature
+    };
+  }
+  _getModelForTier(tier) {
+    return this.models[tier] || this.models.default;
+  }
+  async startVideoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
+    const effectivePrompt = systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt;
+    const requestConfig = {
+      model: modelName,
+      prompt: effectivePrompt,
+      config: {
+        durationSeconds: options.durationSeconds || 6,
+        aspectRatio: options.aspectRatio || "16:9",
+        numberOfVideos: 1,
+        // Pass reference images if provided
+        ...images && images.length > 0 ? { referenceImages: images } : {}
+      }
+    };
+    const logConfig = JSON.parse(JSON.stringify(requestConfig));
+    if (logConfig.config && logConfig.config.referenceImages) {
+      logConfig.config.referenceImages = logConfig.config.referenceImages.map((img) => ({
+        ...img,
+        data: `... (${img.data ? img.data.length : 0} bytes)`
+        // Summarize data
+      }));
+    }
+    console.log("[GeminiProvider] startVideoGeneration request:", JSON.stringify(logConfig, null, 2));
+    try {
+      const operation = await this.client.models.generateVideos(requestConfig);
+      this._pendingOperations.set(operation.name, operation);
+      return { operationName: operation.name };
+    } catch (error) {
+      console.error(`[GeminiProvider] startVideoGeneration failed (API Key: ${this._getMaskedApiKey()}):`, error);
+      throw error;
+    }
+  }
+  async getVideoGenerationStatus(operationName) {
+    var _a, _b, _c, _d, _e, _f;
+    console.log(`[GeminiProvider] Checking status for operation: ${operationName}`);
+    let operation = this._pendingOperations.get(operationName);
+    if (!operation) {
+      operation = await this.client.models.getOperation(operationName);
+    }
+    operation = await operation.get();
+    this._pendingOperations.set(operationName, operation);
+    const result = {
+      done: operation.done,
+      progress: ((_a = operation.metadata) == null ? void 0 : _a.progressPercent) || 0,
+      state: ((_b = operation.metadata) == null ? void 0 : _b.state) || (operation.done ? "COMPLETED" : "PROCESSING")
+    };
+    console.log(`[GeminiProvider] Operation status: ${result.state}, Progress: ${result.progress}%`);
+    if (operation.done) {
+      this._pendingOperations.delete(operationName);
+      if (operation.error) {
+        console.error("[GeminiProvider] Video generation failed:", JSON.stringify(operation.error, null, 2));
+        result.error = operation.error;
+      } else {
+        const videoResult = operation.response;
+        result.videoUri = ((_d = (_c = videoResult.videos) == null ? void 0 : _c[0]) == null ? void 0 : _d.gcsUri) || videoResult.uri || ((_f = (_e = videoResult.generatedAssets) == null ? void 0 : _e[0]) == null ? void 0 : _f.uri);
+        result.content = "Video generation completed.";
+      }
+    }
+    return result;
+  }
+  async startDeepResearch(prompt, options = {}) {
+    const agent = options.agent || "deep-research-pro-preview-12-2025";
+    console.log(`[GeminiProvider] Starting Deep Research with agent: ${agent}`);
+    try {
+      const interaction = await this.client.interactions.create({
+        agent,
+        input: prompt,
+        background: true,
+        // Required for long running
+        store: true
+        // Required for polling
+      });
+      console.log(`[GeminiProvider] Deep Research started. Interaction ID: ${interaction.id}`);
+      return { operationId: interaction.id };
+    } catch (error) {
+      console.error(`[GeminiProvider] startDeepResearch failed:`, error);
+      throw error;
+    }
+  }
+  async getDeepResearchStatus(operationId) {
+    try {
+      const result = await this.client.interactions.get(operationId);
+      const state = result.state;
+      const response = {
+        state,
+        done: state === "completed" || state === "failed",
+        error: state === "failed" ? result.error : null
+      };
+      if (state === "completed") {
+        response.content = result.output;
+        response.citations = result.grounding_metadata;
+      }
+      return response;
+    } catch (error) {
+      console.error(`[GeminiProvider] getDeepResearchStatus failed for ${operationId}:`, error);
+      throw error;
+    }
+  }
+};
+
+// src/llm-service.js
+var LLMService = class {
+  constructor(env, toolImplementations = {}) {
+    this.env = env;
+    this.toolImplementations = toolImplementations;
+    this.providerCache = /* @__PURE__ */ new Map();
+  }
+  async _getProvider(tenantId) {
+    const cacheKey = tenantId || "system";
+    if (this.providerCache.has(cacheKey)) {
+      return this.providerCache.get(cacheKey);
+    }
+    const config = await ConfigManager.getConfig(tenantId, this.env);
+    if (!config.apiKey) {
+      throw new LLMServiceException(`LLM service is not configured for ${config.provider}. Missing API Key.`, 500);
+    }
+    let provider;
+    if (config.provider === "openai") {
+      provider = new OpenAIProvider(config);
+    } else if (config.provider === "gemini") {
+      provider = new GeminiProvider(config);
+    } else {
+      throw new LLMServiceException(`Unsupported LLM provider: ${config.provider}`, 500);
+    }
+    this.providerCache.set(cacheKey, provider);
+    return provider;
+  }
+  /**
+   * Check if LLM service is configured for a tenant (or system default)
+   */
+  async isConfigured(tenantId) {
+    const config = await ConfigManager.getConfig(tenantId, this.env);
+    return !!config.apiKey;
+  }
+  /**
+   * Simple chat interface for single-turn conversations
+   */
+  async chat(userMessage, tenantId, systemPrompt = "", options = {}) {
+    const provider = await this._getProvider(tenantId);
+    return provider.chat(userMessage, systemPrompt, options);
+  }
+  /**
+   * Interact with LLM for generation
+   * 
+   * Intelligent signature detection supports:
+   * - chatCompletion(messages, tenantId, systemPrompt)
+   * - chatCompletion(messages, tenantId, systemPrompt, tools)
+   * - chatCompletion(messages, tenantId, systemPrompt, options)
+   * - chatCompletion(messages, tenantId, systemPrompt, tools, options)
+   * 
+   * @param {Array} messages - Conversation messages
+   * @param {string} tenantId - Tenant identifier
+   * @param {string} systemPrompt - System instructions
+   * @param {Array|Object} toolsOrOptions - Tools array or options object
+   * @param {Object} optionsParam - Options object (if tools provided)
+   * @returns {Object} Response with content, tool_calls, and optionally parsedContent
+   */
+  async chatCompletion(messages, tenantId, systemPrompt, toolsOrOptions = null, optionsParam = {}) {
+    const provider = await this._getProvider(tenantId);
+    if (!(systemPrompt == null ? void 0 : systemPrompt.trim())) {
+      throw new LLMServiceException("No prompt set for bot", 503);
+    }
+    const { tools, options } = this._parseToolsAndOptions(toolsOrOptions, optionsParam);
+    return provider.chatCompletion(messages, systemPrompt, tools, options);
+  }
+  /**
+   * Helper to intelligently detect tools vs options parameters
+   * @private
+   */
+  _parseToolsAndOptions(param1, param2) {
+    if (param1 === null || param1 === void 0) {
+      return { tools: null, options: param2 || {} };
+    }
+    if (Array.isArray(param1)) {
+      return { tools: param1, options: param2 || {} };
+    }
+    if (typeof param1 === "object") {
+      const optionsKeys = ["responseFormat", "responseSchema", "temperature", "maxTokens", "tier", "autoParse", "strictSchema", "schemaName"];
+      const hasOptionsKeys = optionsKeys.some((key) => key in param1);
+      if (hasOptionsKeys) {
+        return { tools: null, options: param1 };
+      }
+      return { tools: param1, options: param2 || {} };
+    }
+    return { tools: param1, options: param2 || {} };
+  }
+  /**
+   * Convenience method for JSON-only responses
+   * Automatically enables JSON mode and returns parsed object
+   * 
+   * @param {Array} messages - Conversation messages
+   * @param {string} tenantId - Tenant identifier
+   * @param {string} systemPrompt - System instructions
+   * @param {Object} schema - Optional JSON schema for validation
+   * @param {Array} tools - Optional tools array
+   * @returns {Object} Parsed JSON object
+   * @throws {LLMServiceException} If JSON parsing fails
+   */
+  async chatCompletionJson(messages, tenantId, systemPrompt, schema = null, tools = null) {
+    const options = {
+      responseFormat: schema ? { type: "json_schema", schema } : "json",
+      autoParse: true
+    };
+    const response = await this.chatCompletion(messages, tenantId, systemPrompt, tools, options);
+    if (response.parsedContent !== null && response.parsedContent !== void 0) {
+      return response.parsedContent;
+    }
+    try {
+      return JSON.parse(response.content);
+    } catch (e) {
+      throw new LLMServiceException(
+        "LLM returned invalid JSON despite JSON mode being enabled",
+        500,
+        { rawContent: response.content, parseError: e.message }
+      );
+    }
+  }
+  async chatWithTools(messages, tenantId, systemPrompt, tools = [], options = {}) {
+    const provider = await this._getProvider(tenantId);
+    let currentMessages = [...messages];
+    const MAX_ITERATIONS = 10;
+    let iteration = 0;
+    const initialResponse = await provider.chatCompletion(
+      currentMessages,
+      systemPrompt,
+      tools,
+      options
+    );
+    let { content, tool_calls, parsedContent, finishReason, _rawFinishReason } = initialResponse;
+    while (tool_calls && iteration < MAX_ITERATIONS) {
+      iteration++;
+      console.log(`[Tool Call] Iteration ${iteration}/${MAX_ITERATIONS} with finish reason ${finishReason}: Assistant wants to use tools:`, tool_calls);
+      currentMessages.push({ role: "assistant", content: content || "", tool_calls });
+      await provider.executeTools(tool_calls, currentMessages, tenantId, this.toolImplementations, this.env);
+      const nextResponse = await provider.chatCompletion(
+        currentMessages,
+        systemPrompt,
+        tools,
+        options
+      );
+      content = nextResponse.content;
+      tool_calls = nextResponse.tool_calls;
+      parsedContent = nextResponse.parsedContent;
+      finishReason = nextResponse.finishReason;
+      _rawFinishReason = nextResponse._rawFinishReason;
+    }
+    if (iteration >= MAX_ITERATIONS) {
+      console.warn(`[Tool Call] Reached maximum iterations (${MAX_ITERATIONS}). Forcing completion.`);
+    }
+    return { content, parsedContent, toolCalls: tool_calls, finishReason, _rawFinishReason };
+  }
+  /**
+   * Generate a video (async wrapper with polling - backward compatibility)
+   */
+  async videoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
+    const { operationName } = await this.startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options);
+    let status = await this.getVideoGenerationStatus(operationName, tenantId);
+    while (!status.done) {
+      console.log(`Waiting for video generation... Progress: ${status.progress}%`);
+      await new Promise((resolve) => setTimeout(resolve, 1e4));
+      status = await this.getVideoGenerationStatus(operationName, tenantId);
+    }
+    if (status.error) {
+      throw new Error(`Video generation failed: ${status.error.message || JSON.stringify(status.error)}`);
+    }
+    return {
+      content: status.content || "Video generation completed.",
+      videoUri: status.videoUri
+    };
+  }
+  /**
+   * Start video generation (returns operation name for polling)
+   */
+  async startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
+    const provider = await this._getProvider(tenantId);
+    return provider.startVideoGeneration(prompt, images, modelName, systemPrompt, options);
+  }
+  /**
+   * Get video generation status
+   */
+  async getVideoGenerationStatus(operationName, tenantId) {
+    const provider = await this._getProvider(tenantId);
+    return provider.getVideoGenerationStatus(operationName);
+  }
+  /**
+   * Generate an image
+   * Falls back to system keys if tenant doesn't have image capability enabled
+   * @param {string} prompt - Text description of the image
+   * @param {string} tenantId - Tenant identifier
+   * @param {string} systemPrompt - System instructions for generation
+   * @param {Object} options - Generation options (aspectRatio, images, etc.)
+   */
+  async imageGeneration(prompt, tenantId, systemPrompt, options = {}) {
+    var _a;
+    if (tenantId) {
+      const config = await ConfigManager.getConfig(tenantId, this.env);
+      if (config.isTenantOwned && !((_a = config.capabilities) == null ? void 0 : _a.image)) {
+        console.log(`[LLMService] Tenant ${tenantId} BYOK doesn't have image capability. Using system keys.`);
+        tenantId = null;
+      }
+    }
+    const provider = await this._getProvider(tenantId);
+    return provider.imageGeneration(prompt, systemPrompt, options);
+  }
+  /**
+   * Start a Deep Research task
+   * @param {string} prompt - Research prompt/query
+   * @param {string} tenantId - Tenant identifier
+   * @param {Object} options - Options (agentId, etc.)
+   * @returns {Promise<{operationId: string}>}
+   */
+  async startDeepResearch(prompt, tenantId, options = {}) {
+    const provider = await this._getProvider(tenantId);
+    return provider.startDeepResearch(prompt, options);
+  }
+  /**
+   * Get status of a Deep Research task
+   * @param {string} operationId - ID returned from startDeepResearch
+   * @param {string} tenantId - Tenant identifier
+   * @returns {Promise<{state: string, content?: string, citations?: any[]}>}
+   */
+  async getDeepResearchStatus(operationId, tenantId) {
+    const provider = await this._getProvider(tenantId);
+    return provider.getDeepResearchStatus(operationId);
+  }
+};
+var LLMServiceException = class extends Error {
+  constructor(message, statusCode = 500, details = null) {
+    super(message);
+    this.name = "LLMServiceException";
+    this.statusCode = statusCode;
+    this.details = details || {};
+  }
+};
+
+// src/utils/error-handler.js
+function handleApiError(error, operation = "complete this operation", context = "api") {
+  var _a;
+  console.error(`[${context}] Error:`, error);
+  const errorMessage = ((_a = error.message) == null ? void 0 : _a.toLowerCase()) || "";
+  const errorString = JSON.stringify(error).toLowerCase();
+  if (errorMessage.includes("overloaded") || errorMessage.includes("503") || errorString.includes("unavailable") || errorString.includes("overloaded")) {
+    return {
+      message: "AI service is busy. Please try again.",
+      error: "service_overloaded",
+      retryable: true,
+      statusCode: 503
+    };
+  }
+  if (errorMessage.includes("quota") || errorMessage.includes("429") || errorMessage.includes("too many requests") || errorMessage.includes("rate limit") || errorString.includes("resource_exhausted")) {
+    return {
+      message: "Too many requests. Please try again later.",
+      error: "rate_limited",
+      retryable: true,
+      statusCode: 429
+    };
+  }
+  if (errorMessage.includes("context length") || errorMessage.includes("too long") || errorString.includes("invalid_argument")) {
+    return {
+      message: "Content too big. Try making focused edits.",
+      error: "input_too_long",
+      retryable: false,
+      statusCode: 422
+    };
+  }
+  if (errorMessage.includes("quotaerror") || errorMessage.includes("quota_exceeded")) {
+    return {
+      message: "You have reached your usage limit for this month. Please upgrade your plan to continue.",
+      error: "user_quota_exceeded",
+      retryable: false,
+      statusCode: 402
+    };
+  }
+  if (errorMessage.includes("trial")) {
+    return {
+      message: "This feature is not available during the free trial. Please upgrade to use this feature.",
+      error: "trial_limitation",
+      retryable: false,
+      statusCode: 402
+    };
+  }
+  if (errorMessage.includes("api key") || errorMessage.includes("authentication") || errorMessage.includes("unauthorized")) {
+    return {
+      message: "Service is not available at this time. Please contact support.",
+      error: "not_configured",
+      retryable: false,
+      statusCode: 503
+    };
+  }
+  if (errorMessage.includes("invalid") || errorMessage.includes("bad request")) {
+    return {
+      message: "Invalid request. Please check your input and try again.",
+      error: "invalid_input",
+      retryable: false,
+      statusCode: 400
+    };
+  }
+  return {
+    message: `An error occurred while trying to ${operation}. Please try again.`,
+    error: "operation_failed",
+    retryable: true,
+    statusCode: 500
+  };
+}
+function sanitizeError(error, context = "general") {
+  const result = handleApiError(error, "complete this operation", context);
+  return new Error(result.error);
+}
+
+// src/transcription-service.js
+import OpenAI2 from "openai";
+var TranscriptionService = class {
+  /**
+   * @param {Object} config
+   * @param {string} config.provider - 'openai' | 'generic'
+   * @param {string} config.apiKey - API key for the provider
+   * @param {string} [config.endpoint] - Custom endpoint URL (required for 'generic')
+   * @param {string} [config.model] - Model to use (default: 'whisper-1')
+   */
+  constructor(config) {
+    this.provider = config.provider || "openai";
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint;
+    this.model = config.model || "whisper-1";
+    if (this.provider === "openai") {
+      this.client = new OpenAI2({ apiKey: this.apiKey });
+    }
+  }
+  /**
+   * Transcribe audio to text
+   * @param {File|Blob} audioFile - Audio file to transcribe
+   * @param {Object} options - Transcription options
+   * @param {string} [options.language] - Language hint (ISO-639-1 code)
+   * @param {string} [options.model] - Override default model
+   * @returns {Promise<{text: string}>}
+   */
+  async transcribe(audioFile, options = {}) {
+    const model = options.model || this.model;
+    const language = options.language;
+    if (this.provider === "openai") {
+      return this._transcribeOpenAI(audioFile, model, language);
+    } else if (this.provider === "generic") {
+      return this._transcribeGeneric(audioFile, model, language);
+    } else {
+      throw new TranscriptionServiceException(
+        `Unsupported transcription provider: ${this.provider}`,
+        400
+      );
+    }
+  }
+  async _transcribeOpenAI(audioFile, model, language) {
+    try {
+      const response = await this.client.audio.transcriptions.create({
+        file: audioFile,
+        model,
+        language
+      });
+      return { text: response.text };
+    } catch (error) {
+      console.error("[TranscriptionService] OpenAI transcription failed:", error);
+      throw new TranscriptionServiceException(
+        `Transcription failed: ${error.message}`,
+        500
+      );
+    }
+  }
+  async _transcribeGeneric(audioFile, model, language) {
+    if (!this.endpoint) {
+      throw new TranscriptionServiceException(
+        "Endpoint is required for generic transcription provider",
+        400
+      );
+    }
+    try {
+      const formData = new FormData();
+      formData.append("file", audioFile);
+      formData.append("model", model);
+      if (language) {
+        formData.append("language", language);
+      }
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
+      }
+      const result = await response.json();
+      return { text: result.text };
+    } catch (error) {
+      console.error("[TranscriptionService] Generic transcription failed:", error);
+      throw new TranscriptionServiceException(
+        `Transcription failed: ${error.message}`,
+        500
+      );
+    }
+  }
+};
+var TranscriptionServiceException = class extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.name = "TranscriptionServiceException";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/handlers/speech-handler.js
+function createSpeechHandler(app, getConfig) {
+  app.post("/transcribe", async (c) => {
+    try {
+      const config = await getConfig(c);
+      if (!config || !config.apiKey) {
+        return c.json({ error: "Transcription service not configured" }, 503);
+      }
+      const formData = await c.req.formData();
+      const audioFile = formData.get("audio");
+      if (!audioFile) {
+        return c.json({ error: "No audio file provided" }, 400);
+      }
+      const language = formData.get("language") || void 0;
+      const service = new TranscriptionService(config);
+      const result = await service.transcribe(audioFile, { language });
+      return c.json(result);
+    } catch (error) {
+      console.error("[SpeechHandler] Transcription error:", error);
+      const statusCode = error.statusCode || 500;
+      return c.json({ error: error.message }, statusCode);
+    }
+  });
+  return app;
+}
+export {
+  BaseConfigProvider,
+  ConfigManager,
+  DefaultConfigProvider,
+  FINISH_REASONS,
+  GeminiProvider,
+  LLMService,
+  LLMServiceException,
+  MODEL_CONFIGS,
+  OpenAIProvider,
+  TranscriptionService,
+  TranscriptionServiceException,
+  createSpeechHandler,
+  extractJsonFromResponse,
+  extractTextAndJson,
+  handleApiError,
+  sanitizeError
+};
+//# sourceMappingURL=index.js.map