@startsimpli/llm 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1,835 +0,0 @@
-import { ZodError } from '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 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;
-  }
-};
-
-export { AnthropicProvider, LLMProviderError, LLMService, LLM_DEFAULTS, MockLLMProvider, OpenAIProvider, buildGenericRetryPrompt, buildParseErrorCorrectionPrompt, buildSchemaErrorCorrectionPrompt, createAnthropicProvider, createOpenAIProvider, extractJson, llmErrorToHttpStatus, resetMockBehavior, setMockBehavior };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map