@hilbras/omninode 2.0.0-alpha.13 → 2.0.0-alpha.14

package/dist/cli/chunk-6Z6O63SS.js

@@ -0,0 +1,708 @@
+#!/usr/bin/env node
+
+// src/errors/index.ts
+var OmniNodeError = class extends Error {
+  code;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.code = code;
+    this.details = options.details;
+  }
+};
+var ConfigError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var ProviderError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var AgentError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var TaskError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var PipelineError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var PlannerError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var MemoryError = class extends OmniNodeError {
+  constructor(message, options = {}) {
+    super("MEMORY_UNAVAILABLE", message, options);
+  }
+};
+function isOmniNodeError(value) {
+  return value instanceof OmniNodeError;
+}
+
+// src/providers/auth.ts
+function resolveApiKey(config, env = process.env) {
+  if (!config.apiKeyEnvVar) return void 0;
+  const value = env[config.apiKeyEnvVar];
+  if (!value) {
+    throw new ProviderError(
+      "PROVIDER_AUTH_FAILED",
+      `Environment variable "${config.apiKeyEnvVar}" (referenced by provider "${config.name}") is not set.`
+    );
+  }
+  return value;
+}
+function authHeaders(config, env = process.env) {
+  const key = resolveApiKey(config, env);
+  const base = { ...config.headers ?? {} };
+  return key ? { ...base, authorization: `Bearer ${key}` } : base;
+}
+
+// src/providers/http.ts
+var HttpResponseError = class extends Error {
+  constructor(message, status, cause) {
+    super(message, { cause });
+    this.status = status;
+    this.name = "HttpResponseError";
+  }
+  status;
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function requestJson(url, options = {}) {
+  const { method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+  const response = await fetch(url, {
+    method,
+    headers: {
+      accept: "application/json",
+      ...body !== void 0 ? { "content-type": "application/json" } : {},
+      ...headers
+    },
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  let parsed;
+  try {
+    parsed = await response.json();
+  } catch (error) {
+    throw new HttpResponseError(`Response from ${url} was not valid JSON.`, response.status, error);
+  }
+  return { status: response.status, body: parsed };
+}
+
+// src/logger/index.ts
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var ConsoleLogSink = class {
+  constructor(stream = process.stderr) {
+    this.stream = stream;
+  }
+  stream;
+  write(_level, line) {
+    this.stream.write(line + "\n");
+  }
+};
+var Logger = class _Logger {
+  level;
+  format;
+  sink;
+  context;
+  constructor(options = {}) {
+    this.level = options.level ?? "info";
+    this.format = options.format ?? "text";
+    this.sink = options.sink ?? new ConsoleLogSink();
+    this.context = options.context ?? {};
+  }
+  child(context) {
+    return new _Logger({
+      level: this.level,
+      format: this.format,
+      sink: this.sink,
+      context: { ...this.context, ...context }
+    });
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  log(level, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.level]) return;
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const merged = { ...this.context, ...data };
+    if (this.format === "json") {
+      this.sink.write(level, JSON.stringify({ at, level, message, ...merged }));
+      return;
+    }
+    const parts = [at, level.toUpperCase(), message];
+    if (Object.keys(merged).length > 0) {
+      parts.push(JSON.stringify(merged));
+    }
+    this.sink.write(level, parts.join(" "));
+  }
+};
+var logger = new Logger();
+function configureLogger(options) {
+  if (options.level !== void 0) logger.level = options.level;
+  if (options.format !== void 0) logger.format = options.format;
+}
+
+// src/providers/errors.ts
+function kindToCode(kind) {
+  switch (kind) {
+    case "AUTHENTICATION_ERROR":
+      return "PROVIDER_AUTH_FAILED";
+    case "MODEL_NOT_FOUND":
+      return "MODEL_NOT_FOUND";
+    default:
+      return "PROVIDER_UNAVAILABLE";
+  }
+}
+function isRetryable(kind) {
+  return kind === "RATE_LIMIT_ERROR" || kind === "SERVER_ERROR" || kind === "NETWORK_ERROR";
+}
+function kindFromStatus(status) {
+  if (status === 401 || status === 403) return "AUTHENTICATION_ERROR";
+  if (status === 429) return "RATE_LIMIT_ERROR";
+  if (status === 404) return "MODEL_NOT_FOUND";
+  if (status === 408 || status === 504) return "TIMEOUT";
+  if (status >= 500) return "SERVER_ERROR";
+  if (status >= 400) return "INVALID_REQUEST";
+  return "UNKNOWN_ERROR";
+}
+function extractMessage(body) {
+  if (body === null || typeof body !== "object") return void 0;
+  const root = body;
+  const error = root.error ?? root;
+  const message = error.message ?? error.detail ?? root.message;
+  return typeof message === "string" ? message : void 0;
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - now);
+}
+function isTimeoutError(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError") || typeof error?.code === "string" && error.code === "ABORT_ERR";
+}
+function isNetworkError(error) {
+  return error instanceof TypeError || typeof error?.cause === "object" && error instanceof Error && !error.code;
+}
+function fallbackMessage(kind, context, status) {
+  const { provider, operation } = context;
+  switch (kind) {
+    case "AUTHENTICATION_ERROR":
+      return `Authentication with provider "${provider}" failed (HTTP ${status}). Check that the referenced API key is set and valid.`;
+    case "RATE_LIMIT_ERROR":
+      return `Provider "${provider}" rate-limited ${operation} (HTTP ${status}). Retry later.`;
+    case "MODEL_NOT_FOUND":
+      return `Provider "${provider}" does not expose the requested model (HTTP ${status}).`;
+    case "TIMEOUT":
+      return `Provider "${provider}" timed out during ${operation} (HTTP ${status}).`;
+    case "SERVER_ERROR":
+      return `Provider "${provider}" returned a server error during ${operation} (HTTP ${status}).`;
+    case "INVALID_REQUEST":
+      return `Provider "${provider}" rejected ${operation} as invalid (HTTP ${status}).`;
+    default:
+      return `Provider "${provider}" failed during ${operation} (HTTP ${status}).`;
+  }
+}
+function providerHttpError(context) {
+  const status = context.status ?? 0;
+  const kind = kindFromStatus(status);
+  const detail = extractMessage(context.body);
+  const retryAfterMs = context.retryAfterMs ?? parseRetryAfter(void 0);
+  return new ProviderError(
+    context.code ?? kindToCode(kind),
+    detail ?? fallbackMessage(kind, context, status),
+    {
+      cause: context.cause,
+      details: {
+        kind,
+        provider: context.provider,
+        operation: context.operation,
+        status,
+        retryable: isRetryable(kind),
+        ...retryAfterMs !== void 0 ? { retryAfterMs } : {},
+        ...detail ? { providerMessage: detail } : {}
+      }
+    }
+  );
+}
+function providerTransportError(context) {
+  const cause = context.cause;
+  const kind = isTimeoutError(cause) ? "TIMEOUT" : cause instanceof SyntaxError || cause?.name === "HttpResponseError" ? "UNKNOWN_ERROR" : "NETWORK_ERROR";
+  const message = context.cause instanceof Error ? context.cause.message : String(context.cause);
+  return new ProviderError("PROVIDER_UNAVAILABLE", `Provider request failed: ${message}`, {
+    cause: context.cause,
+    details: {
+      kind,
+      provider: context.provider,
+      operation: context.operation,
+      retryable: isRetryable(kind)
+    }
+  });
+}
+
+// src/providers/openai-compatible/index.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var OpenAICompatibleProvider = class {
+  config;
+  providerId;
+  authentication;
+  log;
+  /** Discovered models, so getModel() answers without another round-trip. */
+  discovered;
+  env;
+  audit;
+  constructor(config, log = logger, env = process.env, audit) {
+    this.audit = audit;
+    this.config = { ...config, baseUrl: normalizeBaseUrl(config.baseUrl) };
+    this.env = env;
+    this.providerId = config.providerId ?? config.name;
+    this.authentication = {
+      method: config.apiKeyEnvVar ? "bearer" : "none",
+      ...config.apiKeyEnvVar ? { envVar: config.apiKeyEnvVar } : {},
+      configured: config.apiKeyEnvVar ? Boolean(env[config.apiKeyEnvVar]) : true
+    };
+    this.log = log.child({ provider: config.name });
+  }
+  /** Provider-level request timeout (roadmap §6.6/§11) with the shared default. */
+  get requestTimeoutMs() {
+    return this.config.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  /** Authenticate + discover (roadmap §10, Model Discovery). */
+  async connect() {
+    authHeaders(this.config, this.env);
+    const models = await this.listModels();
+    this.discovered = models;
+    return models;
+  }
+  async getModel(modelId) {
+    const models = this.discovered ?? await this.connect();
+    return models.find((m) => m.id === modelId);
+  }
+  /** Raw /models body (protected so adapters can capture gateway-level metadata). */
+  async rawModelsResponse() {
+    const response = await this.modelsRequest();
+    return response.body;
+  }
+  async modelsRequest() {
+    let response;
+    try {
+      response = await requestJson(`${this.config.baseUrl}/models`, {
+        headers: authHeaders(this.config, this.env),
+        timeoutMs: this.requestTimeoutMs
+      });
+    } catch (error) {
+      if (error instanceof ProviderError) {
+        await this.recordProviderError("listModels", error);
+        throw error;
+      }
+      const normalized = providerTransportError({
+        provider: this.config.name,
+        operation: "listModels",
+        cause: error
+      });
+      await this.recordProviderError("listModels", normalized);
+      throw normalized;
+    }
+    const { status, body } = response;
+    if (status !== 200) {
+      const httpError = providerHttpError({
+        provider: this.config.name,
+        operation: "listModels",
+        status,
+        body
+      });
+      await this.recordProviderError("listModels", httpError);
+      throw httpError;
+    }
+    return response;
+  }
+  async listModels() {
+    const body = await this.rawModelsResponse();
+    const entries = extractModelEntries(body, this.config);
+    const models = [];
+    let skipped = 0;
+    for (const entry of entries) {
+      if (typeof entry.id !== "string" || entry.id.length === 0) {
+        skipped += 1;
+        continue;
+      }
+      models.push(this.toModelInfo(entry));
+    }
+    if (skipped > 0) {
+      this.log.warn(`Skipped ${skipped} model entr(y/ies) without a valid id.`);
+    }
+    return models;
+  }
+  /** Maps a raw model entry onto the normalized metadata shape (§10). */
+  toModelInfo(entry) {
+    const parameters = Array.isArray(entry.supported_parameters) ? entry.supported_parameters.filter((p) => typeof p === "string") : void 0;
+    const contextWindow = typeof entry.context_length === "number" ? entry.context_length : typeof entry.context_window === "number" ? entry.context_window : void 0;
+    const inputTypes = normalizeModalities(entry.input_modalities);
+    const outputTypes = normalizeModalities(entry.output_modalities);
+    return {
+      provider: this.config.name,
+      id: entry.id,
+      displayName: entry.id,
+      ...typeof entry.name === "string" ? { name: entry.name } : {},
+      status: "available",
+      ...contextWindow !== void 0 ? { contextWindow } : {},
+      ...inputTypes !== void 0 ? { inputTypes } : {},
+      ...outputTypes !== void 0 ? { outputTypes } : {},
+      ...parameters !== void 0 ? {
+        supportsTools: parameters.includes("tools") || parameters.includes("tool_choice"),
+        supportsStructuredOutput: parameters.includes("response_format"),
+        supportsStreaming: parameters.includes("stream")
+      } : {},
+      metadata: {
+        ...typeof entry.owned_by === "string" ? { ownedBy: entry.owned_by } : {},
+        ...typeof entry.created === "number" ? { createdAt: entry.created } : {},
+        ...parameters !== void 0 ? { supportedParameters: parameters } : {}
+      }
+    };
+  }
+  /** Streaming where the gateway supports it (§11). */
+  stream(request, onChunk) {
+    return streamChatCompletion(this.config, request, onChunk, this.env);
+  }
+  /** Provider errors are part of the audit trail (§14 correlation, §18 observability). */
+  async recordProviderError(operation, error) {
+    await this.audit?.record({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "provider.error",
+      id: this.providerId,
+      providerId: this.providerId,
+      detail: {
+        operation,
+        code: error.code,
+        kind: error.details?.kind,
+        message: error.message
+      }
+    });
+  }
+  async healthCheck() {
+    const lastCheckedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const started = Date.now();
+      const models = await this.listModels();
+      return {
+        name: this.config.name,
+        type: this.config.type,
+        baseUrl: this.config.baseUrl,
+        health: "healthy",
+        connected: true,
+        modelCount: models.length,
+        lastCheckedAt,
+        message: `Discovered ${models.length} model(s) in ${Date.now() - started}ms.`
+      };
+    } catch (error) {
+      return {
+        name: this.config.name,
+        type: this.config.type,
+        baseUrl: this.config.baseUrl,
+        health: inferHealth(error),
+        connected: false,
+        modelCount: 0,
+        lastCheckedAt,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async chat(request) {
+    let response;
+    try {
+      response = await requestJson(`${this.config.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: authHeaders(this.config, this.env),
+        timeoutMs: this.requestTimeoutMs,
+        body: {
+          model: request.model,
+          messages: request.messages,
+          ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+          ...request.maxTokens !== void 0 ? { max_tokens: request.maxTokens } : {},
+          ...request.stop !== void 0 ? { stop: request.stop } : {}
+        }
+      });
+    } catch (error) {
+      if (error instanceof ProviderError) {
+        await this.recordProviderError("chat", error);
+        throw error;
+      }
+      const normalized = providerTransportError({ provider: this.config.name, operation: "chat", cause: error });
+      await this.recordProviderError("chat", normalized);
+      throw normalized;
+    }
+    const { status, body } = response;
+    if (status !== 200) {
+      const httpError = providerHttpError({
+        provider: this.config.name,
+        operation: "chat",
+        status,
+        body,
+        ...status === 404 ? {
+          code: "MODEL_NOT_FOUND"
+        } : {}
+      });
+      await this.recordProviderError("chat", httpError);
+      throw httpError;
+    }
+    const payload = body;
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    const first = choices[0];
+    if (!first || typeof first.message?.content !== "string") {
+      throw unavailable(this.config, "Chat completion response had no message content.", status);
+    }
+    const usage = payload.usage ?? {};
+    return {
+      model: typeof payload.model === "string" ? payload.model : request.model,
+      content: first.message.content,
+      finishReason: typeof first.finish_reason === "string" ? first.finish_reason : void 0,
+      usage: {
+        promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : void 0,
+        completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : void 0,
+        totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : void 0
+      },
+      raw: body
+    };
+  }
+};
+async function streamChatCompletion(config, request, onChunk, env = process.env) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const timeoutMs = config.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        accept: "text/event-stream",
+        "content-type": "application/json",
+        ...authHeaders(config, env)
+      },
+      body: JSON.stringify({
+        model: request.model,
+        messages: request.messages,
+        stream: true,
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+        ...request.maxTokens !== void 0 ? { max_tokens: request.maxTokens } : {}
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    throw providerTransportError({ provider: config.name, operation: "stream", cause: error });
+  }
+  if (!response.ok) {
+    const body = await response.json().catch(() => void 0);
+    throw providerHttpError({ provider: config.name, operation: "stream", status: response.status, body });
+  }
+  if (!response.body) {
+    throw providerHttpError({
+      provider: config.name,
+      operation: "stream",
+      status: 500,
+      body: { error: { message: "streaming is not supported by this endpoint" } }
+    });
+  }
+  let content = "";
+  let model = request.model;
+  let finishReason;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const piece of response.body) {
+    buffer += decoder.decode(piece, { stream: true });
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+      if (line.length === 0 || line.startsWith(":")) continue;
+      const data = line.startsWith("data:") ? line.slice(5).trim() : line;
+      if (data === "[DONE]") continue;
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (typeof event.model === "string") model = event.model;
+      const choices = Array.isArray(event.choices) ? event.choices : [];
+      const first = choices[0];
+      const delta = typeof first?.delta?.content === "string" ? first.delta.content : "";
+      if (delta.length > 0) content += delta;
+      if (typeof first?.finish_reason === "string") finishReason = first.finish_reason;
+      onChunk({ delta, ...finishReason !== void 0 ? { finishReason } : {}, raw: event });
+    }
+  }
+  return { model, content, ...finishReason !== void 0 ? { finishReason } : {} };
+}
+function normalizeModalities(value) {
+  const list = Array.isArray(value) ? value : typeof value === "string" ? [value] : void 0;
+  if (!list) return void 0;
+  const allowed = /* @__PURE__ */ new Set(["text", "image", "audio", "video", "embedding"]);
+  const modalities = list.filter((m) => typeof m === "string" && allowed.has(m));
+  return modalities.length > 0 ? modalities : void 0;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function extractModelEntries(body, config) {
+  if (Array.isArray(body)) return body;
+  if (body !== null && typeof body === "object" && Array.isArray(body.data)) {
+    return body.data;
+  }
+  throw new ProviderError(
+    "PROVIDER_UNAVAILABLE",
+    `Provider "${config.name}" returned an unrecognized model list shape.`,
+    { details: { endpoint: "models" } }
+  );
+}
+function unavailable(config, message, status) {
+  return new ProviderError("PROVIDER_UNAVAILABLE", `Provider "${config.name}": ${message}`, {
+    details: { status }
+  });
+}
+function inferHealth(error) {
+  const status = error instanceof ProviderError && typeof error.details?.status === "number" ? error.details.status : void 0;
+  return status !== void 0 && status >= 500 ? "degraded" : "unreachable";
+}
+
+// src/providers/omnihilbras/index.ts
+var OmniHilbrasProvider = class extends OpenAICompatibleProvider {
+  gateway;
+  async listModels() {
+    const raw = await this.rawModelsResponse();
+    await this.extractGatewayMetadata(raw);
+    const models = await super.listModels();
+    return this.gateway ? models.map((model) => ({ ...model, metadata: { ...model.metadata, gateway: this.gateway } })) : models;
+  }
+  /**
+   * Run the full connect flow. Throws on authentication or transport failure
+   * (use healthCheck() for a non-throwing probe).
+   */
+  /**
+   * Gateway metadata reported alongside the model list (gateway version, tier,
+   * region…), kept separate from per-model metadata (§11 — provider metadata).
+   */
+  gatewayMetadata() {
+    return this.gateway;
+  }
+  async extractGatewayMetadata(body) {
+    if (body !== null && typeof body === "object") {
+      const gateway = body.gateway;
+      if (gateway !== null && typeof gateway === "object") {
+        this.gateway = gateway;
+      }
+    }
+  }
+  async connectAndRegister(registry) {
+    const apiKey = resolveApiKey(this.config);
+    const discovered = await this.listModels();
+    const seen = /* @__PURE__ */ new Set();
+    const models = [];
+    const duplicates = [];
+    for (const model of discovered) {
+      if (seen.has(model.id)) {
+        duplicates.push(model.id);
+        continue;
+      }
+      seen.add(model.id);
+      models.push({
+        ...model,
+        provider: this.config.name,
+        status: "available",
+        metadata: { ...model.metadata, gateway: "omnihilbras" }
+      });
+    }
+    if (registry) {
+      for (const model of models) registry.register(model);
+    }
+    const message = `Authenticated${apiKey ? " with API key" : " (no API key configured)"}; validated ${models.length} unique model(s)` + (duplicates.length > 0 ? `, skipped ${duplicates.length} duplicate(s)` : "") + ".";
+    const status = {
+      name: this.config.name,
+      type: this.config.type,
+      baseUrl: this.config.baseUrl,
+      health: "healthy",
+      connected: true,
+      modelCount: models.length,
+      lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      message
+    };
+    return { status, models, duplicates, registered: registry ? models.length : 0 };
+  }
+};
+
+// src/providers/factory.ts
+var OPENAI_COMPATIBLE_TYPES = [
+  "openai-compatible",
+  "openrouter",
+  "local",
+  "custom"
+];
+function createProvider(config, options = {}) {
+  const shared = {
+    ...options.env !== void 0 ? { env: options.env } : {},
+    ...options.audit !== void 0 ? { audit: options.audit } : {}
+  };
+  if (config.type === "omnihilbras") {
+    return new OmniHilbrasProvider(config, void 0, options.env, options.audit);
+  }
+  if (OPENAI_COMPATIBLE_TYPES.includes(config.type)) {
+    return new OpenAICompatibleProvider(config, void 0, options.env, options.audit);
+  }
+  void shared;
+  throw new OmniNodeError("NOT_IMPLEMENTED", `Provider type "${config.type}" has no adapter yet.`);
+}
+
+export {
+  OmniNodeError,
+  ConfigError,
+  ProviderError,
+  AgentError,
+  TaskError,
+  PipelineError,
+  PlannerError,
+  MemoryError,
+  isOmniNodeError,
+  logger,
+  configureLogger,
+  resolveApiKey,
+  authHeaders,
+  requestJson,
+  isRetryable,
+  kindFromStatus,
+  extractMessage,
+  parseRetryAfter,
+  isTimeoutError,
+  isNetworkError,
+  providerHttpError,
+  providerTransportError,
+  OpenAICompatibleProvider,
+  OmniHilbrasProvider,
+  OPENAI_COMPATIBLE_TYPES,
+  createProvider
+};
+//# sourceMappingURL=chunk-6Z6O63SS.js.map