@irogane/kaji 0.2.0-beta.11

package/dist/openai.cjs

@@ -0,0 +1,1235 @@
+'use strict';
+
+// src/events/json.ts
+function cloneAndFreezeJson(value) {
+  return cloneJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+function canonicalJsonValue(value, subject = "JSON value") {
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  const assertUnicodeScalarString = (text) => {
+    for (let index = 0; index < text.length; index += 1) {
+      const unit = text.charCodeAt(index);
+      if (unit >= 55296 && unit <= 56319) {
+        const next = text.charCodeAt(index + 1);
+        if (!(next >= 56320 && next <= 57343)) {
+          throw new TypeError(`${subject} contains an unpaired Unicode surrogate`);
+        }
+        index += 1;
+      } else if (unit >= 56320 && unit <= 57343) {
+        throw new TypeError(`${subject} contains an unpaired Unicode surrogate`);
+      }
+    }
+  };
+  const encode = (item) => {
+    if (item === null) return "null";
+    switch (typeof item) {
+      case "boolean":
+        return item ? "true" : "false";
+      case "string":
+        assertUnicodeScalarString(item);
+        return JSON.stringify(item);
+      case "number":
+        if (!Number.isFinite(item)) throw new TypeError(`${subject} contains a non-finite number`);
+        if (Number.isInteger(item) && !Number.isSafeInteger(item)) {
+          throw new TypeError(`${subject} contains an integer outside the I-JSON safe range`);
+        }
+        return Object.is(item, -0) ? "0" : item.toString();
+      case "object": {
+        if (ancestors.has(item)) throw new TypeError(`${subject} must be acyclic`);
+        if (Object.getOwnPropertySymbols(item).length > 0) {
+          throw new TypeError(`${subject} JSON object keys must be strings`);
+        }
+        ancestors.add(item);
+        try {
+          if (Array.isArray(item)) {
+            const descriptors = Object.getOwnPropertyDescriptors(item);
+            const values = [];
+            for (let index = 0; index < item.length; index += 1) {
+              const descriptor = descriptors[String(index)];
+              if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+                throw new TypeError(`${subject} array values must be enumerable data values`);
+              }
+              values.push(encode(descriptor.value));
+            }
+            for (const key of Object.keys(descriptors)) {
+              if (key === "length") continue;
+              const index = Number(key);
+              if (Number.isInteger(index) && index >= 0 && index < item.length && String(index) === key) {
+                continue;
+              }
+              throw new TypeError(`${subject} arrays cannot carry named properties`);
+            }
+            return `[${values.join(",")}]`;
+          }
+          const prototype = Object.getPrototypeOf(item);
+          if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError(`${subject} contains a non-plain object`);
+          }
+          const keys = Object.getOwnPropertyNames(item);
+          for (const key of keys) {
+            assertUnicodeScalarString(key);
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+              throw new TypeError(
+                `${subject} JSON object properties must be enumerable data values`
+              );
+            }
+          }
+          return `{${keys.sort().map((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            return `${JSON.stringify(key)}:${encode(descriptor.value)}`;
+          }).join(",")}}`;
+        } finally {
+          ancestors.delete(item);
+        }
+      }
+      default:
+        throw new TypeError(`${subject} contains non-JSON value ${typeof item}`);
+    }
+  };
+  return encode(value);
+}
+function cloneJsonValue(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new TypeError("Event values must be JSON-safe");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    enter(value, ancestors);
+    const clone = value.map((item) => cloneJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return Object.freeze(clone);
+  }
+  if (typeof value === "object") {
+    assertJsonObject(value);
+    enter(value, ancestors);
+    const clone = {};
+    for (const [key, child] of Object.entries(value)) {
+      Object.defineProperty(clone, key, {
+        value: cloneJsonValue(child, ancestors),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    ancestors.delete(value);
+    return Object.freeze(clone);
+  }
+  throw new TypeError("Event values must be JSON-safe");
+}
+function assertJsonObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null || Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError("Event values must be JSON-safe");
+  }
+}
+function enter(value, ancestors) {
+  if (ancestors.has(value)) throw new TypeError("Event values must be JSON-safe and acyclic");
+  ancestors.add(value);
+}
+
+// src/runtime/cancellation.ts
+var CancellationError = class extends Error {
+  constructor(message = "Agent run was cancelled") {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+function throwIfCancellationRequested(token) {
+  if (!token?.isCancelled) return;
+  if (typeof token.throwIfCancelled === "function") {
+    token.throwIfCancelled();
+  }
+  throw new CancellationError();
+}
+
+// src/observability.ts
+var METRIC_UNITS = Object.freeze({
+  "kaji.turn.queue_wait_ms": "ms",
+  "kaji.turn.duration_ms": "ms",
+  "kaji.turn.iterations": "count",
+  "kaji.provider.duration_ms": "ms",
+  "kaji.provider.retries": "count",
+  "kaji.replay.input_events": "count",
+  "kaji.context.messages": "count",
+  "kaji.context.characters": "count",
+  "kaji.tool.queue_wait_ms": "ms",
+  "kaji.tool.active": "gauge",
+  "kaji.tool.duration_ms": "ms",
+  "kaji.journal.failures": "count",
+  "kaji.subscriber.lag_events": "count",
+  "kaji.subscriber.overflow": "count",
+  "kaji.integration.auth_ms": "ms",
+  "kaji.integration.request_ms": "ms"
+});
+Object.freeze(
+  Object.keys(METRIC_UNITS)
+);
+var ALLOWED_LABELS = Object.freeze({
+  "kaji.turn.queue_wait_ms": [],
+  "kaji.turn.duration_ms": ["outcome"],
+  "kaji.turn.iterations": ["outcome"],
+  "kaji.provider.duration_ms": ["provider_family", "status"],
+  "kaji.provider.retries": ["provider_family"],
+  "kaji.replay.input_events": [],
+  "kaji.context.messages": [],
+  "kaji.context.characters": [],
+  "kaji.tool.queue_wait_ms": ["outcome"],
+  "kaji.tool.active": [],
+  "kaji.tool.duration_ms": ["outcome", "error_code"],
+  "kaji.journal.failures": ["stage"],
+  "kaji.subscriber.lag_events": [],
+  "kaji.subscriber.overflow": ["stage"],
+  "kaji.integration.auth_ms": ["integration", "operation", "outcome"],
+  "kaji.integration.request_ms": ["integration", "operation", "outcome"]
+});
+var STABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "NONE",
+  "OTHER",
+  "INVALID_TOOL_SCHEMA",
+  "INVALID_TOOL_ARGUMENTS",
+  "UNCLASSIFIED_TOOL_RISK",
+  "MISSING_TOOL_IDENTITY",
+  "TOOL_NOT_ALLOWED",
+  "APPROVAL_UNAVAILABLE",
+  "APPROVAL_REJECTED",
+  "APPROVAL_TIMEOUT",
+  "TOOL_CANCELLED",
+  "TOOL_TIMEOUT",
+  "TURN_TIMEOUT",
+  "TOOL_EXECUTION_FAILED",
+  "TOOL_START_RECORD_FAILED",
+  "IDEMPOTENCY_CAPACITY_EXCEEDED",
+  "IDEMPOTENCY_CONFLICT",
+  "INTEGRATION_AUTH_ERROR",
+  "INTEGRATION_AUTH_REQUIRED",
+  "INTEGRATION_API_ERROR",
+  "INTEGRATION_POLICY_REJECTED",
+  "INTEGRATION_RATE_LIMITED",
+  "INTEGRATION_REDIRECT_REJECTED",
+  "INTEGRATION_RESPONSE_LIMIT"
+]);
+function validLabel(key, value) {
+  if (typeof value !== "string") return false;
+  const text = value;
+  if (key === "provider_family") {
+    return text === "openai" || text === "anthropic" || text === "custom";
+  }
+  if (key === "status") {
+    return text === "success" || text === "cancelled" || text === "error";
+  }
+  if (key === "stage") {
+    return ["append", "publish", "lag", "overflow"].includes(text);
+  }
+  if (key === "error_code") return STABLE_ERROR_CODES.has(text);
+  if (key === "outcome") {
+    return [
+      "acquired",
+      "completed",
+      "failed",
+      "cancelled",
+      "timeout",
+      "not_started",
+      "unknown",
+      "success",
+      "error"
+    ].includes(text);
+  }
+  if (key === "integration") return text === "github" || text === "gmail";
+  if (key === "operation") return ["read", "mutation", "token"].includes(text);
+  return false;
+}
+function recordMetric(sink, name, value, labels) {
+  if (!Number.isFinite(value)) return;
+  if (sink === NOOP_METRICS) return;
+  if (!Object.hasOwn(METRIC_UNITS, name)) return;
+  const sanitized = {};
+  const allowed = ALLOWED_LABELS[name];
+  const supplied = Object.keys(labels);
+  if (supplied.length !== allowed.length || supplied.some((key) => !allowed.includes(key))) return;
+  for (const key of allowed) {
+    const raw = labels[key];
+    if (!validLabel(key, raw)) return;
+    sanitized[key] = raw;
+  }
+  const measurement = Object.freeze({
+    name,
+    value,
+    unit: METRIC_UNITS[name],
+    labels: Object.freeze(sanitized)
+  });
+  try {
+    const pending = sink.record(measurement);
+    if (pending !== void 0) void Promise.resolve(pending).catch(() => void 0);
+  } catch {
+  }
+}
+var NOOP_METRICS = Object.freeze({ record: () => {
+} });
+
+// src/providers/base.ts
+var PROVIDER_RESPONSE_DIAGNOSTICS = /* @__PURE__ */ Symbol.for(
+  "kaji.provider.responseDiagnostics"
+);
+function getProviderResponseDiagnostics(options) {
+  return options?.[PROVIDER_RESPONSE_DIAGNOSTICS];
+}
+var DEFAULT_PROVIDER_RESPONSE_LIMITS = Object.freeze({
+  textMaxBytes: 262144,
+  toolArgumentsMaxBytes: 65536,
+  responseMaxBytes: 524288,
+  toolCallsMax: 64
+});
+function resolveProviderResponseLimits(limits) {
+  const resolved = { ...DEFAULT_PROVIDER_RESPONSE_LIMITS, ...limits };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new RangeError(`${name} must be a positive safe integer`);
+    }
+  }
+  return Object.freeze(resolved);
+}
+function parseRetryAfterMs(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const headers = "headers" in error ? error.headers : "response" in error && typeof error.response === "object" ? error.response?.headers ?? null : null;
+  if (typeof headers !== "object" || headers === null) return void 0;
+  const retryAfter = headers["retry-after"];
+  if (!retryAfter) return void 0;
+  const seconds = Number(retryAfter);
+  return Number.isFinite(seconds) ? seconds * 1e3 : void 0;
+}
+async function withRetry(fn, retry, cancellationToken, metricsSink = NOOP_METRICS, providerFamily = "custom") {
+  const { maxAttempts, baseDelayMs } = retry;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    throwIfCancellationRequested(cancellationToken);
+    try {
+      return await fn();
+    } catch (error) {
+      const statusCode = typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
+      if (statusCode !== 429 || attempt === maxAttempts) {
+        throw error;
+      }
+      const retryAfterMs = parseRetryAfterMs(error) ?? baseDelayMs * 2 ** (attempt - 1);
+      recordMetric(metricsSink, "kaji.provider.retries", 1, {
+        provider_family: providerFamily
+      });
+      lastError = error;
+      await cancellableDelay(retryAfterMs, cancellationToken);
+    }
+  }
+  throw lastError;
+}
+async function openStreamWithRetry(create, retry, cancellationToken, metricsSink = NOOP_METRICS, providerFamily = "custom") {
+  const opened = await withRetry(
+    async () => {
+      const stream = await create();
+      const iterator = stream[Symbol.asyncIterator]();
+      try {
+        return { iterator, first: await iterator.next() };
+      } catch (error) {
+        try {
+          await iterator.return?.();
+        } catch {
+        }
+        throw error;
+      }
+    },
+    retry,
+    cancellationToken,
+    metricsSink,
+    providerFamily
+  );
+  return new BufferedAsyncIterator(opened.iterator, opened.first);
+}
+var BufferedAsyncIterator = class {
+  constructor(inner, first) {
+    this.inner = inner;
+    this.first = first;
+  }
+  inner;
+  first;
+  firstPending = true;
+  closed = false;
+  closePromise;
+  async next() {
+    if (this.closed) return { value: void 0, done: true };
+    if (this.firstPending) {
+      this.firstPending = false;
+      if (this.first.done) this.markNaturallyClosed();
+      return this.first;
+    }
+    try {
+      const next = await this.inner.next();
+      if (next.done) this.markNaturallyClosed();
+      return next;
+    } catch (error) {
+      try {
+        await this.close();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async return(value) {
+    await this.close();
+    return { value, done: true };
+  }
+  async throw(error) {
+    await this.close();
+    throw error;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  markNaturallyClosed() {
+    this.closed = true;
+    this.closePromise = Promise.resolve();
+  }
+  close() {
+    if (this.closePromise !== void 0) return this.closePromise;
+    this.closed = true;
+    this.firstPending = false;
+    try {
+      const result = this.inner.return?.();
+      this.closePromise = Promise.resolve(result).then(() => void 0);
+    } catch (error) {
+      this.closePromise = Promise.reject(error);
+    }
+    return this.closePromise;
+  }
+};
+async function cancellableDelay(delayMs, cancellationToken) {
+  throwIfCancellationRequested(cancellationToken);
+  if (cancellationToken === void 0) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return;
+  }
+  const signal = cancellationToken?.signal;
+  if (signal === void 0) {
+    const deadline = globalThis.performance.now() + delayMs;
+    while (globalThis.performance.now() < deadline) {
+      throwIfCancellationRequested(cancellationToken);
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(10, deadline - globalThis.performance.now()))
+      );
+    }
+    throwIfCancellationRequested(cancellationToken);
+    return;
+  }
+  if (signal.aborted) throw new CancellationError();
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(new CancellationError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/providers/errors.ts
+var PROVIDER_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderError.v1");
+var PROVIDER_CONFIG_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderConfigError.v1");
+var PROVIDER_API_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderAPIError.v1");
+var PROVIDER_CONNECTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderConnectionError.v1");
+var PROVIDER_RATE_LIMITED_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderRateLimitedError.v1");
+var PROVIDER_OUTPUT_LIMIT_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderOutputLimitError.v1");
+function brand(value, key) {
+  Object.defineProperty(value, key, { value: true });
+}
+function hasBrand(value, key) {
+  return typeof value === "object" && value !== null && Reflect.get(value, key) === true;
+}
+var ProviderError = class extends Error {
+  service;
+  action;
+  statusCode;
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message);
+    brand(this, PROVIDER_ERROR_BRAND);
+    this.name = new.target.name;
+    this.service = options.service ?? "provider";
+    this.action = options.action ?? "request";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+  }
+};
+var ProviderConfigError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_CONFIG_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: "configure" });
+    brand(this, PROVIDER_CONFIG_ERROR_BRAND);
+  }
+};
+var ProviderAPIError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_API_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: options.action ?? "api call" });
+    brand(this, PROVIDER_API_ERROR_BRAND);
+  }
+};
+var ProviderConnectionError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_CONNECTION_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: options.action ?? "connect" });
+    brand(this, PROVIDER_CONNECTION_ERROR_BRAND);
+  }
+};
+var ProviderRateLimitedError = class extends ProviderError {
+  retryAfterMs;
+  attempts;
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_RATE_LIMITED_ERROR_BRAND);
+  }
+  constructor(message, options) {
+    super(message, { ...options, action: "api call", statusCode: 429 });
+    brand(this, PROVIDER_RATE_LIMITED_ERROR_BRAND);
+    this.retryAfterMs = options.retryAfterMs;
+    this.attempts = options.attempts;
+  }
+};
+var ProviderOutputLimitError = class extends Error {
+  constructor(dimension, limit) {
+    if (!["text", "tool_arguments", "total_response", "tool_calls"].includes(dimension)) {
+      throw new TypeError("unknown provider output dimension");
+    }
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new RangeError("provider output limit must be a positive safe integer");
+    }
+    const unit = dimension === "tool_calls" ? "calls" : "bytes";
+    super(`Provider output exceeded ${dimension} limit of ${limit} ${unit}`);
+    this.dimension = dimension;
+    this.limit = limit;
+    brand(this, PROVIDER_OUTPUT_LIMIT_ERROR_BRAND);
+    this.name = "ProviderOutputLimitError";
+  }
+  dimension;
+  limit;
+  code = "PROVIDER_OUTPUT_LIMIT";
+  phase = "provider_stream";
+  retryable = false;
+  outcome = "unknown";
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_OUTPUT_LIMIT_ERROR_BRAND);
+  }
+};
+function errorStatusCode(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const status = "status" in error ? error.status : void 0;
+  const statusCode = "statusCode" in error ? error.statusCode : void 0;
+  return typeof status === "number" ? status : typeof statusCode === "number" ? statusCode : void 0;
+}
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EAI_AGAIN",
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "ETIMEDOUT",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+var NETWORK_ERROR_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "APIConnectionError",
+  "APIConnectionTimeoutError",
+  "APITimeoutError"
+]);
+function isNetworkError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const code = "code" in error ? error.code : void 0;
+  const constructorName = error.constructor?.name;
+  return typeof code === "string" && NETWORK_ERROR_CODES.has(code) || typeof constructorName === "string" && NETWORK_ERROR_TYPE_NAMES.has(constructorName);
+}
+function providerAPIErrorFromUnknown(service, error, action = "request") {
+  if (error instanceof ProviderConfigError) {
+    return new ProviderConfigError(`${service} configuration failed`, {
+      service,
+      statusCode: error.statusCode
+    });
+  }
+  if (error instanceof ProviderConnectionError) {
+    return new ProviderConnectionError(`${service} ${action} failed due to a network error`, {
+      service,
+      action,
+      statusCode: error.statusCode
+    });
+  }
+  if (error instanceof ProviderRateLimitedError) {
+    return new ProviderRateLimitedError(`${service} rate limit exceeded`, {
+      service,
+      retryAfterMs: error.retryAfterMs,
+      attempts: error.attempts
+    });
+  }
+  if (error instanceof ProviderError) {
+    return new ProviderAPIError(`${service} ${action} failed`, {
+      service,
+      action,
+      statusCode: error.statusCode
+    });
+  }
+  if (isNetworkError(error)) {
+    return new ProviderConnectionError(`${service} ${action} failed due to a network error`, {
+      service,
+      action
+    });
+  }
+  return new ProviderAPIError(`${service} ${action} failed`, {
+    service,
+    action,
+    statusCode: errorStatusCode(error)
+  });
+}
+
+// src/providers/args.ts
+function jsonTypeName(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function isJsonObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseToolArgsJSON(raw, providerLabel) {
+  if (raw === void 0 || raw === null || raw === "") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isJsonObjectRecord(parsed)) {
+      return {
+        __parse_error: `${providerLabel} tool args must be a JSON object, got ${jsonTypeName(parsed)}`
+      };
+    }
+    return parsed;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { __parse_error: `${providerLabel} tool args were not valid JSON: ${msg}` };
+  }
+}
+
+// src/providers/costs.ts
+var COST_TABLE = {
+  "gpt-5.4-mini": { inputPer1M: 0.75, outputPer1M: 4.5 },
+  "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15 },
+  "gemini-2.5-flash": { inputPer1M: 0.3, outputPer1M: 2.5 },
+  "gemini-3.5-flash": { inputPer1M: 1.5, outputPer1M: 9 }
+};
+var SNAPSHOT_SUFFIX = /-(?:[0-9]{4}-[0-9]{2}-[0-9]{2}|[0-9]{8}|[0-9]{3})$/;
+var MAX_SAFE_TOKEN_COUNT = 9007199254740991;
+var TOKENS_PER_RATE_UNIT = 1000000n;
+var USD_SCALE = 10000000000n;
+var MAX_RATE_SIGNIFICANT_DIGITS = 32;
+var MAX_RATE_FRACTIONAL_DIGITS = 32;
+var MAX_RATE_ABSOLUTE_EXPONENT = 32n;
+var MAX_RATE_TEXT_LENGTH = 65;
+var DECIMAL_RATE = /^(0|[1-9][0-9]*)(?:\.([0-9]*[1-9]))?$/;
+var SCIENTIFIC_RATE = /^([1-9])(?:\.([0-9]*[1-9]))?e(-?[1-9][0-9]*)$/;
+function assertTokenCount(name, value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+    throw new TypeError(`${name} must be an integer`);
+  }
+  if (value < 0 || value > MAX_SAFE_TOKEN_COUNT) {
+    throw new RangeError(`${name} must be between 0 and ${MAX_SAFE_TOKEN_COUNT}, inclusive`);
+  }
+}
+function boundedExponent(value) {
+  const negative = value.startsWith("-");
+  const digits = value.replace(/^[+-]/, "");
+  const normalized = digits.replace(/^0+/, "") || "0";
+  if (normalized.length > 2) throw new RangeError("cost rate exponent exceeds 32");
+  const magnitude = BigInt(normalized);
+  if (magnitude > MAX_RATE_ABSOLUTE_EXPONENT) {
+    throw new RangeError("cost rate exponent exceeds 32");
+  }
+  const bounded = Number(magnitude);
+  return negative ? -bounded : bounded;
+}
+function numericRateText(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError("cost rate must be a finite number or canonical decimal string");
+  }
+  if (value < 0) throw new RangeError("cost rate must be non-negative");
+  if (value === 0) return "0";
+  const [rawMantissa, exponentText] = value.toString().toLowerCase().split("e");
+  const mantissa = rawMantissa.includes(".") ? rawMantissa.replace(/0+$/, "").replace(/\.$/, "") : rawMantissa;
+  if (exponentText === void 0) return mantissa;
+  const exponent = boundedExponent(exponentText);
+  return exponent === 0 ? mantissa : `${mantissa}e${exponent}`;
+}
+function decimalParts(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new TypeError("cost rate must be a finite number or canonical decimal string");
+  }
+  const source = typeof value === "number" ? numericRateText(value) : value;
+  if (source.length === 0 || source.length > MAX_RATE_TEXT_LENGTH) {
+    throw new RangeError("cost rate exceeds the canonical length bound");
+  }
+  let match = DECIMAL_RATE.exec(source);
+  let exponent = 0;
+  if (!match) {
+    match = SCIENTIFIC_RATE.exec(source);
+    if (!match) throw new TypeError("cost rate is not a canonical non-negative decimal");
+    exponent = boundedExponent(match[3]);
+  }
+  const fraction = match[2] ?? "";
+  const significant = `${match[1]}${fraction}`.replace(/^0+/, "") || "0";
+  if (significant.length > MAX_RATE_SIGNIFICANT_DIGITS) {
+    throw new RangeError("cost rate exceeds 32 significant digits");
+  }
+  if (fraction.length > MAX_RATE_FRACTIONAL_DIGITS) {
+    throw new RangeError("cost rate exceeds 32 fractional digits");
+  }
+  let coefficient = BigInt(`${match[1]}${fraction}`);
+  let scale = fraction.length - exponent;
+  if (scale < 0) {
+    coefficient *= 10n ** BigInt(-scale);
+    scale = 0;
+  }
+  return { coefficient, scale };
+}
+function canonicalUsd(units) {
+  const whole = units / USD_SCALE;
+  const fraction = (units % USD_SCALE).toString().padStart(10, "0").replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole.toString();
+}
+function calculateCostFromRatesUsdCanonical(inputTokens, outputTokens, inputPer1M, outputPer1M) {
+  assertTokenCount("inputTokens", inputTokens);
+  assertTokenCount("outputTokens", outputTokens);
+  const input = decimalParts(inputPer1M);
+  const output = decimalParts(outputPer1M);
+  const rateScale = Math.max(input.scale, output.scale);
+  const numerator = BigInt(inputTokens) * input.coefficient * 10n ** BigInt(rateScale - input.scale) + BigInt(outputTokens) * output.coefficient * 10n ** BigInt(rateScale - output.scale);
+  const denominator = TOKENS_PER_RATE_UNIT * 10n ** BigInt(rateScale);
+  const scaled = numerator * USD_SCALE;
+  let units = scaled / denominator;
+  const remainder = scaled % denominator;
+  const comparison = remainder * 2n - denominator;
+  if (comparison > 0n || comparison === 0n && units % 2n === 1n) units += 1n;
+  return canonicalUsd(units);
+}
+function lookupCost(model) {
+  if (model in COST_TABLE) return COST_TABLE[model];
+  const base = model.replace(SNAPSHOT_SUFFIX, "");
+  return base === model ? void 0 : COST_TABLE[base];
+}
+function calculateCostUsdCanonical(model, inputTokens, outputTokens) {
+  assertTokenCount("inputTokens", inputTokens);
+  assertTokenCount("outputTokens", outputTokens);
+  const entry = lookupCost(model);
+  if (!entry) return "0";
+  return calculateCostFromRatesUsdCanonical(
+    inputTokens,
+    outputTokens,
+    entry.inputPer1M,
+    entry.outputPer1M
+  );
+}
+function calculateCostUsd(model, inputTokens, outputTokens) {
+  return Number(calculateCostUsdCanonical(model, inputTokens, outputTokens));
+}
+
+// src/providers/openai-format.ts
+function toOpenAIChatMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "tool") {
+      return {
+        role: "tool",
+        content: m.content,
+        tool_call_id: m.tool_call_id ?? ""
+      };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: m.content,
+        tool_calls: m.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: JSON.stringify(tc.args ?? {})
+          }
+        }))
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+}
+
+// src/providers/response-budget.ts
+function scanUtf8Scalars(fragment, pendingHighSurrogate) {
+  if (typeof fragment !== "string")
+    throw new TypeError("provider output fragments must be strings");
+  const input = `${pendingHighSurrogate ?? ""}${fragment}`;
+  const scalars = [];
+  let bytes = 0;
+  let pending;
+  for (let index = 0; index < input.length; index += 1) {
+    const unit = input.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      if (index + 1 >= input.length) {
+        pending = input[index];
+        break;
+      }
+      const low = input.charCodeAt(index + 1);
+      if (!(low >= 56320 && low <= 57343)) {
+        throw new TypeError("provider output contains an unpaired Unicode surrogate");
+      }
+      scalars.push({ text: input.slice(index, index + 2), bytes: 4 });
+      bytes += 4;
+      index += 1;
+      continue;
+    }
+    if (unit >= 56320 && unit <= 57343) {
+      throw new TypeError("provider output contains an unpaired Unicode surrogate");
+    }
+    const scalarBytes = unit <= 127 ? 1 : unit <= 2047 ? 2 : 3;
+    scalars.push({ text: input[index], bytes: scalarBytes });
+    bytes += scalarBytes;
+  }
+  return pending === void 0 ? { scalars, bytes } : { scalars, bytes, pendingHighSurrogate: pending };
+}
+function utf8ByteLength(value) {
+  const scan = scanUtf8Scalars(value);
+  if (scan.pendingHighSurrogate !== void 0) {
+    throw new TypeError("provider output contains an unpaired Unicode surrogate");
+  }
+  return scan.bytes;
+}
+var LinearStringParts = class {
+  parts = [];
+  _fragmentCount = 0;
+  _joinOperations = 0;
+  get fragmentCount() {
+    return this._fragmentCount;
+  }
+  get joinOperations() {
+    return this._joinOperations;
+  }
+  append(fragment) {
+    if (!fragment) return;
+    this.parts.push(fragment);
+    this._fragmentCount += 1;
+  }
+  join() {
+    this._joinOperations += 1;
+    return this.parts.join("");
+  }
+};
+var ProviderResponseBudget = class {
+  limits;
+  textBytes = 0;
+  totalBytes = 0;
+  callCount = 0;
+  rawFragments = 0;
+  argumentJoins = 0;
+  textPendingHighSurrogate;
+  rawToolCalls = /* @__PURE__ */ new Map();
+  constructor(limits) {
+    this.limits = resolveProviderResponseLimits(limits);
+  }
+  get diagnostics() {
+    return Object.freeze({
+      textBytes: this.textBytes,
+      totalResponseBytes: this.totalBytes,
+      toolCalls: this.callCount,
+      rawFragments: this.rawFragments,
+      toolArgumentJoinOperations: this.argumentJoins
+    });
+  }
+  get providerDiagnostics() {
+    return Object.freeze({
+      rawFragments: this.rawFragments,
+      toolArgumentJoinOperations: this.argumentJoins
+    });
+  }
+  acceptRaw(input) {
+    const text = input.text ?? "";
+    const textScan = scanUtf8Scalars(text, this.textPendingHighSurrogate);
+    const nextTextBytes = this.textBytes + textScan.bytes;
+    if (nextTextBytes > this.limits.textMaxBytes) {
+      throw new ProviderOutputLimitError("text", this.limits.textMaxBytes);
+    }
+    const nextStates = new Map([...this.rawToolCalls].map(([key, state]) => [key, { ...state }]));
+    let addedTotal = textScan.bytes;
+    let addedCalls = 0;
+    let addedFragments = text ? 1 : 0;
+    for (const fragment of input.toolFragments ?? []) {
+      let state = nextStates.get(fragment.key);
+      if (fragment.startsCall) {
+        if (state !== void 0) throw new TypeError("provider tool call started more than once");
+        state = { argumentBytes: 0 };
+        nextStates.set(fragment.key, state);
+        addedCalls += 1;
+      } else if (state === void 0) {
+        throw new TypeError("provider tool fragment must start a call before appending");
+      }
+      const id = scanUtf8Scalars(fragment.idFragment ?? "", state.idPending);
+      const name = scanUtf8Scalars(fragment.nameFragment ?? "", state.namePending);
+      const args = scanUtf8Scalars(fragment.argumentsFragment ?? "", state.argumentsPending);
+      state.idPending = id.pendingHighSurrogate;
+      state.namePending = name.pendingHighSurrogate;
+      state.argumentsPending = args.pendingHighSurrogate;
+      state.argumentBytes += args.bytes;
+      if (state.argumentBytes > this.limits.toolArgumentsMaxBytes) {
+        throw new ProviderOutputLimitError("tool_arguments", this.limits.toolArgumentsMaxBytes);
+      }
+      addedTotal += id.bytes + name.bytes + args.bytes;
+      addedFragments += Number(Boolean(fragment.idFragment));
+      addedFragments += Number(Boolean(fragment.nameFragment));
+      addedFragments += Number(Boolean(fragment.argumentsFragment));
+    }
+    const nextCalls = this.callCount + addedCalls;
+    if (nextCalls > this.limits.toolCallsMax) {
+      throw new ProviderOutputLimitError("tool_calls", this.limits.toolCallsMax);
+    }
+    const nextTotal = this.totalBytes + addedTotal;
+    if (nextTotal > this.limits.responseMaxBytes) {
+      throw new ProviderOutputLimitError("total_response", this.limits.responseMaxBytes);
+    }
+    this.textBytes = nextTextBytes;
+    this.totalBytes = nextTotal;
+    this.callCount = nextCalls;
+    this.rawFragments += addedFragments;
+    this.textPendingHighSurrogate = textScan.pendingHighSurrogate;
+    this.rawToolCalls = nextStates;
+  }
+  acceptNormalized(delta, toolCalls) {
+    const textScan = scanUtf8Scalars(delta, this.textPendingHighSurrogate);
+    const nextTextBytes = this.textBytes + textScan.bytes;
+    if (nextTextBytes > this.limits.textMaxBytes) {
+      throw new ProviderOutputLimitError("text", this.limits.textMaxBytes);
+    }
+    let addedTotal = textScan.bytes;
+    const serializedCalls = [];
+    for (const call of toolCalls) {
+      const descriptors = Object.getOwnPropertyDescriptors(call);
+      const id = dataProperty(descriptors, "id");
+      const name = dataProperty(descriptors, "name");
+      const args = dataProperty(descriptors, "args");
+      if (typeof id !== "string" || typeof name !== "string") {
+        throw new TypeError("provider tool call id and name must be strings");
+      }
+      const encodedArguments = canonicalJsonValue(args ?? {}, "tool arguments");
+      const argumentBytes = utf8ByteLength(encodedArguments);
+      if (argumentBytes > this.limits.toolArgumentsMaxBytes) {
+        throw new ProviderOutputLimitError("tool_arguments", this.limits.toolArgumentsMaxBytes);
+      }
+      addedTotal += utf8ByteLength(id) + utf8ByteLength(name) + argumentBytes;
+      serializedCalls.push({ id, name, encodedArguments });
+    }
+    const nextCalls = this.callCount + serializedCalls.length;
+    if (nextCalls > this.limits.toolCallsMax) {
+      throw new ProviderOutputLimitError("tool_calls", this.limits.toolCallsMax);
+    }
+    const nextTotal = this.totalBytes + addedTotal;
+    if (nextTotal > this.limits.responseMaxBytes) {
+      throw new ProviderOutputLimitError("total_response", this.limits.responseMaxBytes);
+    }
+    const detached = serializedCalls.map(
+      ({ id, name, encodedArguments }) => Object.freeze({
+        id,
+        name,
+        args: cloneAndFreezeJson(JSON.parse(encodedArguments))
+      })
+    );
+    this.textBytes = nextTextBytes;
+    this.totalBytes = nextTotal;
+    this.callCount = nextCalls;
+    this.textPendingHighSurrogate = textScan.pendingHighSurrogate;
+    return Object.freeze({ delta, toolCalls: Object.freeze(detached) });
+  }
+  finishRawTool(key) {
+    const state = this.rawToolCalls.get(key);
+    if (state === void 0) throw new TypeError("unknown provider tool call");
+    assertNoPendingSurrogate(state.idPending);
+    assertNoPendingSurrogate(state.namePending);
+    assertNoPendingSurrogate(state.argumentsPending);
+  }
+  finish() {
+    assertNoPendingSurrogate(this.textPendingHighSurrogate);
+    for (const key of this.rawToolCalls.keys()) this.finishRawTool(key);
+  }
+  recordToolArgumentJoin() {
+    this.argumentJoins += 1;
+  }
+};
+function dataProperty(descriptors, key) {
+  const descriptor = descriptors[key];
+  if (descriptor === void 0) return void 0;
+  if (!descriptor.enumerable || !("value" in descriptor)) {
+    throw new TypeError("provider tool calls must contain enumerable data properties");
+  }
+  return descriptor.value;
+}
+function assertNoPendingSurrogate(pending) {
+  if (pending !== void 0) {
+    throw new TypeError("provider output contains an unpaired Unicode surrogate");
+  }
+}
+async function closeProviderStream(stream) {
+  if (typeof stream !== "object" || stream === null) return;
+  const candidate = stream;
+  const close = candidate.controller?.abort?.bind(candidate.controller) ?? candidate.abort?.bind(candidate) ?? candidate.return?.bind(candidate) ?? candidate.close?.bind(candidate);
+  if (close === void 0) return;
+  try {
+    await close();
+  } catch {
+  }
+}
+
+// src/providers/openai.ts
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function parseToolCalls(raw) {
+  return (raw ?? []).map((tc) => {
+    if (tc.type !== "function") {
+      return { id: tc.id ?? "", name: "", args: {} };
+    }
+    const argsRaw = tc.function?.arguments;
+    return {
+      id: tc.id ?? "",
+      name: tc.function?.name ?? "",
+      // The OpenAI SDK types arguments as `string`; treat non-strings as
+      // already-parsed for forward-compat with mocked SDK shapes.
+      args: typeof argsRaw === "string" ? parseToolArgsJSON(argsRaw, "OpenAI") : argsRaw ?? {}
+    };
+  });
+}
+function rawToolCallFragments(raw) {
+  return (raw ?? []).map((toolCall, key) => {
+    const args = toolCall.type === "function" ? toolCall.function?.arguments : void 0;
+    return {
+      key,
+      startsCall: true,
+      idFragment: toolCall.id ?? "",
+      nameFragment: toolCall.type === "function" ? toolCall.function?.name ?? "" : "",
+      argumentsFragment: typeof args === "string" ? args : canonicalJsonValue(args ?? {}, "tool arguments")
+    };
+  });
+}
+var OpenAIProvider = class {
+  providerFamily = "openai";
+  opts;
+  client = null;
+  constructor(opts) {
+    if (!opts.apiKey?.trim()) {
+      throw new ProviderConfigError("OpenAI API key is not configured.", { service: "openai" });
+    }
+    if (opts.requestTimeoutMs !== void 0 && (!Number.isFinite(opts.requestTimeoutMs) || !Number.isInteger(opts.requestTimeoutMs) || opts.requestTimeoutMs <= 0)) {
+      throw new RangeError("requestTimeoutMs must be a positive finite integer");
+    }
+    this.opts = {
+      apiKey: opts.apiKey,
+      model: opts.model ?? "gpt-5.4-mini",
+      baseURL: opts.baseURL ?? "",
+      temperature: opts.temperature ?? 0.7,
+      maxTokens: opts.maxTokens ?? 4096,
+      requestTimeoutMs: opts.requestTimeoutMs,
+      defaultHeaders: opts.defaultHeaders && Object.keys(opts.defaultHeaders).length > 0 ? opts.defaultHeaders : void 0,
+      retry: {
+        maxAttempts: opts.retry?.maxAttempts ?? 3,
+        baseDelayMs: opts.retry?.baseDelayMs ?? 1e3
+      }
+    };
+  }
+  /** Expose the model name for downstream cost calculation. */
+  get model() {
+    return this.opts.model;
+  }
+  async createClient() {
+    const { default: OpenAIDefault } = await import('openai');
+    return new OpenAIDefault({
+      apiKey: this.opts.apiKey,
+      maxRetries: 0,
+      ...this.opts.baseURL ? { baseURL: this.opts.baseURL } : {},
+      ...this.opts.defaultHeaders ? { defaultHeaders: this.opts.defaultHeaders } : {}
+    });
+  }
+  async getClient() {
+    if (this.client !== null) return this.client;
+    try {
+      this.client = await this.createClient();
+    } catch (error) {
+      if (error instanceof ProviderError) throw error;
+      throw new ProviderConfigError("OpenAI provider requires the openai package.", {
+        service: "openai"
+      });
+    }
+    return this.client;
+  }
+  async generate(messages, tools, options) {
+    throwIfCancellationRequested(options?.cancellationToken);
+    const client = await this.getClient();
+    const params = {
+      model: this.opts.model,
+      messages: toOpenAIChatMessages(messages),
+      temperature: options?.temperature ?? this.opts.temperature,
+      max_completion_tokens: options?.maxTokens ?? this.opts.maxTokens
+    };
+    if (tools.length > 0) params.tools = toOpenAITools(tools);
+    const budget = new ProviderResponseBudget(options?.responseLimits);
+    try {
+      const response = await withRetry(
+        () => client.chat.completions.create(params, {
+          signal: options?.cancellationToken?.signal,
+          ...this.opts.requestTimeoutMs === void 0 ? {} : { timeout: this.opts.requestTimeoutMs }
+        }),
+        this.opts.retry,
+        options?.cancellationToken,
+        options?.metricsSink,
+        "openai"
+      );
+      const choice = response.choices[0];
+      if (!choice) {
+        return { content: "", toolCalls: [], usage: void 0 };
+      }
+      const message = choice.message;
+      const content = message.content ?? "";
+      budget.acceptRaw({
+        text: content,
+        toolFragments: rawToolCallFragments(message.tool_calls)
+      });
+      budget.finish();
+      const usage = response.usage ? { input: response.usage.prompt_tokens, output: response.usage.completion_tokens } : void 0;
+      const costUsd = usage && lookupCost(this.opts.model) !== void 0 ? calculateCostUsd(this.opts.model, usage.input, usage.output) : void 0;
+      return {
+        content,
+        toolCalls: parseToolCalls(message.tool_calls),
+        usage,
+        costUsd
+      };
+    } catch (error) {
+      if (error instanceof ProviderOutputLimitError) throw error;
+      throwIfCancellationRequested(options?.cancellationToken);
+      throw providerAPIErrorFromUnknown("openai", error, "request");
+    } finally {
+      getProviderResponseDiagnostics(options)?.record(budget.providerDiagnostics);
+    }
+  }
+  async *generateStream(messages, tools, options) {
+    throwIfCancellationRequested(options?.cancellationToken);
+    const client = await this.getClient();
+    const params = {
+      model: this.opts.model,
+      messages: toOpenAIChatMessages(messages),
+      temperature: options?.temperature ?? this.opts.temperature,
+      max_completion_tokens: options?.maxTokens ?? this.opts.maxTokens,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (tools.length > 0) params.tools = toOpenAITools(tools);
+    const budget = new ProviderResponseBudget(options?.responseLimits);
+    let stream;
+    try {
+      stream = await openStreamWithRetry(
+        () => client.chat.completions.create(params, {
+          signal: options?.cancellationToken?.signal,
+          ...this.opts.requestTimeoutMs === void 0 ? {} : { timeout: this.opts.requestTimeoutMs }
+        }),
+        this.opts.retry,
+        options?.cancellationToken,
+        options?.metricsSink,
+        "openai"
+      );
+      const pendingCalls = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const usage = chunk.usage ? { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens } : void 0;
+        if (usage) {
+          yield {
+            delta: "",
+            toolCalls: [],
+            usage,
+            costUsd: lookupCost(this.opts.model) === void 0 ? void 0 : calculateCostUsd(this.opts.model, usage.input, usage.output)
+          };
+          continue;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (!delta) continue;
+        const text = delta.content ?? "";
+        const incomingCalls = [];
+        const fragments = [];
+        const knownIndices = new Set(pendingCalls.keys());
+        for (const tc of delta.tool_calls ?? []) {
+          const idx = tc.index ?? 0;
+          const startsCall = !knownIndices.has(idx);
+          knownIndices.add(idx);
+          fragments.push({
+            key: idx,
+            startsCall,
+            idFragment: tc.id ?? "",
+            nameFragment: tc.function?.name ?? "",
+            argumentsFragment: tc.function?.arguments ?? ""
+          });
+        }
+        budget.acceptRaw({ text, toolFragments: fragments });
+        for (const fragment of fragments) {
+          let entry = pendingCalls.get(fragment.key);
+          if (entry === void 0) {
+            entry = {
+              id: new LinearStringParts(),
+              name: new LinearStringParts(),
+              arguments: new LinearStringParts()
+            };
+            pendingCalls.set(fragment.key, entry);
+          }
+          entry.id.append(fragment.idFragment ?? "");
+          entry.name.append(fragment.nameFragment ?? "");
+          entry.arguments.append(fragment.argumentsFragment ?? "");
+        }
+        if (chunk.choices[0]?.finish_reason === "tool_calls") {
+          for (const [key, entry] of pendingCalls) {
+            budget.finishRawTool(key);
+            budget.recordToolArgumentJoin();
+            incomingCalls.push({
+              id: entry.id.join(),
+              name: entry.name.join(),
+              args: parseToolArgsJSON(entry.arguments.join(), "OpenAI")
+            });
+          }
+          pendingCalls.clear();
+        }
+        if (text || incomingCalls.length > 0) {
+          yield { delta: text, toolCalls: incomingCalls };
+        }
+      }
+      budget.finish();
+    } catch (error) {
+      if (error instanceof ProviderOutputLimitError) {
+        await closeProviderStream(stream);
+        throw error;
+      }
+      throwIfCancellationRequested(options?.cancellationToken);
+      throw providerAPIErrorFromUnknown("openai", error, "stream");
+    } finally {
+      getProviderResponseDiagnostics(options)?.record(budget.providerDiagnostics);
+    }
+  }
+};
+
+exports.OpenAIProvider = OpenAIProvider;
+//# sourceMappingURL=openai.cjs.map
+//# sourceMappingURL=openai.cjs.map