@renderify/llm 0.1.0

package/dist/llm.esm.js

@@ -0,0 +1,1746 @@
+// src/providers/anthropic.ts
+import { isRuntimePlan } from "@renderify/ir";
+
+// src/providers/shared.ts
+function pickString(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function pickPositiveInt(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      return Math.floor(value);
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.floor(parsed);
+      }
+    }
+  }
+  return void 0;
+}
+function pickFetch(source, key) {
+  const value = source[key];
+  if (typeof value === "function") {
+    return value;
+  }
+  return void 0;
+}
+function resolveFetch(fetchImpl, missingMessage) {
+  if (fetchImpl) {
+    return fetchImpl;
+  }
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new Error(missingMessage);
+}
+function createTimeoutAbortScope(timeoutMs, upstreamSignal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  let onAbort;
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort();
+    } else {
+      onAbort = () => {
+        controller.abort();
+      };
+      upstreamSignal.addEventListener("abort", onAbort, { once: true });
+    }
+  }
+  return {
+    signal: controller.signal,
+    release() {
+      clearTimeout(timeout);
+      if (upstreamSignal && onAbort) {
+        upstreamSignal.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+async function withTimeoutAbortScope(timeoutMs, upstreamSignal, operation) {
+  const scope = createTimeoutAbortScope(timeoutMs, upstreamSignal);
+  try {
+    return await operation(scope.signal);
+  } finally {
+    scope.release();
+  }
+}
+function formatContext(context) {
+  if (!context || Object.keys(context).length === 0) {
+    return "";
+  }
+  try {
+    return JSON.stringify(context);
+  } catch {
+    return "";
+  }
+}
+function tryParseJson(raw) {
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  const payload = fenced ? fenced[1] : raw;
+  try {
+    return {
+      ok: true,
+      value: JSON.parse(payload)
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function readErrorResponse(response) {
+  try {
+    const body = await response.json();
+    if (body.error?.message) {
+      return body.error.message;
+    }
+    return JSON.stringify(body);
+  } catch {
+    try {
+      return await response.text();
+    } catch {
+      return "unknown error";
+    }
+  }
+}
+function consumeSseEvents(buffer, flush = false) {
+  const events = [];
+  const separator = /\r?\n\r?\n/g;
+  let cursor = 0;
+  let match = separator.exec(buffer);
+  while (match) {
+    const block = buffer.slice(cursor, match.index);
+    const parsed = parseSseEventBlock(block);
+    if (parsed) {
+      events.push(parsed);
+    }
+    cursor = match.index + match[0].length;
+    match = separator.exec(buffer);
+  }
+  let remaining = buffer.slice(cursor);
+  if (flush) {
+    const tail = parseSseEventBlock(remaining);
+    if (tail) {
+      events.push(tail);
+    }
+    remaining = "";
+  }
+  return {
+    events,
+    remaining
+  };
+}
+function parseSseEventBlock(block) {
+  const lines = block.split(/\r?\n/);
+  let eventName;
+  const dataLines = [];
+  for (const line of lines) {
+    if (line.startsWith(":")) {
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (dataLines.length === 0) {
+    return void 0;
+  }
+  const data = dataLines.join("\n").trim();
+  if (data.length === 0) {
+    return void 0;
+  }
+  return {
+    event: eventName,
+    data
+  };
+}
+
+// src/providers/anthropic.ts
+var DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
+var DEFAULT_MODEL = "claude-3-5-sonnet-latest";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_TOKENS = 2048;
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+var AnthropicLLMInterpreter = class {
+  templates = /* @__PURE__ */ new Map();
+  options = {
+    baseUrl: DEFAULT_BASE_URL,
+    model: DEFAULT_MODEL,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    maxTokens: DEFAULT_MAX_TOKENS,
+    version: DEFAULT_ANTHROPIC_VERSION,
+    apiKey: void 0,
+    systemPrompt: void 0
+  };
+  fetchImpl;
+  constructor(options = {}) {
+    this.configure({ ...options });
+    if (options.fetchImpl) {
+      this.fetchImpl = options.fetchImpl;
+    }
+  }
+  configure(options) {
+    const apiKey = pickString(options, "apiKey", "llmApiKey");
+    const model = pickString(options, "model", "llmModel");
+    const baseUrl = pickString(options, "baseUrl", "llmBaseUrl");
+    const systemPrompt = pickString(options, "systemPrompt");
+    const version = pickString(options, "version", "anthropicVersion");
+    const timeoutMs = pickPositiveInt(
+      options,
+      "timeoutMs",
+      "llmRequestTimeoutMs"
+    );
+    const maxTokens = pickPositiveInt(options, "maxTokens");
+    const fetchImpl = pickFetch(options, "fetchImpl");
+    this.options = {
+      ...this.options,
+      ...apiKey !== void 0 ? { apiKey } : {},
+      ...model !== void 0 ? { model } : {},
+      ...baseUrl !== void 0 ? { baseUrl } : {},
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      ...version !== void 0 ? { version } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...maxTokens !== void 0 ? { maxTokens } : {}
+    };
+    if (fetchImpl) {
+      this.fetchImpl = fetchImpl;
+    }
+  }
+  async generateResponse(req) {
+    const payload = await this.requestMessages(
+      {
+        model: this.options.model,
+        max_tokens: this.options.maxTokens,
+        system: this.resolveSystemPrompt(req),
+        messages: [
+          {
+            role: "user",
+            content: this.buildUserPrompt(req)
+          }
+        ]
+      },
+      req.signal
+    );
+    const text = this.extractText(payload);
+    return {
+      text,
+      tokensUsed: this.extractTotalTokens(payload),
+      model: payload.model ?? this.options.model,
+      raw: {
+        mode: "text",
+        responseId: payload.id
+      }
+    };
+  }
+  async *generateResponseStream(req) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in AnthropicLLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "Anthropic apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    const abortScope = createTimeoutAbortScope(
+      this.options.timeoutMs,
+      req.signal
+    );
+    let aggregatedText = "";
+    let chunkIndex = 0;
+    let tokensUsed;
+    let inputTokens;
+    let outputTokens;
+    let model = this.options.model;
+    let responseId;
+    let doneEmitted = false;
+    const processEvents = (events) => {
+      const chunks = [];
+      for (const event of events) {
+        if (event.data === "[DONE]" || event.event === "message_stop") {
+          if (!doneEmitted) {
+            chunkIndex += 1;
+            doneEmitted = true;
+            chunks.push({
+              delta: "",
+              text: aggregatedText,
+              done: true,
+              index: chunkIndex,
+              tokensUsed,
+              model,
+              raw: {
+                mode: "stream",
+                responseId,
+                done: true,
+                event: event.event ?? "done"
+              }
+            });
+          }
+          continue;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(event.data);
+        } catch (error) {
+          throw new Error(
+            `Anthropic stream chunk parse failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        if (payload.error?.message) {
+          throw new Error(`Anthropic error: ${payload.error.message}`);
+        }
+        if (typeof payload.message?.id === "string") {
+          responseId = payload.message.id;
+        }
+        if (typeof payload.message?.model === "string" && payload.message.model.trim().length > 0) {
+          model = payload.message.model;
+        }
+        const usageInput = payload.message?.usage?.input_tokens;
+        const usageOutput = payload.message?.usage?.output_tokens ?? payload.usage?.output_tokens;
+        if (typeof usageInput === "number") {
+          inputTokens = usageInput;
+        }
+        if (typeof usageOutput === "number") {
+          outputTokens = usageOutput;
+        }
+        if (typeof inputTokens === "number" || typeof outputTokens === "number") {
+          tokensUsed = (inputTokens ?? 0) + (outputTokens ?? 0);
+        }
+        const deltaText = payload.type === "content_block_delta" && typeof payload.delta?.text === "string" ? payload.delta.text : "";
+        if (deltaText.length === 0) {
+          continue;
+        }
+        aggregatedText += deltaText;
+        chunkIndex += 1;
+        chunks.push({
+          delta: deltaText,
+          text: aggregatedText,
+          done: false,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            responseId,
+            event: event.event ?? payload.type,
+            chunk: payload
+          }
+        });
+      }
+      return chunks;
+    };
+    try {
+      const response = await fetchImpl(
+        `${this.options.baseUrl.replace(/\/$/, "")}/messages`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": this.options.version
+          },
+          body: JSON.stringify({
+            model: this.options.model,
+            max_tokens: this.options.maxTokens,
+            system: this.resolveSystemPrompt(req),
+            stream: true,
+            messages: [
+              {
+                role: "user",
+                content: this.buildUserPrompt(req)
+              }
+            ]
+          }),
+          signal: abortScope.signal
+        }
+      );
+      if (!response.ok) {
+        const details = await readErrorResponse(response);
+        throw new Error(
+          `Anthropic request failed (${response.status}): ${details}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("Anthropic streaming response body is empty");
+      }
+      const decoder = new TextDecoder();
+      const reader = response.body.getReader();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          buffer += decoder.decode(value, { stream: true });
+        }
+        const parsedEvents = consumeSseEvents(buffer);
+        buffer = parsedEvents.remaining;
+        for (const chunk of processEvents(parsedEvents.events)) {
+          yield chunk;
+        }
+      }
+      buffer += decoder.decode();
+      const finalEvents = consumeSseEvents(buffer, true);
+      for (const chunk of processEvents(finalEvents.events)) {
+        yield chunk;
+      }
+      if (!doneEmitted) {
+        chunkIndex += 1;
+        doneEmitted = true;
+        yield {
+          delta: "",
+          text: aggregatedText,
+          done: true,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            responseId,
+            done: true,
+            reason: "eof"
+          }
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (req.signal?.aborted) {
+          throw new Error("Anthropic request aborted by caller");
+        }
+        throw new Error(
+          `Anthropic request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    } finally {
+      abortScope.release();
+    }
+  }
+  async generateStructuredResponse(req) {
+    if (req.format !== "runtime-plan") {
+      return {
+        text: "",
+        valid: false,
+        errors: [`Unsupported structured format: ${String(req.format)}`],
+        model: this.options.model
+      };
+    }
+    const payload = await this.requestMessages(
+      {
+        model: this.options.model,
+        max_tokens: this.options.maxTokens,
+        system: this.resolveStructuredSystemPrompt(req),
+        messages: [
+          {
+            role: "user",
+            content: this.buildUserPrompt(req)
+          }
+        ]
+      },
+      req.signal
+    );
+    const text = this.extractText(payload);
+    if (text.trim().length === 0) {
+      return {
+        text,
+        valid: false,
+        errors: ["Structured response content is empty"],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    const parsed = tryParseJson(text);
+    if (!parsed.ok) {
+      return {
+        text,
+        valid: false,
+        errors: [`Structured JSON parse failed: ${parsed.error}`],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    if (!isRuntimePlan(parsed.value)) {
+      return {
+        text,
+        value: parsed.value,
+        valid: false,
+        errors: ["Structured payload is not a valid RuntimePlan"],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    return {
+      text,
+      value: parsed.value,
+      valid: true,
+      tokensUsed: this.extractTotalTokens(payload),
+      model: payload.model ?? this.options.model,
+      raw: {
+        mode: "structured",
+        responseId: payload.id
+      }
+    };
+  }
+  setPromptTemplate(templateName, templateContent) {
+    this.templates.set(templateName, templateContent);
+  }
+  getPromptTemplate(templateName) {
+    return this.templates.get(templateName);
+  }
+  resolveSystemPrompt(req) {
+    const templateSystem = this.templates.get("default");
+    const configuredSystem = this.options.systemPrompt;
+    const requestSystem = req.systemPrompt;
+    const candidates = [configuredSystem, templateSystem, requestSystem].filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (candidates.length === 0) {
+      return void 0;
+    }
+    return candidates.join("\n\n");
+  }
+  resolveStructuredSystemPrompt(req) {
+    const template = this.templates.get("runtime-plan");
+    const strictHint = req.strict === false ? "false" : "true";
+    const defaultPrompt = [
+      "You generate RuntimePlan JSON for Renderify.",
+      "Return only JSON with no markdown or explanations.",
+      "Schema priority: id/version/root/capabilities must be valid.",
+      `Strict mode: ${strictHint}.`
+    ].join(" ");
+    const combined = [this.resolveSystemPrompt(req), template, defaultPrompt].filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0).join("\n\n");
+    return combined;
+  }
+  buildUserPrompt(req) {
+    const contextSnippet = formatContext(req.context);
+    if (!contextSnippet) {
+      return req.prompt;
+    }
+    return `${req.prompt}
+
+Context:
+${contextSnippet}`;
+  }
+  async requestMessages(body, signal) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in AnthropicLLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "Anthropic apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    try {
+      return await withTimeoutAbortScope(
+        this.options.timeoutMs,
+        signal,
+        async (timeoutSignal) => {
+          const response = await fetchImpl(
+            `${this.options.baseUrl.replace(/\/$/, "")}/messages`,
+            {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": this.options.version
+              },
+              body: JSON.stringify(body),
+              signal: timeoutSignal
+            }
+          );
+          if (!response.ok) {
+            const details = await readErrorResponse(response);
+            throw new Error(
+              `Anthropic request failed (${response.status}): ${details}`
+            );
+          }
+          const parsed = await response.json();
+          if (parsed.error?.message) {
+            throw new Error(`Anthropic error: ${parsed.error.message}`);
+          }
+          return parsed;
+        }
+      );
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (signal?.aborted) {
+          throw new Error("Anthropic request aborted by caller");
+        }
+        throw new Error(
+          `Anthropic request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    }
+  }
+  extractText(payload) {
+    const content = payload.content;
+    if (!Array.isArray(content) || content.length === 0) {
+      return "";
+    }
+    return content.map(
+      (part) => part.type === "text" && typeof part.text === "string" ? part.text : ""
+    ).join("").trim();
+  }
+  extractTotalTokens(payload) {
+    const input = payload.usage?.input_tokens;
+    const output = payload.usage?.output_tokens;
+    if (typeof input !== "number" && typeof output !== "number") {
+      return void 0;
+    }
+    return (input ?? 0) + (output ?? 0);
+  }
+};
+
+// src/providers/google.ts
+import { isRuntimePlan as isRuntimePlan2 } from "@renderify/ir";
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com/v1beta";
+var DEFAULT_MODEL2 = "gemini-2.0-flash";
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var GoogleLLMInterpreter = class {
+  templates = /* @__PURE__ */ new Map();
+  options = {
+    baseUrl: DEFAULT_BASE_URL2,
+    model: DEFAULT_MODEL2,
+    timeoutMs: DEFAULT_TIMEOUT_MS2,
+    apiKey: void 0,
+    systemPrompt: void 0
+  };
+  fetchImpl;
+  constructor(options = {}) {
+    this.configure({ ...options });
+    if (options.fetchImpl) {
+      this.fetchImpl = options.fetchImpl;
+    }
+  }
+  configure(options) {
+    const apiKey = pickString(options, "apiKey", "llmApiKey");
+    const model = pickString(options, "model", "llmModel");
+    const baseUrl = pickString(options, "baseUrl", "llmBaseUrl");
+    const systemPrompt = pickString(options, "systemPrompt");
+    const timeoutMs = pickPositiveInt(
+      options,
+      "timeoutMs",
+      "llmRequestTimeoutMs"
+    );
+    const fetchImpl = pickFetch(options, "fetchImpl");
+    this.options = {
+      ...this.options,
+      ...apiKey !== void 0 ? { apiKey } : {},
+      ...model !== void 0 ? { model } : {},
+      ...baseUrl !== void 0 ? { baseUrl } : {},
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {}
+    };
+    if (fetchImpl) {
+      this.fetchImpl = fetchImpl;
+    }
+  }
+  async generateResponse(req) {
+    const payload = await this.requestGenerateContent(
+      this.buildRequest(req),
+      req.signal
+    );
+    const refusal = this.extractRefusal(payload);
+    if (refusal) {
+      throw new Error(`Google refused request: ${refusal}`);
+    }
+    return {
+      text: this.extractText(payload),
+      tokensUsed: this.extractTotalTokens(payload),
+      model: payload.modelVersion ?? this.options.model,
+      raw: {
+        mode: "text",
+        finishReason: payload.candidates?.[0]?.finishReason
+      }
+    };
+  }
+  async *generateResponseStream(req) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in GoogleLLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "Google apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    const abortScope = createTimeoutAbortScope(
+      this.options.timeoutMs,
+      req.signal
+    );
+    let aggregatedText = "";
+    let chunkIndex = 0;
+    let tokensUsed;
+    let model = this.options.model;
+    let doneEmitted = false;
+    const processEvents = (events) => {
+      const chunks = [];
+      for (const event of events) {
+        if (event.data === "[DONE]") {
+          if (!doneEmitted) {
+            chunkIndex += 1;
+            doneEmitted = true;
+            chunks.push({
+              delta: "",
+              text: aggregatedText,
+              done: true,
+              index: chunkIndex,
+              tokensUsed,
+              model,
+              raw: {
+                mode: "stream",
+                done: true
+              }
+            });
+          }
+          continue;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(event.data);
+        } catch (error) {
+          throw new Error(
+            `Google stream chunk parse failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        if (payload.error?.message) {
+          throw new Error(`Google error: ${payload.error.message}`);
+        }
+        if (typeof payload.modelVersion === "string" && payload.modelVersion.trim().length > 0) {
+          model = payload.modelVersion;
+        }
+        const refusal = this.extractRefusal(payload);
+        if (refusal) {
+          throw new Error(`Google refused request: ${refusal}`);
+        }
+        const payloadTokens = this.extractTotalTokens(payload);
+        if (typeof payloadTokens === "number") {
+          tokensUsed = payloadTokens;
+        }
+        const deltaText = this.extractTextRaw(payload);
+        if (deltaText.length === 0) {
+          continue;
+        }
+        aggregatedText += deltaText;
+        chunkIndex += 1;
+        chunks.push({
+          delta: deltaText,
+          text: aggregatedText,
+          done: false,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            chunk: payload
+          }
+        });
+      }
+      return chunks;
+    };
+    try {
+      const response = await fetchImpl(
+        `${this.options.baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(this.options.model)}:streamGenerateContent?alt=sse`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-goog-api-key": apiKey
+          },
+          body: JSON.stringify(this.buildRequest(req)),
+          signal: abortScope.signal
+        }
+      );
+      if (!response.ok) {
+        const details = await readErrorResponse(response);
+        throw new Error(
+          `Google request failed (${response.status}): ${details}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("Google streaming response body is empty");
+      }
+      const decoder = new TextDecoder();
+      const reader = response.body.getReader();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          buffer += decoder.decode(value, { stream: true });
+        }
+        const parsedEvents = consumeSseEvents(buffer);
+        buffer = parsedEvents.remaining;
+        for (const chunk of processEvents(parsedEvents.events)) {
+          yield chunk;
+        }
+      }
+      buffer += decoder.decode();
+      const finalEvents = consumeSseEvents(buffer, true);
+      for (const chunk of processEvents(finalEvents.events)) {
+        yield chunk;
+      }
+      if (!doneEmitted) {
+        chunkIndex += 1;
+        doneEmitted = true;
+        yield {
+          delta: "",
+          text: aggregatedText,
+          done: true,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            done: true,
+            reason: "eof"
+          }
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (req.signal?.aborted) {
+          throw new Error("Google request aborted by caller");
+        }
+        throw new Error(
+          `Google request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    } finally {
+      abortScope.release();
+    }
+  }
+  async generateStructuredResponse(req) {
+    if (req.format !== "runtime-plan") {
+      return {
+        text: "",
+        valid: false,
+        errors: [`Unsupported structured format: ${String(req.format)}`],
+        model: this.options.model
+      };
+    }
+    const payload = await this.requestGenerateContent(
+      this.buildStructuredRequest(req),
+      req.signal
+    );
+    const refusal = this.extractRefusal(payload);
+    if (refusal) {
+      return {
+        text: "",
+        valid: false,
+        errors: [`Google refusal: ${refusal}`],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.modelVersion ?? this.options.model,
+        raw: {
+          mode: "structured",
+          finishReason: payload.candidates?.[0]?.finishReason
+        }
+      };
+    }
+    const text = this.extractText(payload);
+    if (text.trim().length === 0) {
+      return {
+        text,
+        valid: false,
+        errors: ["Structured response content is empty"],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.modelVersion ?? this.options.model,
+        raw: {
+          mode: "structured",
+          finishReason: payload.candidates?.[0]?.finishReason
+        }
+      };
+    }
+    const parsed = tryParseJson(text);
+    if (!parsed.ok) {
+      return {
+        text,
+        valid: false,
+        errors: [`Structured JSON parse failed: ${parsed.error}`],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.modelVersion ?? this.options.model,
+        raw: {
+          mode: "structured",
+          finishReason: payload.candidates?.[0]?.finishReason
+        }
+      };
+    }
+    if (!isRuntimePlan2(parsed.value)) {
+      return {
+        text,
+        value: parsed.value,
+        valid: false,
+        errors: ["Structured payload is not a valid RuntimePlan"],
+        tokensUsed: this.extractTotalTokens(payload),
+        model: payload.modelVersion ?? this.options.model,
+        raw: {
+          mode: "structured",
+          finishReason: payload.candidates?.[0]?.finishReason
+        }
+      };
+    }
+    return {
+      text,
+      value: parsed.value,
+      valid: true,
+      tokensUsed: this.extractTotalTokens(payload),
+      model: payload.modelVersion ?? this.options.model,
+      raw: {
+        mode: "structured",
+        finishReason: payload.candidates?.[0]?.finishReason
+      }
+    };
+  }
+  setPromptTemplate(templateName, templateContent) {
+    this.templates.set(templateName, templateContent);
+  }
+  getPromptTemplate(templateName) {
+    return this.templates.get(templateName);
+  }
+  buildRequest(req) {
+    const system = this.resolveSystemPrompt(req);
+    const body = {
+      contents: [
+        {
+          role: "user",
+          parts: [
+            {
+              text: this.buildUserPrompt(req)
+            }
+          ]
+        }
+      ],
+      generationConfig: {
+        responseMimeType: "text/plain"
+      }
+    };
+    if (system) {
+      body.systemInstruction = {
+        parts: [
+          {
+            text: system
+          }
+        ]
+      };
+    }
+    return body;
+  }
+  buildStructuredRequest(req) {
+    const body = this.buildRequest({
+      ...req,
+      systemPrompt: this.resolveStructuredSystemPrompt(req)
+    });
+    body.generationConfig = {
+      responseMimeType: "application/json"
+    };
+    return body;
+  }
+  resolveSystemPrompt(req) {
+    const configuredSystem = this.options.systemPrompt;
+    const templateSystem = this.templates.get("default");
+    const requestSystem = req.systemPrompt;
+    const candidates = [configuredSystem, templateSystem, requestSystem].filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (candidates.length === 0) {
+      return void 0;
+    }
+    return candidates.join("\n\n");
+  }
+  resolveStructuredSystemPrompt(req) {
+    const template = this.templates.get("runtime-plan");
+    const strictHint = req.strict === false ? "false" : "true";
+    const defaultPrompt = [
+      "You generate RuntimePlan JSON for Renderify.",
+      "Return only JSON with no markdown or explanations.",
+      "Schema priority: id/version/root/capabilities must be valid.",
+      `Strict mode: ${strictHint}.`
+    ].join(" ");
+    return [this.resolveSystemPrompt(req), template, defaultPrompt].filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0).join("\n\n");
+  }
+  buildUserPrompt(req) {
+    const contextSnippet = formatContext(req.context);
+    if (!contextSnippet) {
+      return req.prompt;
+    }
+    return `${req.prompt}
+
+Context:
+${contextSnippet}`;
+  }
+  async requestGenerateContent(body, signal) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in GoogleLLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "Google apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    try {
+      return await withTimeoutAbortScope(
+        this.options.timeoutMs,
+        signal,
+        async (timeoutSignal) => {
+          const response = await fetchImpl(
+            `${this.options.baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(this.options.model)}:generateContent`,
+            {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                "x-goog-api-key": apiKey
+              },
+              body: JSON.stringify(body),
+              signal: timeoutSignal
+            }
+          );
+          if (!response.ok) {
+            const details = await readErrorResponse(response);
+            throw new Error(
+              `Google request failed (${response.status}): ${details}`
+            );
+          }
+          const parsed = await response.json();
+          if (parsed.error?.message) {
+            throw new Error(`Google error: ${parsed.error.message}`);
+          }
+          return parsed;
+        }
+      );
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (signal?.aborted) {
+          throw new Error("Google request aborted by caller");
+        }
+        throw new Error(
+          `Google request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    }
+  }
+  extractText(payload) {
+    return this.extractTextRaw(payload).trim();
+  }
+  extractTextRaw(payload) {
+    const candidate = payload.candidates?.[0];
+    if (!candidate) {
+      return "";
+    }
+    return (candidate.content?.parts ?? []).map((part) => typeof part.text === "string" ? part.text : "").join("");
+  }
+  extractRefusal(payload) {
+    const blockReason = payload.promptFeedback?.blockReason;
+    if (typeof blockReason === "string" && blockReason.trim().length > 0) {
+      const details = payload.promptFeedback?.blockReasonMessage;
+      if (typeof details === "string" && details.trim().length > 0) {
+        return `${blockReason.trim()}: ${details.trim()}`;
+      }
+      return blockReason.trim();
+    }
+    const finishReason = payload.candidates?.[0]?.finishReason;
+    if (finishReason === "SAFETY" || finishReason === "RECITATION" || finishReason === "BLOCKLIST" || finishReason === "PROHIBITED_CONTENT" || finishReason === "SPII") {
+      return `finishReason=${finishReason}`;
+    }
+    return void 0;
+  }
+  extractTotalTokens(payload) {
+    const usage = payload.usageMetadata;
+    if (!usage) {
+      return void 0;
+    }
+    if (typeof usage.totalTokenCount === "number") {
+      return usage.totalTokenCount;
+    }
+    const prompt = usage.promptTokenCount;
+    const candidates = usage.candidatesTokenCount;
+    if (typeof prompt !== "number" && typeof candidates !== "number") {
+      return void 0;
+    }
+    return (prompt ?? 0) + (candidates ?? 0);
+  }
+};
+
+// src/providers/openai.ts
+import { isRuntimePlan as isRuntimePlan3 } from "@renderify/ir";
+var DEFAULT_BASE_URL3 = "https://api.openai.com/v1";
+var DEFAULT_MODEL3 = "gpt-4.1-mini";
+var DEFAULT_TIMEOUT_MS3 = 3e4;
+var RUNTIME_PLAN_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: ["id", "version", "root", "capabilities"],
+  properties: {
+    specVersion: {
+      type: "string",
+      minLength: 1
+    },
+    id: {
+      type: "string",
+      minLength: 1
+    },
+    version: {
+      type: "integer",
+      minimum: 1
+    },
+    root: {
+      type: "object",
+      additionalProperties: true
+    },
+    capabilities: {
+      type: "object",
+      additionalProperties: true
+    },
+    imports: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    moduleManifest: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        required: ["resolvedUrl"],
+        properties: {
+          resolvedUrl: { type: "string", minLength: 1 },
+          integrity: { type: "string", minLength: 1 },
+          version: { type: "string", minLength: 1 },
+          signer: { type: "string", minLength: 1 }
+        }
+      }
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true
+    },
+    state: {
+      type: "object",
+      additionalProperties: true
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["language", "code"],
+      properties: {
+        language: {
+          type: "string",
+          enum: ["js", "jsx", "ts", "tsx"]
+        },
+        code: {
+          type: "string",
+          minLength: 1
+        },
+        exportName: {
+          type: "string",
+          minLength: 1
+        },
+        runtime: {
+          type: "string",
+          enum: ["renderify", "preact"]
+        }
+      }
+    }
+  }
+};
+var OpenAILLMInterpreter = class {
+  templates = /* @__PURE__ */ new Map();
+  options = {
+    baseUrl: DEFAULT_BASE_URL3,
+    model: DEFAULT_MODEL3,
+    timeoutMs: DEFAULT_TIMEOUT_MS3,
+    apiKey: void 0,
+    organization: void 0,
+    project: void 0,
+    systemPrompt: void 0
+  };
+  fetchImpl;
+  constructor(options = {}) {
+    this.configure({ ...options });
+    if (options.fetchImpl) {
+      this.fetchImpl = options.fetchImpl;
+    }
+  }
+  configure(options) {
+    const apiKey = pickString(options, "apiKey", "llmApiKey");
+    const model = pickString(options, "model", "llmModel");
+    const baseUrl = pickString(options, "baseUrl", "llmBaseUrl");
+    const organization = pickString(
+      options,
+      "organization",
+      "openaiOrganization"
+    );
+    const project = pickString(options, "project", "openaiProject");
+    const systemPrompt = pickString(options, "systemPrompt");
+    const timeoutMs = pickPositiveInt(
+      options,
+      "timeoutMs",
+      "llmRequestTimeoutMs"
+    );
+    const fetchImpl = pickFetch(options, "fetchImpl");
+    this.options = {
+      ...this.options,
+      ...apiKey !== void 0 ? { apiKey } : {},
+      ...model !== void 0 ? { model } : {},
+      ...baseUrl !== void 0 ? { baseUrl } : {},
+      ...organization !== void 0 ? { organization } : {},
+      ...project !== void 0 ? { project } : {},
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {}
+    };
+    if (fetchImpl) {
+      this.fetchImpl = fetchImpl;
+    }
+  }
+  async generateResponse(req) {
+    const payload = await this.requestChatCompletions(
+      {
+        model: this.options.model,
+        messages: this.buildMessages(req)
+      },
+      req.signal
+    );
+    const output = this.extractOutput(payload);
+    if (output.refusal) {
+      throw new Error(`OpenAI refused request: ${output.refusal}`);
+    }
+    return {
+      text: output.text,
+      tokensUsed: payload.usage?.total_tokens,
+      model: payload.model ?? this.options.model,
+      raw: {
+        mode: "text",
+        responseId: payload.id
+      }
+    };
+  }
+  async *generateResponseStream(req) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in OpenAILLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "OpenAI apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    const abortScope = createTimeoutAbortScope(
+      this.options.timeoutMs,
+      req.signal
+    );
+    let aggregatedText = "";
+    let chunkIndex = 0;
+    let tokensUsed;
+    let model = this.options.model;
+    let doneEmitted = false;
+    const processEvents = (events) => {
+      const chunks = [];
+      for (const event of events) {
+        const eventData = event.data;
+        if (eventData === "[DONE]") {
+          if (!doneEmitted) {
+            chunkIndex += 1;
+            doneEmitted = true;
+            chunks.push({
+              delta: "",
+              text: aggregatedText,
+              done: true,
+              index: chunkIndex,
+              tokensUsed,
+              model,
+              raw: {
+                mode: "stream",
+                done: true
+              }
+            });
+          }
+          continue;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(eventData);
+        } catch (error) {
+          throw new Error(
+            `OpenAI stream chunk parse failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        if (payload.error?.message) {
+          throw new Error(`OpenAI error: ${payload.error.message}`);
+        }
+        if (typeof payload.model === "string" && payload.model.trim().length > 0) {
+          model = payload.model;
+        }
+        if (typeof payload.usage?.total_tokens === "number" && Number.isFinite(payload.usage.total_tokens)) {
+          tokensUsed = payload.usage.total_tokens;
+        }
+        const output = this.extractStreamDelta(payload);
+        if (output.refusal) {
+          throw new Error(`OpenAI refused request: ${output.refusal}`);
+        }
+        if (output.text.length === 0) {
+          continue;
+        }
+        aggregatedText += output.text;
+        chunkIndex += 1;
+        chunks.push({
+          delta: output.text,
+          text: aggregatedText,
+          done: false,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            chunk: payload
+          }
+        });
+      }
+      return chunks;
+    };
+    try {
+      const response = await fetchImpl(
+        `${this.options.baseUrl.replace(/\/$/, "")}/chat/completions`,
+        {
+          method: "POST",
+          headers: this.createHeaders(apiKey),
+          body: JSON.stringify({
+            model: this.options.model,
+            messages: this.buildMessages(req),
+            stream: true,
+            stream_options: {
+              include_usage: true
+            }
+          }),
+          signal: abortScope.signal
+        }
+      );
+      if (!response.ok) {
+        const details = await readErrorResponse(response);
+        throw new Error(
+          `OpenAI request failed (${response.status}): ${details}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("OpenAI streaming response body is empty");
+      }
+      const decoder = new TextDecoder();
+      const reader = response.body.getReader();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          buffer += decoder.decode(value, { stream: true });
+        }
+        const parsedEvents = consumeSseEvents(buffer);
+        buffer = parsedEvents.remaining;
+        for (const chunk of processEvents(parsedEvents.events)) {
+          yield chunk;
+        }
+      }
+      buffer += decoder.decode();
+      const finalEvents = consumeSseEvents(buffer, true);
+      for (const chunk of processEvents(finalEvents.events)) {
+        yield chunk;
+      }
+      if (!doneEmitted) {
+        chunkIndex += 1;
+        doneEmitted = true;
+        yield {
+          delta: "",
+          text: aggregatedText,
+          done: true,
+          index: chunkIndex,
+          tokensUsed,
+          model,
+          raw: {
+            mode: "stream",
+            done: true,
+            reason: "eof"
+          }
+        };
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (req.signal?.aborted) {
+          throw new Error("OpenAI request aborted by caller");
+        }
+        throw new Error(
+          `OpenAI request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    } finally {
+      abortScope.release();
+    }
+  }
+  async generateStructuredResponse(req) {
+    if (req.format !== "runtime-plan") {
+      return {
+        text: "",
+        valid: false,
+        errors: [`Unsupported structured format: ${String(req.format)}`],
+        model: this.options.model
+      };
+    }
+    const payload = await this.requestChatCompletions(
+      {
+        model: this.options.model,
+        messages: this.buildMessages({
+          ...req,
+          systemPrompt: this.resolveStructuredSystemPrompt(req)
+        }),
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            name: "runtime_plan",
+            strict: req.strict !== false,
+            schema: RUNTIME_PLAN_JSON_SCHEMA
+          }
+        }
+      },
+      req.signal
+    );
+    const output = this.extractOutput(payload);
+    if (output.refusal) {
+      return {
+        text: "",
+        valid: false,
+        errors: [`OpenAI refusal: ${output.refusal}`],
+        tokensUsed: payload.usage?.total_tokens,
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id,
+          refusal: output.refusal
+        }
+      };
+    }
+    if (output.text.trim().length === 0) {
+      return {
+        text: "",
+        valid: false,
+        errors: ["Structured response content is empty"],
+        tokensUsed: payload.usage?.total_tokens,
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    const parsed = tryParseJson(output.text);
+    if (!parsed.ok) {
+      return {
+        text: output.text,
+        valid: false,
+        errors: [`Structured JSON parse failed: ${parsed.error}`],
+        tokensUsed: payload.usage?.total_tokens,
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    if (!isRuntimePlan3(parsed.value)) {
+      return {
+        text: output.text,
+        value: parsed.value,
+        valid: false,
+        errors: ["Structured payload is not a valid RuntimePlan"],
+        tokensUsed: payload.usage?.total_tokens,
+        model: payload.model ?? this.options.model,
+        raw: {
+          mode: "structured",
+          responseId: payload.id
+        }
+      };
+    }
+    return {
+      text: output.text,
+      value: parsed.value,
+      valid: true,
+      tokensUsed: payload.usage?.total_tokens,
+      model: payload.model ?? this.options.model,
+      raw: {
+        mode: "structured",
+        responseId: payload.id
+      }
+    };
+  }
+  setPromptTemplate(templateName, templateContent) {
+    this.templates.set(templateName, templateContent);
+  }
+  getPromptTemplate(templateName) {
+    return this.templates.get(templateName);
+  }
+  async requestChatCompletions(body, signal) {
+    const fetchImpl = resolveFetch(
+      this.fetchImpl,
+      "Global fetch is unavailable. Provide fetchImpl in OpenAILLMInterpreter options."
+    );
+    const apiKey = this.options.apiKey;
+    if (!apiKey || apiKey.trim().length === 0) {
+      throw new Error(
+        "OpenAI apiKey is missing. Set RENDERIFY_LLM_API_KEY or configure apiKey."
+      );
+    }
+    try {
+      return await withTimeoutAbortScope(
+        this.options.timeoutMs,
+        signal,
+        async (timeoutSignal) => {
+          const response = await fetchImpl(
+            `${this.options.baseUrl.replace(/\/$/, "")}/chat/completions`,
+            {
+              method: "POST",
+              headers: this.createHeaders(apiKey),
+              body: JSON.stringify(body),
+              signal: timeoutSignal
+            }
+          );
+          if (!response.ok) {
+            const details = await readErrorResponse(response);
+            throw new Error(
+              `OpenAI request failed (${response.status}): ${details}`
+            );
+          }
+          const parsed = await response.json();
+          if (parsed.error?.message) {
+            throw new Error(`OpenAI error: ${parsed.error.message}`);
+          }
+          return parsed;
+        }
+      );
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (signal?.aborted) {
+          throw new Error("OpenAI request aborted by caller");
+        }
+        throw new Error(
+          `OpenAI request timed out after ${this.options.timeoutMs}ms`
+        );
+      }
+      throw error;
+    }
+  }
+  buildMessages(req) {
+    const messages = [];
+    const templateSystem = this.templates.get("default");
+    const promptSystem = req.systemPrompt;
+    const configuredSystem = this.options.systemPrompt;
+    for (const system of [configuredSystem, templateSystem, promptSystem]) {
+      if (typeof system === "string" && system.trim().length > 0) {
+        messages.push({
+          role: "system",
+          content: system.trim()
+        });
+      }
+    }
+    const contextSnippet = formatContext(req.context);
+    const prompt = contextSnippet ? `${req.prompt}
+
+Context:
+${contextSnippet}` : req.prompt;
+    messages.push({
+      role: "user",
+      content: prompt
+    });
+    return messages;
+  }
+  resolveStructuredSystemPrompt(req) {
+    const template = this.templates.get("runtime-plan");
+    if (template && template.trim().length > 0) {
+      return template;
+    }
+    const strictHint = req.strict === false ? "false" : "true";
+    return [
+      "You generate RuntimePlan JSON for Renderify.",
+      "Return only JSON with no markdown or explanations.",
+      "Schema priority: id/version/root/capabilities must be valid.",
+      `Strict mode: ${strictHint}.`
+    ].join(" ");
+  }
+  createHeaders(apiKey) {
+    const headers = {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    };
+    if (this.options.organization) {
+      headers["OpenAI-Organization"] = this.options.organization;
+    }
+    if (this.options.project) {
+      headers["OpenAI-Project"] = this.options.project;
+    }
+    return headers;
+  }
+  extractOutput(payload) {
+    const choice = payload.choices?.[0];
+    if (!choice || !choice.message) {
+      throw new Error("OpenAI response missing assistant choice");
+    }
+    const refusal = choice.message.refusal;
+    if (typeof refusal === "string" && refusal.trim().length > 0) {
+      return {
+        text: "",
+        refusal: refusal.trim()
+      };
+    }
+    const content = choice.message.content;
+    if (typeof content === "string") {
+      return {
+        text: content.trim()
+      };
+    }
+    if (Array.isArray(content)) {
+      const combined = content.map((part) => typeof part.text === "string" ? part.text : "").join("").trim();
+      return {
+        text: combined
+      };
+    }
+    return {
+      text: ""
+    };
+  }
+  extractStreamDelta(payload) {
+    const choices = payload.choices ?? [];
+    let text = "";
+    for (const choice of choices) {
+      const refusal = choice.delta?.refusal;
+      if (typeof refusal === "string" && refusal.trim().length > 0) {
+        return {
+          text: "",
+          refusal: refusal.trim()
+        };
+      }
+      const content = choice.delta?.content;
+      if (typeof content === "string") {
+        text += content;
+        continue;
+      }
+      if (Array.isArray(content)) {
+        text += content.map((part) => typeof part.text === "string" ? part.text : "").join("");
+      }
+    }
+    return {
+      text
+    };
+  }
+};
+
+// src/registry.ts
+var openaiLLMProvider = {
+  name: "openai",
+  create: (options) => new OpenAILLMInterpreter(options)
+};
+var anthropicLLMProvider = {
+  name: "anthropic",
+  create: (options) => new AnthropicLLMInterpreter(options)
+};
+var googleLLMProvider = {
+  name: "google",
+  create: (options) => new GoogleLLMInterpreter(options)
+};
+var LLMProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(definition) {
+    const key = normalizeProviderName(definition.name);
+    this.providers.set(key, definition);
+    return this;
+  }
+  unregister(providerName) {
+    return this.providers.delete(normalizeProviderName(providerName));
+  }
+  has(providerName) {
+    return this.providers.has(normalizeProviderName(providerName));
+  }
+  list() {
+    return [...this.providers.keys()].sort((a, b) => a.localeCompare(b));
+  }
+  resolve(providerName) {
+    return this.providers.get(normalizeProviderName(providerName));
+  }
+  create(providerName, options) {
+    const provider = this.resolve(providerName);
+    if (!provider) {
+      const available = this.list();
+      const hint = available.length > 0 ? ` Available providers: ${available.join(", ")}.` : " No providers registered.";
+      throw new Error(`Unknown LLM provider: ${providerName}.${hint}`);
+    }
+    return provider.create(options);
+  }
+};
+function createDefaultLLMProviderRegistry() {
+  const registry = new LLMProviderRegistry();
+  registry.register(anthropicLLMProvider);
+  registry.register(googleLLMProvider);
+  registry.register(openaiLLMProvider);
+  return registry;
+}
+var defaultLLMProviderRegistry = createDefaultLLMProviderRegistry();
+function createLLMInterpreter(options) {
+  const provider = normalizeProviderName(options.provider ?? "openai");
+  const registry = options.registry ?? defaultLLMProviderRegistry;
+  return registry.create(provider, options.providerOptions);
+}
+function normalizeProviderName(providerName) {
+  const normalized = String(providerName).trim().toLowerCase();
+  if (normalized.length === 0) {
+    return "openai";
+  }
+  return normalized;
+}
+export {
+  AnthropicLLMInterpreter,
+  GoogleLLMInterpreter,
+  LLMProviderRegistry,
+  OpenAILLMInterpreter,
+  anthropicLLMProvider,
+  createDefaultLLMProviderRegistry,
+  createLLMInterpreter,
+  defaultLLMProviderRegistry,
+  googleLLMProvider,
+  openaiLLMProvider
+};
+//# sourceMappingURL=llm.esm.js.map