@nyte-ai/ai 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,104 @@
+import {
+  claudeCodeVersion2,
+  usesClaudeSubscription2
+} from "./account-limits-cache-ks1sjym9.js";
+import {
+  limitWindow2,
+  fetchAccountUsage2
+} from "./account-limits-cache-ehy0ze2b.js";
+
+// src/providers/anthropic-limits.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var AccountResetSchema = Type.Optional(Type.Union([Type.Number(), Type.String(), Type.Null()]));
+var ClaudeUsageResponseSchema = Type.Record(Type.String(), Type.Unknown());
+var ClaudeUsageWindowSchema = Type.Object({
+  utilization: Type.Number(),
+  resets_at: AccountResetSchema
+});
+var ClaudeScopedUsageWindowSchema = Type.Object({
+  kind: Type.Literal("weekly_scoped"),
+  scope: Type.Object({ model: Type.Object({ display_name: Type.String() }) }),
+  percent: Type.Number(),
+  resets_at: AccountResetSchema
+});
+function resetAtMs(value) {
+  if (value === null || value === undefined)
+    return;
+  if (typeof value === "number") {
+    return value < 1000000000000 ? value * 1000 : value;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function accountLimitWindow(id, label, percent, reset, windowMinutes) {
+  return limitWindow2(id, label, percent, resetAtMs(reset), windowMinutes);
+}
+var CLAUDE_USAGE_WINDOWS = [
+  { id: "five_hour", label: "5-hour", windowMinutes: 5 * 60 },
+  { id: "seven_day", label: "Weekly", windowMinutes: 7 * 24 * 60 },
+  { id: "seven_day_sonnet", label: "Sonnet weekly", windowMinutes: 7 * 24 * 60 },
+  { id: "seven_day_opus", label: "Opus weekly", windowMinutes: 7 * 24 * 60 }
+];
+function claudeHeaderLimits2(headers, providerId) {
+  const windows = [];
+  for (const [id, label, suffix, windowMinutes] of [
+    ["five_hour", "5-hour", "5h", 5 * 60],
+    ["seven_day", "Weekly", "7d", 7 * 24 * 60]
+  ]) {
+    const utilization = Number(headers[`anthropic-ratelimit-unified-${suffix}-utilization`]);
+    if (!Number.isFinite(utilization))
+      continue;
+    const reset = Number(headers[`anthropic-ratelimit-unified-${suffix}-reset`]);
+    windows.push(accountLimitWindow(id, label, utilization * 100, Number.isFinite(reset) ? reset : undefined, windowMinutes));
+  }
+  return windows.length === 0 ? undefined : { providerId, windows, observedAt: Date.now() };
+}
+function claudeUsageWindows(usage) {
+  const windows = [];
+  for (const definition of CLAUDE_USAGE_WINDOWS) {
+    const window = usage[definition.id];
+    if (!Value.Check(ClaudeUsageWindowSchema, window))
+      continue;
+    windows.push(accountLimitWindow(definition.id, definition.label, window.utilization, window.resets_at, definition.windowMinutes));
+  }
+  const scoped = usage["limits"];
+  for (const window of Array.isArray(scoped) ? scoped : []) {
+    if (!Value.Check(ClaudeScopedUsageWindowSchema, window))
+      continue;
+    const name = window.scope.model.display_name;
+    if (name.trim() === "")
+      continue;
+    windows.push(accountLimitWindow(`seven_day_${name}`, `${name} weekly`, window.percent, window.resets_at, 7 * 24 * 60));
+  }
+  return windows;
+}
+async function fetchAnthropicAccountLimits2(model, options) {
+  const apiKey = options?.apiKey;
+  if (!apiKey || !usesClaudeSubscription2(apiKey)) {
+    throw new Error("Claude usage requires Anthropic OAuth");
+  }
+  const headers = new Headers({
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "User-Agent": `claude-cli/${claudeCodeVersion2}`,
+    "anthropic-beta": "oauth-2025-04-20"
+  });
+  for (const source of [model.headers, options?.headers]) {
+    for (const [name, value] of Object.entries(source ?? {})) {
+      if (value === null)
+        headers.delete(name);
+      else
+        headers.set(name, value);
+    }
+  }
+  const baseUrl = (model.baseUrl?.trim() || "https://api.anthropic.com").replace(/\/+$/, "").replace(/\/v1$/, "");
+  const decoded = await fetchAccountUsage2(`${baseUrl}/api/oauth/usage`, headers, options, ClaudeUsageResponseSchema, "Claude");
+  return {
+    providerId: model.provider,
+    windows: claudeUsageWindows(decoded),
+    observedAt: Date.now()
+  };
+}
+
+export { claudeHeaderLimits2, fetchAnthropicAccountLimits2 };

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

@@ -0,0 +1,9 @@
+// src/utils/nyte-home.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+function defaultNyteHome2() {
+  return process.env["NYTE_HOME"] ?? join(homedir(), ".nyte");
+}
+
+export { defaultNyteHome2 };

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

@@ -0,0 +1,7 @@
+// src/utils/typebox-helpers.ts
+import { Type } from "typebox";
+function StringEnum2(values, options) {
+  return Type.Enum(values, { type: "string", ...options });
+}
+
+export { StringEnum2 };

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

@@ -0,0 +1,20 @@
+// src/auth/oauth/pkce.ts
+function base64urlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+async function generatePKCE2() {
+  const verifierBytes = new Uint8Array(32);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = base64urlEncode(verifierBytes);
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const challenge = base64urlEncode(new Uint8Array(hashBuffer));
+  return { verifier, challenge };
+}
+
+export { generatePKCE2 };

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

@@ -0,0 +1,24 @@
+// src/auth/oauth/load.ts
+var registeredFlows = new Map;
+function registerOAuthFlow2(id, flow) {
+  registeredFlows.set(id, flow);
+}
+async function importOAuthModule(specifier) {
+  try {
+    await import(specifier);
+  } catch (error) {
+    throw new Error(`OAuth flow module ${specifier} is not loadable at runtime. Bundled hosts must register flows up front with registerBunOAuthFlows.`, { cause: error });
+  }
+}
+async function loadOAuthFlow(id, specifier) {
+  if (!registeredFlows.has(id))
+    await importOAuthModule(specifier);
+  const flow = registeredFlows.get(id);
+  if (flow === undefined)
+    throw new Error(`OAuth flow module ${specifier} did not register its flow`);
+  return flow;
+}
+var loadAnthropicOAuth2 = () => loadOAuthFlow("anthropic", "@nyte-ai/ai/auth/oauth/anthropic");
+var loadOpenAICodexOAuth2 = () => loadOAuthFlow("openaiCodex", "@nyte-ai/ai/auth/oauth/openai-codex");
+
+export { registerOAuthFlow2, loadAnthropicOAuth2, loadOpenAICodexOAuth2 };

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

@@ -0,0 +1,281 @@
+import {
+  applyServiceTierPricing2
+} from "./account-limits-cache-f9z00x8c.js";
+import {
+  CodexFrameJson2,
+  readText2,
+  readBoolean2,
+  readNumber2,
+  readRecord2,
+  TERMINAL_RESPONSE_TYPES2
+} from "./account-limits-cache-fvadc36m.js";
+import {
+  codexFrameLimits2
+} from "./account-limits-cache-hj3ek3ty.js";
+import {
+  splitDeferredTools2
+} from "./account-limits-cache-8s8bz4dr.js";
+import {
+  formatThrownValue2
+} from "./account-limits-cache-9wqk28n5.js";
+import {
+  iterateServerSentEvents2
+} from "./account-limits-cache-me1x57bs.js";
+import {
+  getSystemMessageText2
+} from "./account-limits-cache-b4edaybk.js";
+import {
+  getDeclaredTools2,
+  getInitialSystemMessage2,
+  resolveTranscriptTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  createGrammarToolInputProperties2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  convertResponsesMessages2,
+  convertResponsesTools2
+} from "./account-limits-cache-n3yk6g5c.js";
+
+// src/api/openai-codex-protocol.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CodexResponseStatusSchema = Type.Union([
+  Type.Literal("completed"),
+  Type.Literal("incomplete"),
+  Type.Literal("failed"),
+  Type.Literal("cancelled"),
+  Type.Literal("queued"),
+  Type.Literal("in_progress")
+]);
+var DEFAULT_MAX_RETRIES2 = 0;
+var REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+var CODEX_TOOL_CALL_PROVIDERS2 = new Set([
+  "openai",
+  "openai-codex",
+  "opencode"
+]);
+function compressRequestBodyZstd2(bodyJson) {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  try {
+    const zlib = process.getBuiltinModule("node:zlib");
+    const compressed = zlib.zstdCompressSync(bodyJson, {
+      params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL }
+    });
+    return new Uint8Array(compressed);
+  } catch {
+    return null;
+  }
+}
+function buildRequestBody2(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+  const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
+  const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
+  const deferredToolsMode = model.compat?.supportsAdditionalTools ? "additional-tools" : model.compat?.supportsToolSearch ? "tool-search" : undefined;
+  const transcriptTools = resolveTranscriptTools2(context.messages, deferredToolsMode !== undefined);
+  const toolPlacement = splitDeferredTools2({ messages: context.messages, tools: transcriptTools.requestTools }, deferredToolsMode !== undefined);
+  const messages = convertResponsesMessages2(model, context, CODEX_TOOL_CALL_PROVIDERS2, {
+    includeSystemPrompt: false,
+    grammarToolInputProperties,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    deferredTools: toolPlacement.deferred,
+    deferredToolsMode,
+    toolOptions: {
+      strict: null,
+      supportsStrictMode,
+      supportsOpenAIGrammarTools
+    }
+  });
+  const initialSystemMessage = getInitialSystemMessage2(context.messages);
+  const instructions = initialSystemMessage ? getSystemMessageText2(initialSystemMessage) : "";
+  const body = {
+    model: model.id,
+    store: false,
+    stream: true,
+    instructions: instructions || "You are a helpful assistant.",
+    input: messages,
+    text: { verbosity: options?.textVerbosity || "low" },
+    include: ["reasoning.encrypted_content"],
+    prompt_cache_key: cacheSessionId,
+    tool_choice: options?.toolChoice ?? "auto",
+    parallel_tool_calls: true
+  };
+  if (options?.temperature !== undefined) {
+    body.temperature = options.temperature;
+  }
+  if (options?.serviceTier !== undefined) {
+    body.service_tier = options.serviceTier;
+  }
+  if (toolPlacement.immediate.length > 0) {
+    body.tools = convertResponsesTools2(toolPlacement.immediate, {
+      strict: null,
+      supportsStrictMode,
+      supportsOpenAIGrammarTools
+    });
+  }
+  if (options?.reasoningEffort !== undefined) {
+    const effort = options.reasoningEffort === "none" ? model.thinkingLevelMap?.off === undefined ? "none" : model.thinkingLevelMap.off : model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+    if (effort !== null) {
+      body.reasoning = {
+        effort,
+        summary: options.reasoningSummary ?? "auto"
+      };
+    }
+  } else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+    body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+  }
+  return body;
+}
+function resolveCodexServiceTier2(responseServiceTier, requestServiceTier) {
+  if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) {
+    return requestServiceTier;
+  }
+  return responseServiceTier ?? requestServiceTier;
+}
+function codexStreamOptions2(request) {
+  return {
+    serviceTier: request.options?.serviceTier,
+    grammarToolInputProperties: request.grammarToolInputProperties,
+    resolveServiceTier: resolveCodexServiceTier2,
+    applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing2(usage, serviceTier, request.model)
+  };
+}
+
+class CodexRequestError2 extends Error {
+  status;
+  headers;
+  retryable;
+  constructor(message, status, headers, retryable, options) {
+    super(message, options);
+    this.name = "CodexRequestError";
+    this.status = status;
+    this.headers = headers;
+    this.retryable = retryable;
+  }
+}
+function retryableCodexRequest2(error) {
+  return error instanceof CodexRequestError2 && error.retryable;
+}
+
+class CodexApiError2 extends Error {
+  code;
+  payload;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "CodexApiError";
+    this.code = options?.code;
+    this.payload = options?.payload;
+  }
+}
+
+class CodexProtocolError2 extends Error {
+  payload;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "CodexProtocolError";
+    this.payload = options?.payload;
+  }
+}
+function extractCodexEventError2(event) {
+  const nested = readRecord2(event.error);
+  return {
+    code: readText2(event.code) ?? readText2(nested?.code),
+    message: readText2(event.message) ?? readText2(nested?.message)
+  };
+}
+async function reportFrameLimits(frame, providerId, onAccountLimits) {
+  const limits = codexFrameLimits2(frame, providerId);
+  if (limits !== undefined)
+    await onAccountLimits(limits);
+}
+async function* mapCodexEvents2(events, output, onAccountLimits) {
+  for await (const event of events) {
+    const { type } = event;
+    if (type === "codex.rate_limits") {
+      if (onAccountLimits !== undefined) {
+        await reportFrameLimits(event, output.provider, onAccountLimits).catch(() => {
+          return;
+        });
+      }
+      continue;
+    }
+    if (type === "error") {
+      const { code, message } = extractCodexEventError2(event);
+      throw new CodexApiError2(`Codex error: ${message || code || JSON.stringify(event)}`, {
+        code,
+        payload: event
+      });
+    }
+    if (TERMINAL_RESPONSE_TYPES2.has(type)) {
+      const response = readRecord2(event.response);
+      const endTurn = readBoolean2(response?.end_turn);
+      const status = response?.status;
+      if (endTurn !== undefined) {
+        output.endTurn = endTurn;
+      }
+      yield {
+        ...event,
+        type: "response.completed",
+        response: {
+          ...response,
+          status: type === "response.failed" ? "failed" : Value.Check(CodexResponseStatusSchema, status) ? status : undefined
+        }
+      };
+      if (type === "response.failed") {
+        const failure = readRecord2(response?.error);
+        throw new CodexApiError2(readText2(failure?.message) || "Codex response failed", {
+          code: readText2(failure?.code),
+          payload: event
+        });
+      }
+      return;
+    }
+    yield event;
+  }
+}
+async function* parseSSE2(response, signal, idleTimeoutMs) {
+  if (!response.body)
+    return;
+  for await (const { data } of iterateServerSentEvents2(response.body, signal, idleTimeoutMs)) {
+    if (data.trim() === "" || data === "[DONE]")
+      continue;
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch (cause) {
+      throw new CodexProtocolError2(`Invalid Codex SSE JSON: ${formatThrownValue2(cause)}`, {
+        cause,
+        payload: data
+      });
+    }
+    if (Value.Check(CodexFrameJson2, frame))
+      yield frame;
+  }
+}
+function parseJsonObject(raw) {
+  try {
+    return readRecord2(JSON.parse(raw));
+  } catch {
+    return;
+  }
+}
+function parseErrorResponse2(raw, response) {
+  const fallback = raw || response.statusText || "Request failed";
+  const err = readRecord2(parseJsonObject(raw)?.error);
+  if (!err)
+    return { message: fallback };
+  const code = readText2(err.code) ?? readText2(err.type) ?? "";
+  let friendlyMessage;
+  if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+    const planType = readText2(err.plan_type);
+    const plan = planType ? ` (${planType.toLowerCase()} plan)` : "";
+    const resetsAt = readNumber2(err.resets_at);
+    const mins = resetsAt ? Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60000)) : undefined;
+    const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+    friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
+  }
+  return { message: readText2(err.message) || friendlyMessage || fallback, friendlyMessage };
+}
+
+export { DEFAULT_MAX_RETRIES2, CODEX_TOOL_CALL_PROVIDERS2, compressRequestBodyZstd2, buildRequestBody2, resolveCodexServiceTier2, codexStreamOptions2, CodexRequestError2, retryableCodexRequest2, CodexApiError2, CodexProtocolError2, extractCodexEventError2, mapCodexEvents2, parseSSE2, parseErrorResponse2 };

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

