@startsimpli/llm 0.1.1

package/dist/index.js

@@ -0,0 +1,851 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/errors.ts
+var LLMProviderError = class extends Error {
+  constructor(message, code, retryable = false, statusCode, provider) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.statusCode = statusCode;
+    this.provider = provider;
+    this.name = "LLMProviderError";
+  }
+};
+
+// src/types.ts
+var LLM_DEFAULTS = {
+  openaiModel: "gpt-4o-mini",
+  anthropicModel: "claude-sonnet-4-20250514",
+  /**
+   * Default sampling temperature.
+   * Note: base gpt-5 models (gpt-5, gpt-5.1, gpt-5.2) require temperature=1.0
+   * and the OpenAI provider enforces this automatically.
+   */
+  temperature: 0.7,
+  maxTokens: 8192,
+  timeoutMs: 6e4
+};
+
+// src/providers/openai.ts
+var OPENAI_MODELS = [
+  "gpt-5.2",
+  "gpt-5.1",
+  "gpt-5",
+  "gpt-4o",
+  "gpt-4o-mini"
+];
+var MODEL_COSTS = {
+  "gpt-5.2": { input: 5e-3, output: 0.015 },
+  "gpt-5.1": { input: 5e-3, output: 0.015 },
+  "gpt-5": { input: 5e-3, output: 0.015 },
+  "gpt-4o": { input: 25e-4, output: 0.01 },
+  "gpt-4o-mini": { input: 15e-5, output: 6e-4 }
+};
+var DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+  model: LLM_DEFAULTS.openaiModel,
+  temperature: LLM_DEFAULTS.temperature,
+  maxTokens: LLM_DEFAULTS.maxTokens,
+  timeoutMs: LLM_DEFAULTS.timeoutMs
+};
+var OpenAIProvider = class {
+  constructor(config) {
+    this.name = "openai";
+    this.availableModels = OPENAI_MODELS;
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULTS.baseUrl,
+      defaultModel: config.defaultModel ?? DEFAULTS.model,
+      defaultTemperature: config.defaultTemperature ?? DEFAULTS.temperature,
+      defaultMaxTokens: config.defaultMaxTokens ?? DEFAULTS.maxTokens,
+      timeoutMs: config.timeoutMs ?? DEFAULTS.timeoutMs
+    };
+    this.defaultModel = this.config.defaultModel;
+  }
+  isAvailable() {
+    return Boolean(this.config.apiKey);
+  }
+  async generate(userPrompt, systemPrompt, options) {
+    if (!this.isAvailable()) {
+      throw new LLMProviderError(
+        "OpenAI API key not configured",
+        "AUTHENTICATION_ERROR",
+        false,
+        void 0,
+        this.name
+      );
+    }
+    const model = options?.model ?? this.config.defaultModel;
+    const isBaseGpt5 = model === "gpt-5" || model === "gpt-5.1" || model === "gpt-5.2";
+    const isFineTuned = model.startsWith("ft:");
+    const temperature = isBaseGpt5 && !isFineTuned ? 1 : options?.temperature ?? this.config.defaultTemperature;
+    const maxTokens = options?.maxTokens ?? this.config.defaultMaxTokens;
+    const timeout = options?.timeout ?? this.config.timeoutMs;
+    const requestBody = {
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      temperature,
+      max_tokens: maxTokens,
+      response_format: { type: "json_object" }
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({
+          error: { message: "Unknown error" }
+        }));
+        throw this.handleApiError(response.status, errorData);
+      }
+      const data = await response.json();
+      if (!data.choices?.[0]?.message?.content) {
+        throw new LLMProviderError(
+          "Empty response from OpenAI",
+          "UNKNOWN_ERROR",
+          true,
+          void 0,
+          this.name
+        );
+      }
+      return {
+        content: data.choices[0].message.content,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        },
+        model: data.model,
+        responseId: data.id,
+        finishReason: data.choices[0].finish_reason
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof LLMProviderError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new LLMProviderError(
+          `Request timed out after ${timeout}ms`,
+          "TIMEOUT",
+          true,
+          void 0,
+          this.name
+        );
+      }
+      throw new LLMProviderError(
+        `OpenAI request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "UNKNOWN_ERROR",
+        true,
+        void 0,
+        this.name
+      );
+    }
+  }
+  estimateCost(promptTokens, completionTokens, model) {
+    const costs = MODEL_COSTS[model ?? this.config.defaultModel];
+    if (!costs) return void 0;
+    return promptTokens / 1e3 * costs.input + completionTokens / 1e3 * costs.output;
+  }
+  handleApiError(statusCode, errorResponse) {
+    const message = errorResponse.error?.message ?? "Unknown OpenAI error";
+    const errorType = errorResponse.error?.type ?? "";
+    const errorCode = errorResponse.error?.code ?? "";
+    let code;
+    let retryable = false;
+    if (statusCode === 401) {
+      code = "AUTHENTICATION_ERROR";
+    } else if (statusCode === 429) {
+      code = "RATE_LIMITED";
+      retryable = true;
+    } else if (statusCode === 400) {
+      if (errorCode === "context_length_exceeded") {
+        code = "CONTEXT_LENGTH_EXCEEDED";
+      } else if (errorType === "invalid_request_error") {
+        code = "INVALID_REQUEST";
+      } else {
+        code = "UNKNOWN_ERROR";
+      }
+    } else if (statusCode === 403) {
+      code = errorCode === "content_filter" ? "CONTENT_FILTERED" : "AUTHENTICATION_ERROR";
+    } else if (statusCode >= 500) {
+      code = "SERVICE_UNAVAILABLE";
+      retryable = true;
+    } else {
+      code = "UNKNOWN_ERROR";
+    }
+    return new LLMProviderError(message, code, retryable, statusCode, this.name);
+  }
+};
+function createOpenAIProvider() {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) return null;
+  return new OpenAIProvider({
+    apiKey,
+    baseUrl: process.env.OPENAI_BASE_URL,
+    defaultModel: process.env.OPENAI_MODEL
+  });
+}
+
+// src/providers/anthropic.ts
+var ANTHROPIC_MODELS = [
+  "claude-opus-4-6",
+  "claude-opus-4-20250514",
+  "claude-sonnet-4-6",
+  "claude-sonnet-4-20250514",
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-haiku-20241022",
+  "claude-3-opus-20240229",
+  "claude-3-sonnet-20240229",
+  "claude-3-haiku-20240307"
+];
+var MODEL_COSTS2 = {
+  "claude-opus-4-6": { input: 0.015, output: 0.075 },
+  "claude-opus-4-20250514": { input: 0.015, output: 0.075 },
+  "claude-sonnet-4-6": { input: 3e-3, output: 0.015 },
+  "claude-sonnet-4-20250514": { input: 3e-3, output: 0.015 },
+  "claude-3-5-sonnet-20241022": { input: 3e-3, output: 0.015 },
+  "claude-3-5-haiku-20241022": { input: 8e-4, output: 4e-3 },
+  "claude-3-opus-20240229": { input: 0.015, output: 0.075 },
+  "claude-3-sonnet-20240229": { input: 3e-3, output: 0.015 },
+  "claude-3-haiku-20240307": { input: 25e-5, output: 125e-5 }
+};
+var DEFAULTS2 = {
+  baseUrl: "https://api.anthropic.com/v1",
+  model: LLM_DEFAULTS.anthropicModel,
+  temperature: LLM_DEFAULTS.temperature,
+  maxTokens: LLM_DEFAULTS.maxTokens,
+  timeoutMs: LLM_DEFAULTS.timeoutMs,
+  apiVersion: "2023-06-01"
+};
+var AnthropicProvider = class {
+  constructor(config, apiVersion) {
+    this.name = "anthropic";
+    this.availableModels = ANTHROPIC_MODELS;
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULTS2.baseUrl,
+      defaultModel: config.defaultModel ?? DEFAULTS2.model,
+      defaultTemperature: config.defaultTemperature ?? DEFAULTS2.temperature,
+      defaultMaxTokens: config.defaultMaxTokens ?? DEFAULTS2.maxTokens,
+      timeoutMs: config.timeoutMs ?? DEFAULTS2.timeoutMs
+    };
+    this.defaultModel = this.config.defaultModel;
+    this.apiVersion = apiVersion ?? DEFAULTS2.apiVersion;
+  }
+  isAvailable() {
+    return Boolean(this.config.apiKey);
+  }
+  async generate(userPrompt, systemPrompt, options) {
+    if (!this.isAvailable()) {
+      throw new LLMProviderError(
+        "Anthropic API key not configured",
+        "AUTHENTICATION_ERROR",
+        false,
+        void 0,
+        this.name
+      );
+    }
+    const model = options?.model ?? this.config.defaultModel;
+    const temperature = options?.temperature ?? this.config.defaultTemperature;
+    const maxTokens = options?.maxTokens ?? this.config.defaultMaxTokens;
+    const timeout = options?.timeout ?? this.config.timeoutMs;
+    const jsonWrappedPrompt = `${userPrompt}
+
+Please respond with a valid JSON object only. Do not include any text before or after the JSON.`;
+    const requestBody = {
+      model,
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: jsonWrappedPrompt }],
+      system: systemPrompt,
+      temperature
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(`${this.config.baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": this.apiVersion
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({
+          error: { type: "unknown", message: "Unknown error" }
+        }));
+        throw this.handleApiError(response.status, errorData);
+      }
+      const data = await response.json();
+      const textContent = data.content.find((c) => c.type === "text");
+      if (!textContent?.text) {
+        throw new LLMProviderError(
+          "Empty response from Anthropic",
+          "UNKNOWN_ERROR",
+          true,
+          void 0,
+          this.name
+        );
+      }
+      return {
+        content: textContent.text,
+        usage: {
+          promptTokens: data.usage.input_tokens,
+          completionTokens: data.usage.output_tokens,
+          totalTokens: data.usage.input_tokens + data.usage.output_tokens
+        },
+        model: data.model,
+        responseId: data.id,
+        finishReason: data.stop_reason ?? void 0
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof LLMProviderError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new LLMProviderError(
+          `Request timed out after ${timeout}ms`,
+          "TIMEOUT",
+          true,
+          void 0,
+          this.name
+        );
+      }
+      throw new LLMProviderError(
+        `Anthropic request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "UNKNOWN_ERROR",
+        true,
+        void 0,
+        this.name
+      );
+    }
+  }
+  estimateCost(promptTokens, completionTokens, model) {
+    const costs = MODEL_COSTS2[model ?? this.config.defaultModel];
+    if (!costs) return void 0;
+    return promptTokens / 1e3 * costs.input + completionTokens / 1e3 * costs.output;
+  }
+  handleApiError(statusCode, errorResponse) {
+    const message = errorResponse.error?.message ?? "Unknown Anthropic error";
+    const errorType = errorResponse.error?.type ?? "";
+    let code;
+    let retryable = false;
+    if (statusCode === 401) {
+      code = "AUTHENTICATION_ERROR";
+    } else if (statusCode === 429) {
+      code = "RATE_LIMITED";
+      retryable = true;
+    } else if (statusCode === 400) {
+      if (errorType === "invalid_request_error") {
+        code = message.includes("token") || message.includes("length") ? "CONTEXT_LENGTH_EXCEEDED" : "INVALID_REQUEST";
+      } else {
+        code = "UNKNOWN_ERROR";
+      }
+    } else if (statusCode === 403) {
+      code = "AUTHENTICATION_ERROR";
+    } else if (statusCode === 529 || statusCode >= 500) {
+      code = "SERVICE_UNAVAILABLE";
+      retryable = true;
+    } else {
+      code = "UNKNOWN_ERROR";
+    }
+    return new LLMProviderError(message, code, retryable, statusCode, this.name);
+  }
+};
+function createAnthropicProvider() {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return null;
+  return new AnthropicProvider({
+    apiKey,
+    baseUrl: process.env.ANTHROPIC_BASE_URL,
+    defaultModel: process.env.ANTHROPIC_MODEL
+  });
+}
+
+// src/providers/mock.ts
+var mockBehavior = {};
+function setMockBehavior(behavior) {
+  mockBehavior = behavior;
+}
+function resetMockBehavior() {
+  mockBehavior = {};
+}
+function getDefaultResponse() {
+  return JSON.stringify({ mock: true, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function getInvalidResponse() {
+  return JSON.stringify({ incomplete: true });
+}
+var MockLLMProvider = class {
+  constructor() {
+    this.name = "mock";
+    this.availableModels = ["mock-model-1", "mock-model-2"];
+    this.defaultModel = "mock-model-1";
+    this.callCount = 0;
+  }
+  async generate(_userPrompt, _systemPrompt, _options) {
+    this.callCount++;
+    if (mockBehavior.error) {
+      throw new LLMProviderError(
+        mockBehavior.error.message,
+        mockBehavior.error.code,
+        mockBehavior.error.code === "RATE_LIMITED",
+        mockBehavior.error.code === "RATE_LIMITED" ? 429 : 503,
+        "mock"
+      );
+    }
+    if (mockBehavior.delay) {
+      await new Promise((resolve) => setTimeout(resolve, mockBehavior.delay));
+    }
+    if (mockBehavior.customResponse) {
+      return {
+        content: mockBehavior.customResponse,
+        usage: { promptTokens: 100, completionTokens: 500, totalTokens: 600 },
+        model: this.defaultModel,
+        responseId: `mock-${this.callCount}`,
+        finishReason: "stop"
+      };
+    }
+    if (mockBehavior.returnInvalidJson) {
+      return {
+        content: getInvalidResponse(),
+        usage: { promptTokens: 100, completionTokens: 200, totalTokens: 300 },
+        model: this.defaultModel,
+        responseId: `mock-${this.callCount}`,
+        finishReason: "stop"
+      };
+    }
+    return {
+      content: getDefaultResponse(),
+      usage: { promptTokens: 150, completionTokens: 800, totalTokens: 950 },
+      model: this.defaultModel,
+      responseId: `mock-${this.callCount}`,
+      finishReason: "stop"
+    };
+  }
+  isAvailable() {
+    return true;
+  }
+  estimateCost(promptTokens, completionTokens, _model) {
+    return (promptTokens + completionTokens) * 1e-5;
+  }
+  getCallCount() {
+    return this.callCount;
+  }
+  resetCallCount() {
+    this.callCount = 0;
+  }
+};
+
+// src/utils/json-extraction.ts
+function extractJson(content) {
+  const trimmed = content.trim();
+  try {
+    const json = JSON.parse(trimmed);
+    return { success: true, json, raw: trimmed };
+  } catch {
+  }
+  const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    try {
+      const json = JSON.parse(codeBlockMatch[1].trim());
+      return { success: true, json, raw: codeBlockMatch[1].trim() };
+    } catch (e) {
+      return {
+        success: false,
+        error: `JSON in code block is invalid: ${e instanceof Error ? e.message : "Parse error"}`,
+        raw: trimmed
+      };
+    }
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    const jsonCandidate = trimmed.slice(firstBrace, lastBrace + 1);
+    try {
+      const json = JSON.parse(jsonCandidate);
+      return { success: true, json, raw: jsonCandidate };
+    } catch (e) {
+      return {
+        success: false,
+        error: `Found JSON-like content but it's invalid: ${e instanceof Error ? e.message : "Parse error"}`,
+        raw: trimmed
+      };
+    }
+  }
+  return {
+    success: false,
+    error: "No valid JSON object found in response",
+    raw: trimmed
+  };
+}
+
+// src/utils/http-status.ts
+function llmErrorToHttpStatus(code) {
+  switch (code) {
+    case "RATE_LIMITED":
+      return 429;
+    case "CONTENT_FILTERED":
+    case "INVALID_REQUEST":
+      return 400;
+    case "AUTHENTICATION_ERROR":
+    case "SERVICE_UNAVAILABLE":
+      return 503;
+    case "TIMEOUT":
+      return 504;
+    case "CONTEXT_LENGTH_EXCEEDED":
+      return 422;
+    default:
+      return 500;
+  }
+}
+
+// src/utils/retry.ts
+function buildSchemaErrorCorrectionPrompt(previousResponse, zodError) {
+  const errorDetails = zodError.errors.map((e) => {
+    const path = e.path.length > 0 ? e.path.join(".") : "root";
+    return `- Path "${path}": ${e.message}`;
+  }).join("\n");
+  return `Your previous response contained JSON that did not conform to the required schema.
+
+## Previous Response
+
+\`\`\`json
+${previousResponse}
+\`\`\`
+
+## Validation Errors
+
+The following schema validation errors were found:
+
+${errorDetails}
+
+## Instructions
+
+Please generate a corrected JSON response that:
+1. Fixes ALL the validation errors listed above
+2. Maintains the same content and intent
+3. Follows the exact schema structure required
+4. Contains ONLY valid JSON with no text before or after
+
+Common fixes needed:
+- Ensure all required fields are present
+- Check that enum values match the schema exactly
+- Verify number fields contain numbers, not strings
+- Ensure arrays are not empty where minimum length is 1
+- Check that nested objects have all required properties
+
+Respond with ONLY the corrected JSON object.`;
+}
+function buildParseErrorCorrectionPrompt(previousResponse, parseError) {
+  const truncatedResponse = previousResponse.length > 2e3 ? previousResponse.slice(0, 2e3) + "\n... [truncated]" : previousResponse;
+  return `Your previous response could not be parsed as valid JSON.
+
+## Previous Response (excerpt)
+
+\`\`\`
+${truncatedResponse}
+\`\`\`
+
+## Parse Error
+
+${parseError}
+
+## Instructions
+
+Please generate a valid JSON response that:
+1. Contains ONLY the JSON object - no markdown, no explanations
+2. Does not wrap the JSON in code blocks
+3. Uses proper JSON syntax (double quotes for strings, no trailing commas)
+4. Properly escapes any special characters in strings
+
+Common JSON issues:
+- Using single quotes instead of double quotes
+- Trailing commas after the last item in arrays/objects
+- Unescaped special characters in strings (\\n, \\t, \\", etc.)
+- Missing commas between object properties
+- Extra text before or after the JSON
+
+Respond with ONLY the corrected JSON object.`;
+}
+function buildGenericRetryPrompt(originalPrompt, attemptNumber) {
+  return `The previous attempt to generate a response encountered issues. This is attempt ${attemptNumber}.
+
+## Original Request
+
+${originalPrompt}
+
+## Instructions
+
+Please generate a fresh response that:
+1. Follows the exact JSON schema structure
+2. Contains only valid, parseable JSON
+3. Includes all required fields
+4. Has accurate data throughout
+
+Focus on generating a complete, valid response rather than a complex one. A simpler response that is fully valid is better than a complex one with errors.
+
+Respond with ONLY the JSON object.`;
+}
+var DEFAULT_CONFIG = {
+  maxRetries: 2,
+  preferredProvider: "openai",
+  defaultModel: "",
+  defaultTemperature: LLM_DEFAULTS.temperature,
+  defaultMaxTokens: LLM_DEFAULTS.maxTokens
+};
+var LLMService = class {
+  constructor(config) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.initializeProviders();
+  }
+  initializeProviders() {
+    if (process.env.LLM_PROVIDER === "mock") {
+      this.providers.set("mock", new MockLLMProvider());
+      return;
+    }
+    const openai = createOpenAIProvider();
+    if (openai) this.providers.set("openai", openai);
+    const anthropic = createAnthropicProvider();
+    if (anthropic) this.providers.set("anthropic", anthropic);
+  }
+  getProvider() {
+    const preferred = this.providers.get(this.config.preferredProvider);
+    if (preferred?.isAvailable()) return preferred;
+    for (const provider of this.providers.values()) {
+      if (provider.isAvailable()) return provider;
+    }
+    throw new LLMProviderError(
+      "No LLM providers available. Please configure OPENAI_API_KEY or ANTHROPIC_API_KEY.",
+      "AUTHENTICATION_ERROR",
+      false
+    );
+  }
+  /** Check if any LLM provider is available. */
+  isAvailable() {
+    for (const provider of this.providers.values()) {
+      if (provider.isAvailable()) return true;
+    }
+    return false;
+  }
+  /** Get list of available provider names. */
+  getAvailableProviders() {
+    const available = [];
+    for (const [name, provider] of this.providers.entries()) {
+      if (provider.isAvailable()) available.push(name);
+    }
+    return available;
+  }
+  /**
+   * Simple chat-style generation with no schema validation.
+   * Returns the raw LLM response.
+   */
+  async chat(userPrompt, systemPrompt, options) {
+    const provider = this.getProvider();
+    const generateOptions = {
+      temperature: options?.temperature ?? this.config.defaultTemperature,
+      maxTokens: options?.maxTokens ?? this.config.defaultMaxTokens,
+      ...options
+    };
+    return provider.generate(userPrompt, systemPrompt, generateOptions);
+  }
+  /**
+   * Generate structured output validated against a Zod schema.
+   *
+   * @param userPrompt - User's request
+   * @param systemPrompt - System instructions
+   * @param schema - Zod schema to validate the parsed JSON against
+   * @param options - Generation options
+   */
+  async generate(userPrompt, systemPrompt, schema, options) {
+    const provider = this.getProvider();
+    const genOptions = {
+      model: this.config.defaultModel || void 0,
+      temperature: this.config.defaultTemperature,
+      maxTokens: this.config.defaultMaxTokens,
+      ...options
+    };
+    let lastError;
+    let lastResponse;
+    let validationAttempts = 0;
+    try {
+      lastResponse = await provider.generate(userPrompt, systemPrompt, genOptions);
+      validationAttempts++;
+      const extraction = extractJson(lastResponse.content);
+      if (!extraction.success) {
+        const result = await this.retryWithCorrection(
+          provider,
+          userPrompt,
+          systemPrompt,
+          lastResponse,
+          "parse",
+          extraction.error,
+          schema,
+          genOptions,
+          validationAttempts
+        );
+        if (result.data) {
+          return this.buildSuccess(result.data, result.response ?? lastResponse, result.attempts);
+        }
+        lastError = new Error(extraction.error);
+        validationAttempts = result.attempts;
+      } else {
+        const validation = this.validate(extraction.json, schema);
+        if (validation.valid && validation.data) {
+          return this.buildSuccess(validation.data, lastResponse, validationAttempts);
+        }
+        const result = await this.retryWithCorrection(
+          provider,
+          userPrompt,
+          systemPrompt,
+          lastResponse,
+          "schema",
+          validation.zodError,
+          schema,
+          genOptions,
+          validationAttempts
+        );
+        if (result.data) {
+          return this.buildSuccess(result.data, result.response ?? lastResponse, result.attempts);
+        }
+        lastError = validation.zodError;
+        validationAttempts = result.attempts;
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    return this.buildError(lastError ?? new Error("Unknown error"), lastResponse, validationAttempts);
+  }
+  /**
+   * Register an additional provider instance (useful for custom/third-party providers).
+   */
+  registerProvider(name, provider) {
+    this.providers.set(name, provider);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async retryWithCorrection(provider, originalPrompt, systemPrompt, previousResponse, errorType, error, schema, options, currentAttempts) {
+    let attempts = currentAttempts;
+    for (let retry = 0; retry < this.config.maxRetries; retry++) {
+      attempts++;
+      try {
+        const correctionPrompt = errorType === "parse" ? buildParseErrorCorrectionPrompt(previousResponse.content, error) : buildSchemaErrorCorrectionPrompt(previousResponse.content, error);
+        const response = await provider.generate(correctionPrompt, systemPrompt, options);
+        const extraction = extractJson(response.content);
+        if (!extraction.success) {
+          if (retry === this.config.maxRetries - 1) {
+            const genericPrompt = buildGenericRetryPrompt(originalPrompt, attempts);
+            const finalResponse = await provider.generate(genericPrompt, systemPrompt, options);
+            attempts++;
+            const finalExtraction = extractJson(finalResponse.content);
+            if (finalExtraction.success) {
+              const validation2 = this.validate(finalExtraction.json, schema);
+              if (validation2.valid && validation2.data) {
+                return { data: validation2.data, response: finalResponse, attempts };
+              }
+            }
+          }
+          continue;
+        }
+        const validation = this.validate(extraction.json, schema);
+        if (validation.valid && validation.data) {
+          return { data: validation.data, response, attempts };
+        }
+        if (validation.zodError) {
+          previousResponse = response;
+          error = validation.zodError;
+          errorType = "schema";
+        }
+      } catch {
+      }
+    }
+    return { attempts };
+  }
+  validate(data, schema) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return { valid: true, data: result.data };
+    }
+    return {
+      valid: false,
+      zodError: result.error,
+      errors: result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`)
+    };
+  }
+  buildSuccess(data, response, validationAttempts) {
+    return {
+      success: true,
+      data,
+      metadata: {
+        model: response.model,
+        promptTokens: response.usage.promptTokens,
+        completionTokens: response.usage.completionTokens,
+        validationAttempts
+      }
+    };
+  }
+  buildError(error, response, validationAttempts) {
+    const isProviderError = error instanceof LLMProviderError;
+    let code = "GENERATION_FAILED";
+    let retryable = false;
+    if (isProviderError) {
+      code = error.code;
+      retryable = error.retryable;
+    } else if (error instanceof zod.ZodError) {
+      code = "VALIDATION_FAILED";
+      retryable = true;
+    }
+    const result = {
+      success: false,
+      error: { code, message: error.message, retryable }
+    };
+    if (response) {
+      result.metadata = {
+        model: response.model,
+        promptTokens: response.usage.promptTokens,
+        completionTokens: response.usage.completionTokens,
+        validationAttempts: validationAttempts ?? 1
+      };
+    }
+    return result;
+  }
+};
+
+exports.AnthropicProvider = AnthropicProvider;
+exports.LLMProviderError = LLMProviderError;
+exports.LLMService = LLMService;
+exports.LLM_DEFAULTS = LLM_DEFAULTS;
+exports.MockLLMProvider = MockLLMProvider;
+exports.OpenAIProvider = OpenAIProvider;
+exports.buildGenericRetryPrompt = buildGenericRetryPrompt;
+exports.buildParseErrorCorrectionPrompt = buildParseErrorCorrectionPrompt;
+exports.buildSchemaErrorCorrectionPrompt = buildSchemaErrorCorrectionPrompt;
+exports.createAnthropicProvider = createAnthropicProvider;
+exports.createOpenAIProvider = createOpenAIProvider;
+exports.extractJson = extractJson;
+exports.llmErrorToHttpStatus = llmErrorToHttpStatus;
+exports.resetMockBehavior = resetMockBehavior;
+exports.setMockBehavior = setMockBehavior;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map