@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/chunks/account-limits-cache-dejeygdt.js

@@ -0,0 +1,114 @@
+// src/utils/estimate.ts
+import { getSystemMessageText } from "@nyte-ai/schema/model";
+var CHARS_PER_TOKEN = 4;
+var ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens2(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+function estimateTextAndImageContentChars(content) {
+  if (!Array.isArray(content))
+    return content.length;
+  let chars = 0;
+  for (const block of content)
+    chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+  return chars;
+}
+function estimateTextTokens2(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTextAndImageContentTokens2(content) {
+  return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens2(message) {
+  let chars = 0;
+  if (message.role === "system") {
+    return estimateTextTokens2(getSystemMessageText(message)) + estimateToolsTokens(message.toolsAdded) + estimateToolsTokens(message.toolsRemoved);
+  }
+  if (message.role === "user")
+    return estimateTextAndImageContentTokens2(message.content);
+  if (message.role === "toolResult")
+    return estimateTextAndImageContentTokens2(message.content);
+  for (const block of message.content) {
+    if (block.type === "text") {
+      chars += block.text.length;
+    } else if (block.type === "thinking") {
+      chars += block.thinking.length;
+    } else {
+      chars += block.name.length + safeJsonStringify(block.arguments).length;
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function getLastAssistantUsageInfo(messages) {
+  let latestPrefixTimestamp = Number.NEGATIVE_INFINITY;
+  let usageInfo;
+  for (let i = 0;i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role === "assistant") {
+      const usageAppliesToPrefix = message.timestamp >= latestPrefixTimestamp;
+      if (usageAppliesToPrefix && message.stopReason !== "aborted" && message.stopReason !== "error" && calculateContextTokens2(message.usage) > 0) {
+        usageInfo = { usage: message.usage, index: i };
+      }
+    }
+    latestPrefixTimestamp = Math.max(latestPrefixTimestamp, message.timestamp);
+  }
+  return usageInfo;
+}
+function estimateMessages(messages) {
+  const usageInfo = getLastAssistantUsageInfo(messages);
+  if (usageInfo) {
+    const usageTokens = calculateContextTokens2(usageInfo.usage);
+    let trailingTokens = 0;
+    for (let i = usageInfo.index + 1;i < messages.length; i++) {
+      trailingTokens += estimateMessageTokens2(messages[i]);
+    }
+    return {
+      tokens: usageTokens + trailingTokens,
+      usageTokens,
+      trailingTokens,
+      lastUsageIndex: usageInfo.index
+    };
+  }
+  let tokens = 0;
+  for (const message of messages)
+    tokens += estimateMessageTokens2(message);
+  return { tokens, usageTokens: 0, trailingTokens: tokens, lastUsageIndex: null };
+}
+function estimateToolsTokens(tools) {
+  if (!tools || tools.length === 0)
+    return 0;
+  return estimateTextTokens2(safeJsonStringify(tools));
+}
+function estimateContextTokens2(context) {
+  if (!("messages" in context))
+    return estimateMessages(context);
+  const estimate = estimateMessages(context.messages);
+  if (!("systemPrompt" in context) && !("tools" in context))
+    return estimate;
+  if (estimate.lastUsageIndex !== null) {
+    const addedNames = new Set(context.messages.slice(estimate.lastUsageIndex + 1).filter((message) => message.role === "toolResult").flatMap((message) => message.addedToolNames ?? []));
+    const addedToolTokens = estimateToolsTokens(context.tools?.filter((tool) => addedNames.has(tool.name)));
+    return {
+      tokens: estimate.tokens + addedToolTokens,
+      usageTokens: estimate.usageTokens,
+      trailingTokens: estimate.trailingTokens + addedToolTokens,
+      lastUsageIndex: estimate.lastUsageIndex
+    };
+  }
+  const prefixTokens = (context.systemPrompt ? estimateTextTokens2(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+  return {
+    tokens: estimate.tokens + prefixTokens,
+    usageTokens: estimate.usageTokens,
+    trailingTokens: estimate.trailingTokens + prefixTokens,
+    lastUsageIndex: estimate.lastUsageIndex
+  };
+}
+
+export { calculateContextTokens2, estimateTextTokens2, estimateTextAndImageContentTokens2, estimateMessageTokens2, estimateContextTokens2 };

package/dist/chunks/account-limits-cache-eejm0vth.js

@@ -0,0 +1,11 @@
+// src/api/openai-codex-compaction-error.ts
+class OpenAICodexCompactionError2 extends Error {
+  usage;
+  constructor(message, usage) {
+    super(message);
+    this.name = "OpenAICodexCompactionError";
+    this.usage = usage;
+  }
+}
+
+export { OpenAICodexCompactionError2 };

package/dist/chunks/account-limits-cache-ehy0ze2b.js

@@ -0,0 +1,33 @@
+// src/providers/account-limits.ts
+import { Value } from "typebox/value";
+function limitWindow2(id, label, usedPercent, resetsAt, windowMinutes) {
+  const window = {
+    id,
+    label,
+    usedPercent: Math.max(0, Math.min(100, usedPercent))
+  };
+  if (resetsAt !== undefined)
+    window.resetsAt = resetsAt;
+  if (windowMinutes !== undefined)
+    window.windowMinutes = windowMinutes;
+  return window;
+}
+async function fetchAccountUsage2(url, headers, options, schema, label) {
+  const timeoutSignal = options?.timeoutMs !== undefined && options.timeoutMs > 0 ? AbortSignal.timeout(Math.floor(options.timeoutMs)) : undefined;
+  const signal = AbortSignal.any([options?.signal, timeoutSignal].filter((candidate) => candidate !== undefined));
+  const response = await (options?.fetch ?? globalThis.fetch)(url, {
+    method: "GET",
+    headers,
+    signal
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`${label} usage request failed (${String(response.status)}): ${text || response.statusText}`);
+  }
+  const decoded = await response.json();
+  if (!Value.Check(schema, decoded))
+    throw new Error(`${label} usage response was not an object`);
+  return decoded;
+}
+
+export { limitWindow2, fetchAccountUsage2 };

package/dist/chunks/account-limits-cache-emg5b4hj.js

@@ -0,0 +1,53 @@
+import {
+  operationSignal2,
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+
+// src/auth/credential-store.ts
+import { keyedSerial } from "@nyte-ai/schema/serial";
+class InMemoryCredentialStore2 {
+  credentials = new Map;
+  writes = keyedSerial();
+  enqueue(providerId, task, options) {
+    const signal = operationSignal2(options?.signal);
+    const queued = this.writes.run(providerId, () => {
+      signal.throwIfAborted();
+      return task();
+    });
+    return raceWithAbortSignal2(queued, signal);
+  }
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
+    return this.credentials.get(providerId);
+  }
+  async list(options) {
+    options?.signal?.throwIfAborted();
+    return [...this.credentials].flatMap(([providerId, stored]) => stored.accounts.map((account) => ({
+      providerId,
+      id: account.id,
+      label: account.label,
+      type: account.credential.type,
+      active: stored.active === account.id
+    })));
+  }
+  modify(providerId, fn, options) {
+    return this.enqueue(providerId, async () => {
+      const current = this.credentials.get(providerId);
+      const next = await fn(current);
+      if (next !== undefined) {
+        if (next.accounts.length === 0)
+          this.credentials.delete(providerId);
+        else
+          this.credentials.set(providerId, next);
+      }
+      return next ?? current;
+    }, options);
+  }
+  delete(providerId, options) {
+    return this.enqueue(providerId, async () => {
+      this.credentials.delete(providerId);
+    }, options);
+  }
+}
+
+export { InMemoryCredentialStore2 };

package/dist/chunks/account-limits-cache-eqwweapz.js

@@ -0,0 +1,6 @@
+// src/utils/sanitize-unicode.ts
+function sanitizeSurrogates2(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+export { sanitizeSurrogates2 };

package/dist/chunks/account-limits-cache-eyx1jcxc.js

@@ -0,0 +1,8 @@
+import {
+  lazyApi2
+} from "./account-limits-cache-90c9c2eb.js";
+
+// src/api/openai-completions.lazy.ts
+var openAICompletionsApi2 = () => lazyApi2(() => import("../src/api/openai-completions.js"));
+
+export { openAICompletionsApi2 };

package/dist/chunks/account-limits-cache-f9z00x8c.js

@@ -0,0 +1,36 @@
+// src/model-pricing.ts
+var ANTHROPIC_FAST_MODE_COST_MULTIPLIER2 = 2;
+function getServiceTierCostMultiplier(model, serviceTier) {
+  switch (serviceTier) {
+    case "flex":
+      return 0.5;
+    case "priority":
+    case "fast":
+      return model.id === "gpt-5.5" ? 2.5 : 2;
+    default:
+      return 1;
+  }
+}
+function applyServiceTierPricing2(usage, serviceTier, model) {
+  const multiplier = getServiceTierCostMultiplier(model, serviceTier ?? undefined);
+  if (multiplier === 1)
+    return;
+  usage.cost.input *= multiplier;
+  usage.cost.output *= multiplier;
+  usage.cost.cacheRead *= multiplier;
+  usage.cost.cacheWrite *= multiplier;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function getFastModeCostMultiplier2(model) {
+  switch (model.api) {
+    case "openai-responses":
+    case "openai-codex-responses":
+      return getServiceTierCostMultiplier(model, "priority");
+    case "anthropic-messages":
+      return model.provider === "anthropic" ? ANTHROPIC_FAST_MODE_COST_MULTIPLIER2 : undefined;
+    default:
+      return;
+  }
+}
+
+export { ANTHROPIC_FAST_MODE_COST_MULTIPLIER2, applyServiceTierPricing2, getFastModeCostMultiplier2 };

package/dist/chunks/account-limits-cache-fbkaq46e.js

@@ -0,0 +1,113 @@
+// src/utils/json-parse.ts
+import { parse as partialParse } from "partial-json";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ToolArgumentsSchema = Type.Record(Type.String(), Type.Unknown());
+var VALID_JSON_ESCAPES = new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function escapeControlCharacter(char) {
+  switch (char) {
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\t":
+      return "\\t";
+    default:
+      return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+  }
+}
+function repairJson2(json) {
+  let repaired = "";
+  let inString = false;
+  for (let index = 0;index < json.length; index++) {
+    const char = json[index];
+    if (!inString) {
+      repaired += char;
+      if (char === '"') {
+        inString = true;
+      }
+      continue;
+    }
+    if (char === '"') {
+      repaired += char;
+      inString = false;
+      continue;
+    }
+    if (char === "\\") {
+      const nextChar = json[index + 1];
+      if (nextChar === undefined) {
+        repaired += "\\\\";
+        continue;
+      }
+      if (nextChar === "u") {
+        const unicodeDigits = json.slice(index + 2, index + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+          repaired += `\\u${unicodeDigits}`;
+          index += 5;
+          continue;
+        }
+      }
+      if (VALID_JSON_ESCAPES.has(nextChar)) {
+        repaired += `\\${nextChar}`;
+        index += 1;
+        continue;
+      }
+      repaired += "\\\\";
+      continue;
+    }
+    const codePoint = char.codePointAt(0) ?? 32;
+    repaired += codePoint <= 31 ? escapeControlCharacter(char) : char;
+  }
+  return repaired;
+}
+function parseStreamingJson2(partialJson) {
+  if (!partialJson || partialJson.trim() === "")
+    return {};
+  let value;
+  try {
+    value = JSON.parse(partialJson);
+  } catch {
+    const repaired = repairJson2(partialJson);
+    try {
+      value = JSON.parse(repaired);
+    } catch {
+      try {
+        value = partialParse(repaired);
+      } catch {
+        return {};
+      }
+    }
+  }
+  return Value.Check(ToolArgumentsSchema, value) ? value : {};
+}
+function parseToolCallArguments2(json) {
+  if (!json || json.trim() === "")
+    return { arguments: {} };
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch (error) {
+    try {
+      value = JSON.parse(repairJson2(json));
+    } catch {
+      return unparsedToolCallArguments(error instanceof Error ? error.message : String(error), json);
+    }
+  }
+  return Value.Check(ToolArgumentsSchema, value) ? { arguments: value } : unparsedToolCallArguments("Tool arguments must be a JSON object", json);
+}
+function unfinishedToolCallArguments2(json) {
+  return unparsedToolCallArguments("The response ended before this tool call finished", json);
+}
+function unparsedToolCallArguments(reason, json) {
+  return { arguments: {}, argumentsError: `${reason}
+
+Received arguments:
+${json}` };
+}
+
+export { repairJson2, parseStreamingJson2, parseToolCallArguments2, unfinishedToolCallArguments2 };