@nyte-ai/ai 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,293 @@
+import {
+  GITHUB_COPILOT_API_VERSION2,
+  GITHUB_COPILOT_DEFAULT_ORIGIN2,
+  GITHUB_COPILOT_HEADERS2
+} from "./account-limits-cache-za42x8a3.js";
+import {
+  parseGitHubCopilotCatalog2
+} from "./account-limits-cache-gs8a3fhw.js";
+import {
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  pollOAuthDeviceCodeFlow2
+} from "./account-limits-cache-4hptgd2h.js";
+
+// src/auth/oauth/github-copilot.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var DEFAULT_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+var DEVICE_CODE_LIFETIME_SECONDS = 15 * 60;
+var EXPIRED_MESSAGE = "The device code expired before GitHub approved it. Sign in again.";
+var CREDENTIAL_ERROR = "Invalid stored GitHub Copilot credential. Sign in to GitHub Copilot again.";
+var KNOWN_GRANT_ERRORS = new Set([
+  "unsupported_grant_type",
+  "incorrect_client_credentials",
+  "incorrect_device_code",
+  "device_flow_disabled"
+]);
+var DeviceCodeResponse = Type.Object({
+  device_code: Type.String({ minLength: 1 }),
+  user_code: Type.String({ minLength: 1 }),
+  verification_uri: Type.String({ minLength: 1 }),
+  interval: Type.Optional(Type.Unknown()),
+  expires_in: Type.Optional(Type.Unknown())
+});
+var GitHubToken = Type.Object({ access_token: Type.String({ minLength: 1 }) });
+var GrantError = Type.Object({ error: Type.String(), interval: Type.Optional(Type.Unknown()) });
+var PositiveSeconds = Type.Number({ exclusiveMinimum: 0 });
+var CopilotToken = Type.Object({
+  token: Type.String({ minLength: 1 }),
+  expires_at: Type.Number()
+});
+var CopilotCredential = Type.Object({
+  type: Type.Literal("oauth"),
+  refresh: Type.String({ minLength: 1 }),
+  access: Type.String({ minLength: 1 }),
+  expires: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+  availableModelIds: Type.Array(Type.String({ minLength: 1 }))
+});
+function matchesCopilotCredential2(value) {
+  return Value.Check(CopilotCredential, value);
+}
+function copilotOrigin(token) {
+  const proxy = /(?:^|;)proxy-ep=([^;]+)/u.exec(token)?.[1];
+  if (proxy === undefined)
+    return GITHUB_COPILOT_DEFAULT_ORIGIN2;
+  const url = URL.parse(`https://${proxy.replace(/^proxy\./u, "api.")}`);
+  if (!url || url.protocol !== "https:" || !url.hostname.endsWith(".githubcopilot.com") || url.port !== "" || url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+    throw new Error("GitHub Copilot token contains an untrusted API endpoint");
+  }
+  return url.origin;
+}
+async function requestCopilot(input) {
+  const bounded = AbortSignal.any([input.signal, AbortSignal.timeout(15000)]);
+  let response;
+  try {
+    response = await raceWithAbortSignal2((input.fetch ?? globalThis.fetch)(input.url, {
+      ...input.init,
+      signal: bounded,
+      redirect: "error"
+    }), bounded);
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (bounded.aborted)
+      throw new Error(`${input.describe} timed out`, { cause: error });
+    throw new Error(`${input.describe} failed: network error`, { cause: error });
+  }
+  if (!response.ok)
+    throw new Error(`${input.describe} failed (HTTP ${String(response.status)})`);
+  try {
+    return await raceWithAbortSignal2(response.json(), bounded);
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (bounded.aborted)
+      throw new Error(`${input.describe} timed out`, { cause: error });
+    throw new Error(`${input.describe} returned an unreadable response`, { cause: error });
+  }
+}
+var DEVICE_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/x-www-form-urlencoded",
+  "User-Agent": GITHUB_COPILOT_HEADERS2["User-Agent"]
+};
+async function startDeviceAuthorization(input) {
+  const json = await requestCopilot({
+    fetch: input.fetch,
+    url: "https://github.com/login/device/code",
+    init: {
+      method: "POST",
+      headers: DEVICE_HEADERS,
+      body: new URLSearchParams({ client_id: input.clientId, scope: "read:user" })
+    },
+    signal: input.signal,
+    describe: "GitHub device code request"
+  });
+  if (!Value.Check(DeviceCodeResponse, json))
+    throw new Error("GitHub device code response is missing required fields");
+  const url = URL.parse(json.verification_uri);
+  if (!url || url.protocol !== "https:" || url.hostname !== "github.com" && url.hostname !== "www.github.com" || url.port !== "" || url.username !== "" || url.password !== "" || !url.pathname.startsWith("/login/")) {
+    throw new Error("GitHub device code response named a verification page outside github.com");
+  }
+  return {
+    ...json,
+    verification_uri: url.href,
+    interval: Value.Check(PositiveSeconds, json.interval) ? json.interval : undefined,
+    expires_in: Math.min(DEVICE_CODE_LIFETIME_SECONDS, Value.Check(PositiveSeconds, json.expires_in) ? json.expires_in : DEVICE_CODE_LIFETIME_SECONDS)
+  };
+}
+var LIFETIME_GRACE_MS = 1000;
+async function pollForGitHubToken(input) {
+  const lifetime = AbortSignal.timeout(Math.ceil(input.device.expires_in * 1000) + LIFETIME_GRACE_MS);
+  const pollSignal = AbortSignal.any([input.signal, lifetime]);
+  try {
+    return await pollOAuthDeviceCodeFlow2({
+      intervalSeconds: input.device.interval,
+      expiresInSeconds: input.device.expires_in,
+      waitBeforeFirstPoll: true,
+      signal: pollSignal,
+      poll: async () => {
+        const json = await requestCopilot({
+          fetch: input.fetch,
+          url: "https://github.com/login/oauth/access_token",
+          init: {
+            method: "POST",
+            headers: DEVICE_HEADERS,
+            body: new URLSearchParams({
+              client_id: input.clientId,
+              device_code: input.device.device_code,
+              grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+            })
+          },
+          signal: pollSignal,
+          describe: "GitHub device authorization"
+        });
+        if (Value.Check(GitHubToken, json))
+          return { status: "complete", value: json };
+        if (!Value.Check(GrantError, json))
+          return { status: "failed", message: "GitHub device authorization response is malformed" };
+        switch (json.error) {
+          case "authorization_pending":
+            return { status: "pending" };
+          case "slow_down":
+            return {
+              status: "slow_down",
+              intervalSeconds: Value.Check(PositiveSeconds, json.interval) ? json.interval : undefined
+            };
+          case "expired_token":
+            return { status: "failed", message: EXPIRED_MESSAGE };
+          case "access_denied":
+            return { status: "failed", message: "GitHub sign-in was denied." };
+          default:
+            return {
+              status: "failed",
+              message: KNOWN_GRANT_ERRORS.has(json.error) ? `GitHub device authorization failed: ${json.error}` : "GitHub device authorization failed with an unrecognized error"
+            };
+        }
+      }
+    });
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (lifetime.aborted)
+      throw new Error(EXPIRED_MESSAGE, { cause: error });
+    throw error;
+  }
+}
+async function loadCopilotCredential(input) {
+  const token = await requestCopilot({
+    fetch: input.fetch,
+    url: "https://api.github.com/copilot_internal/v2/token",
+    init: {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${input.github.access_token}`,
+        ...GITHUB_COPILOT_HEADERS2
+      }
+    },
+    signal: input.signal,
+    describe: "GitHub Copilot token exchange"
+  });
+  if (!Value.Check(CopilotToken, token) || !Number.isSafeInteger(token.expires_at * 1000) || token.expires_at * 1000 <= Date.now()) {
+    throw new Error("GitHub Copilot token exchange returned an invalid token or expiry. Sign in to GitHub Copilot again.");
+  }
+  const origin = copilotOrigin(token.token);
+  const catalog = parseGitHubCopilotCatalog2(await requestCopilot({
+    fetch: input.fetch,
+    url: `${origin}/models`,
+    init: {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token.token}`,
+        ...GITHUB_COPILOT_HEADERS2,
+        "X-GitHub-Api-Version": GITHUB_COPILOT_API_VERSION2
+      }
+    },
+    signal: input.signal,
+    describe: "GitHub Copilot catalog request"
+  }), origin, input.knownModelIds);
+  input.signal.throwIfAborted();
+  return {
+    credential: {
+      type: "oauth",
+      refresh: input.github.access_token,
+      access: token.token,
+      expires: token.expires_at * 1000,
+      availableModelIds: catalog.availableModelIds
+    },
+    needsApproval: catalog.needsApproval
+  };
+}
+function githubCopilotOAuth2(options = {}, knownModelIds = () => new Set) {
+  return {
+    name: "GitHub Copilot",
+    isSubscription: true,
+    loginLabel: "Sign in with GitHub",
+    login: async (interaction) => {
+      interaction.signal.throwIfAborted();
+      const environment = typeof process === "undefined" ? undefined : process.env.NYTE_GITHUB_COPILOT_CLIENT_ID;
+      const clientId = options.clientId || environment || DEFAULT_CLIENT_ID;
+      const device = await startDeviceAuthorization({
+        fetch: options.fetch,
+        clientId,
+        signal: interaction.signal
+      });
+      if (interaction.signal.aborted)
+        throw new Error("Login cancelled");
+      const deviceCode = {
+        type: "device_code",
+        userCode: device.user_code,
+        verificationUri: device.verification_uri,
+        intervalSeconds: device.interval,
+        expiresInSeconds: device.expires_in
+      };
+      if (clientId === DEFAULT_CLIENT_ID) {
+        deviceCode.instructions = "This sign-in uses GitHub's Copilot app, not a Nyte OAuth app.";
+      }
+      interaction.notify(deviceCode);
+      const github = await pollForGitHubToken({
+        fetch: options.fetch,
+        clientId,
+        device,
+        signal: interaction.signal
+      });
+      interaction.notify({ type: "progress", message: "Connecting to GitHub Copilot" });
+      const result = await loadCopilotCredential({
+        fetch: options.fetch,
+        github,
+        knownModelIds: knownModelIds(),
+        signal: interaction.signal
+      });
+      if (result.needsApproval)
+        interaction.notify({
+          type: "info",
+          message: "Some Copilot models need account approval. Enable them in your Copilot settings, then sign in again."
+        });
+      return result.credential;
+    },
+    refresh: async (previous, signal) => {
+      if (!matchesCopilotCredential2(previous))
+        throw new Error(CREDENTIAL_ERROR);
+      const result = await loadCopilotCredential({
+        fetch: options.fetch,
+        github: { access_token: previous.refresh },
+        knownModelIds: knownModelIds(),
+        signal
+      });
+      return result.credential;
+    },
+    async toAuth(credential) {
+      if (!matchesCopilotCredential2(credential))
+        throw new Error(CREDENTIAL_ERROR);
+      return {
+        apiKey: credential.access,
+        baseUrl: copilotOrigin(credential.access),
+        headers: GITHUB_COPILOT_HEADERS2
+      };
+    }
+  };
+}
+
+export { matchesCopilotCredential2, githubCopilotOAuth2 };

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

@@ -0,0 +1,27 @@
+// src/auth/oauth/authorization-input.ts
+function parseAuthorizationInput2(input) {
+  const value = input.trim();
+  if (!value)
+    return {};
+  try {
+    const url = new URL(value);
+    return {
+      code: url.searchParams.get("code") ?? undefined,
+      state: url.searchParams.get("state") ?? undefined
+    };
+  } catch {}
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code, state };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? undefined,
+      state: params.get("state") ?? undefined
+    };
+  }
+  return { code: value };
+}
+
+export { parseAuthorizationInput2 };

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

@@ -0,0 +1,17 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+
+// src/prompt-cache.ts
+function resolveCacheRetention2(retention, env) {
+  if (retention !== undefined)
+    return retention;
+  return getProviderEnvValue2("NYTE_CACHE_RETENTION", env) === "short" ? "short" : "long";
+}
+function promptCacheMinimumTtlMs2(policy, retention) {
+  if (policy === undefined || retention === "none")
+    return;
+  return policy.minimumRetentionMs[retention];
+}
+
+export { resolveCacheRetention2, promptCacheMinimumTtlMs2 };

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 };