@nyte-ai/ai 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,92 @@
+// src/api/openai-completions-reasoning.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var reasoningDetailFields = {
+  id: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  format: Type.Optional(Type.String()),
+  index: Type.Optional(Type.Number())
+};
+var OpenAIReasoningDetailSchema2 = Type.Union([
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.summary"),
+    summary: Type.String()
+  }),
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.encrypted"),
+    data: Type.String()
+  }),
+  Type.Object({
+    ...reasoningDetailFields,
+    type: Type.Literal("reasoning.text"),
+    text: Type.String(),
+    signature: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+  })
+]);
+var OpenAIReasoningDetailsSchema = Type.Array(OpenAIReasoningDetailSchema2, { minItems: 1 });
+function parseOpenAIReasoningDetails2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(OpenAIReasoningDetailsSchema, parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function parseLegacyEncryptedReasoningDetail2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(OpenAIReasoningDetailSchema2, parsed) && parsed.type === "reasoning.encrypted" && parsed.id !== undefined && parsed.id !== null && parsed.id.length > 0 && parsed.data.length > 0 ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function fillMissingCommonReasoningDetailFields(target, source) {
+  target.id ??= source.id;
+  target.format ||= source.format;
+  target.index ??= source.index;
+}
+function appendOpenAIReasoningDetail2(details, detail) {
+  const lastDetail = details.at(-1);
+  if (detail.type === "reasoning.text" && lastDetail?.type === "reasoning.text") {
+    lastDetail.text += detail.text;
+    lastDetail.signature ||= detail.signature;
+    fillMissingCommonReasoningDetailFields(lastDetail, detail);
+    return;
+  }
+  if (detail.type === "reasoning.summary" && lastDetail?.type === "reasoning.summary") {
+    lastDetail.summary += detail.summary;
+    fillMissingCommonReasoningDetailFields(lastDetail, detail);
+    return;
+  }
+  details.push({ ...detail });
+}
+var OPENAI_COMPLETIONS_REASONING_FIELDS = [
+  "reasoning",
+  "reasoning_content",
+  "reasoning_text"
+];
+var OpenAICompletionsReasoningFieldSchema2 = Type.Enum(OPENAI_COMPLETIONS_REASONING_FIELDS);
+var CopilotReasoningOpaqueSchema2 = Type.Object({
+  reasoning_opaque: Type.String({ minLength: 1 })
+});
+var REASONING_DELTA_SCHEMAS2 = ["reasoning_content", "reasoning", "reasoning_text"].map((field) => ({ field, schema: Type.Object({ [field]: Type.String({ minLength: 1 }) }) }));
+var ReasoningDetailsDeltaSchema2 = Type.Object({
+  reasoning_details: Type.Array(Type.Unknown())
+});
+function parseCopilotReasoningOpaque2(signature) {
+  if (!signature)
+    return;
+  try {
+    const parsed = JSON.parse(signature);
+    return Value.Check(CopilotReasoningOpaqueSchema2, parsed) ? parsed.reasoning_opaque : undefined;
+  } catch {
+    return;
+  }
+}
+
+export { OpenAIReasoningDetailSchema2, parseOpenAIReasoningDetails2, parseLegacyEncryptedReasoningDetail2, appendOpenAIReasoningDetail2, OpenAICompletionsReasoningFieldSchema2, CopilotReasoningOpaqueSchema2, REASONING_DELTA_SCHEMAS2, ReasoningDetailsDeltaSchema2, parseCopilotReasoningOpaque2 };

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

@@ -0,0 +1,128 @@
+import {
+  DEFAULT_CODEX_BASE_URL2,
+  extractAccountId2,
+  buildBaseCodexHeaders2
+} from "./account-limits-cache-fvadc36m.js";
+import {
+  limitWindow2,
+  fetchAccountUsage2
+} from "./account-limits-cache-ehy0ze2b.js";
+
+// src/providers/openai-codex-limits.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var OptionalJsonNumber = Type.Optional(Type.Union([Type.Number(), Type.Null()]));
+var CodexUsageWindowSchema = Type.Object({
+  used_percent: Type.Number(),
+  limit_window_seconds: OptionalJsonNumber,
+  reset_at: OptionalJsonNumber
+});
+var CodexUsageResponseSchema = Type.Object({
+  rate_limit: Type.Optional(Type.Union([
+    Type.Object({
+      primary_window: Type.Optional(Type.Unknown()),
+      secondary_window: Type.Optional(Type.Unknown())
+    }),
+    Type.Null()
+  ]))
+});
+var CodexPlanSchema = Type.Object({ plan_type: Type.String() });
+var CodexRateLimitsFrameSchema = Type.Object({
+  type: Type.Literal("codex.rate_limits"),
+  plan_type: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  rate_limits: Type.Optional(Type.Union([
+    Type.Object({
+      primary: Type.Optional(Type.Unknown()),
+      secondary: Type.Optional(Type.Unknown())
+    }),
+    Type.Null()
+  ]))
+});
+var CodexRateLimitWindowSchema = Type.Object({
+  used_percent: Type.Number(),
+  window_minutes: OptionalJsonNumber,
+  reset_at: OptionalJsonNumber
+});
+var FIVE_HOURS_SECONDS = 5 * 60 * 60;
+var WEEK_SECONDS = 7 * 24 * 60 * 60;
+function durationLabel(seconds) {
+  if (seconds === WEEK_SECONDS)
+    return "Weekly";
+  if (seconds % (24 * 60 * 60) === 0)
+    return `${String(seconds / (24 * 60 * 60))}-day`;
+  if (seconds % (60 * 60) === 0)
+    return `${String(seconds / (60 * 60))}-hour`;
+  return `${String(Math.round(seconds / 60))}-minute`;
+}
+function codexLimitWindow(fallbackId, usedPercent, windowSeconds, resetAtSeconds) {
+  const id = windowSeconds === FIVE_HOURS_SECONDS ? "five_hour" : windowSeconds === WEEK_SECONDS ? "seven_day" : fallbackId;
+  const label = windowSeconds === undefined || windowSeconds === null ? fallbackId === "primary" ? "Primary" : "Secondary" : durationLabel(windowSeconds);
+  return limitWindow2(id, label, usedPercent, resetAtSeconds === undefined || resetAtSeconds === null ? undefined : resetAtSeconds * 1000, windowSeconds === undefined || windowSeconds === null ? undefined : windowSeconds / 60);
+}
+function minutesWindow(fallbackId, window) {
+  if (!window.window_minutes)
+    return;
+  return codexLimitWindow(fallbackId, window.used_percent, window.window_minutes * 60, window.reset_at);
+}
+function accountLimits(providerId, windows, plan) {
+  if (windows.length === 0)
+    return;
+  const limits = { providerId, windows, observedAt: Date.now() };
+  if (plan)
+    limits.plan = plan;
+  return limits;
+}
+function codexFrameLimits2(frame, providerId) {
+  if (!Value.Check(CodexRateLimitsFrameSchema, frame))
+    return;
+  const windows = [];
+  for (const id of ["primary", "secondary"]) {
+    const window = frame.rate_limits?.[id];
+    const parsed = Value.Check(CodexRateLimitWindowSchema, window) ? minutesWindow(id, window) : undefined;
+    if (parsed !== undefined)
+      windows.push(parsed);
+  }
+  return accountLimits(providerId, windows, frame.plan_type);
+}
+function codexHeaderLimits2(headers, providerId) {
+  const windows = [];
+  for (const id of ["primary", "secondary"]) {
+    const usedPercent = Number(headers[`x-codex-${id}-used-percent`]);
+    if (!Number.isFinite(usedPercent))
+      continue;
+    const resetHeader = headers[`x-codex-${id}-reset-at`];
+    const resetAt = resetHeader ? Number(resetHeader) : Number.NaN;
+    const parsed = minutesWindow(id, {
+      used_percent: usedPercent,
+      window_minutes: Number(headers[`x-codex-${id}-window-minutes`]),
+      reset_at: Number.isFinite(resetAt) ? resetAt : null
+    });
+    if (parsed !== undefined)
+      windows.push(parsed);
+  }
+  return accountLimits(providerId, windows, headers["x-codex-plan-type"]);
+}
+async function fetchOpenAICodexAccountLimits2(model, options) {
+  const apiKey = options?.apiKey;
+  if (!apiKey)
+    throw new Error(`No API key for provider: ${model.provider}`);
+  const headers = buildBaseCodexHeaders2(model.headers, options?.headers, extractAccountId2(apiKey), apiKey);
+  headers.set("accept", "application/json");
+  const baseUrl = (model.baseUrl?.trim() || DEFAULT_CODEX_BASE_URL2).replace(/\/+$/, "").replace(/\/codex$/, "");
+  const decoded = await fetchAccountUsage2(`${baseUrl}/wham/usage`, headers, options, CodexUsageResponseSchema, "Codex");
+  const windows = [];
+  for (const [id, window] of [
+    ["primary", decoded.rate_limit?.primary_window],
+    ["secondary", decoded.rate_limit?.secondary_window]
+  ]) {
+    if (!Value.Check(CodexUsageWindowSchema, window))
+      continue;
+    windows.push(codexLimitWindow(id, window.used_percent, window.limit_window_seconds, window.reset_at));
+  }
+  const limits = { providerId: model.provider, windows, observedAt: Date.now() };
+  if (Value.Check(CodexPlanSchema, decoded))
+    limits.plan = decoded.plan_type;
+  return limits;
+}
+
+export { codexFrameLimits2, codexHeaderLimits2, fetchOpenAICodexAccountLimits2 };