@irogane/kaji 0.2.0-beta.11

package/dist/chunk-TM7ZGOJX.js

@@ -0,0 +1,716 @@
+import { canonicalJsonValue, cloneAndFreezeJson } from './chunk-KAJ6BM64.js';
+import { NOOP_METRICS, recordMetric } from './chunk-LSJ4AVO2.js';
+
+// 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/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/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 {
+  }
+}
+
+export { LinearStringParts, ProviderConfigError, ProviderError, ProviderOutputLimitError, ProviderResponseBudget, calculateCostUsd, closeProviderStream, getProviderResponseDiagnostics, lookupCost, openStreamWithRetry, parseToolArgsJSON, providerAPIErrorFromUnknown, throwIfCancellationRequested, withRetry };
+//# sourceMappingURL=chunk-TM7ZGOJX.js.map
+//# sourceMappingURL=chunk-TM7ZGOJX.js.map