@@ -0,0 +1,69 @@
+import {
+  defaultProviderAuthContext2
+} from "./account-limits-cache-1jv43fhh.js";
+import {
+  FileCredentialStore2
+} from "./account-limits-cache-yzyp0c2h.js";
+import {
+  FileModelsStore2
+} from "./account-limits-cache-a55e14fr.js";
+import {
+  createModels2
+} from "./account-limits-cache-5jdhn0e1.js";
+import {
+  anthropicProvider2
+} from "./account-limits-cache-8wfqg73s.js";
+import {
+  githubCopilotProvider2
+} from "./account-limits-cache-a1jyaq00.js";
+import {
+  openaiCodexProvider2
+} from "./account-limits-cache-09vs98g6.js";
+import {
+  openaiProvider2
+} from "./account-limits-cache-gsa5tzck.js";
+import {
+  opencodeProvider2
+} from "./account-limits-cache-nbkyhs6v.js";
+import {
+  opencodeGoProvider2
+} from "./account-limits-cache-nyy770yd.js";
+import {
+  openrouterProvider2
+} from "./account-limits-cache-pfa86y8e.js";
+import {
+  vercelAiGatewayProvider2
+} from "./account-limits-cache-q63mc41j.js";
+
+// src/providers/nyte-catalog.ts
+var NYTE_PROVIDERS = [
+  openaiCodexProvider2,
+  openaiProvider2,
+  anthropicProvider2,
+  opencodeProvider2,
+  opencodeGoProvider2,
+  githubCopilotProvider2,
+  vercelAiGatewayProvider2,
+  openrouterProvider2
+];
+var defaultModelPerProvider2 = {
+  "openai-codex": "gpt-5.6-luna",
+  openai: "gpt-5.6-luna",
+  anthropic: "claude-opus-5"
+};
+function createNyteModels2() {
+  const models = createModels2({
+    credentials: new FileCredentialStore2,
+    authContext: defaultProviderAuthContext2(),
+    modelsStore: new FileModelsStore2,
+    catalog: { url: process.env.NYTE_MODELS_URL }
+  });
+  for (const provider of nyteProviders2())
+    models.setProvider(provider);
+  return models;
+}
+function nyteProviders2() {
+  return NYTE_PROVIDERS.map((provider) => provider());
+}
+
+export { defaultModelPerProvider2, createNyteModels2, nyteProviders2 };

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

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