@nyte-ai/ai 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,399 @@
+import {
+  shortHash2
+} from "./account-limits-cache-0af5gqeg.js";
+import {
+  sanitizeSurrogates2
+} from "./account-limits-cache-eqwweapz.js";
+import {
+  getSystemMessageText2,
+  renderSystemMessageUpdate2
+} from "./account-limits-cache-b4edaybk.js";
+import {
+  resolveTranscript2,
+  resolveTranscriptTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  getJsonSchemaToolParameters2,
+  getGrammarToolInput2,
+  resolveJsonSchemaStrictSampling2,
+  resolveGrammarConstrainedSampling2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  transformMessages2
+} from "./account-limits-cache-8qzk56vj.js";
+import {
+  parseOpenAIReasoningDetails2,
+  parseLegacyEncryptedReasoningDetail2,
+  OpenAICompletionsReasoningFieldSchema2,
+  parseCopilotReasoningOpaque2
+} from "./account-limits-cache-hj1h48sc.js";
+
+// src/api/openai-completions-convert.ts
+import { Value } from "typebox/value";
+var DEFAULT_COMPAT = {
+  supportsStore: true,
+  supportsDeveloperRole: true,
+  supportsReasoningEffort: true,
+  supportsUsageInStreaming: true,
+  supportsFinishReason: true,
+  maxTokensField: "max_completion_tokens",
+  requiresToolResultName: false,
+  requiresAssistantAfterToolResult: false,
+  requiresThinkingAsText: false,
+  requiresReasoningContentOnAssistantMessages: false,
+  thinkingFormat: "openai",
+  openRouterRouting: {},
+  vercelGatewayRouting: {},
+  chatTemplateKwargs: {},
+  chatTemplateArgs: {},
+  zaiToolStream: false,
+  supportsStrictMode: false,
+  supportsOpenAIGrammarTools: false,
+  sendSessionAffinityHeaders: false,
+  sessionAffinityFormat: "openai",
+  supportsLongCacheRetention: true
+};
+function resolveCompat2(model) {
+  return { ...DEFAULT_COMPAT, ...model.compat };
+}
+function kimiToolSystemMessage(tools, compat) {
+  return {
+    role: "system",
+    tools: convertTools2(tools, compat)
+  };
+}
+function getToolsByName(tools, names) {
+  if (!tools)
+    return [];
+  const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+  return Array.from(names).map((name) => toolsByName.get(name)).filter((tool) => tool !== undefined);
+}
+function getCompatCacheControl2(compat, cacheRetention) {
+  if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") {
+    return;
+  }
+  const cacheControl = { type: "ephemeral" };
+  if (cacheRetention === "long" && compat.supportsLongCacheRetention)
+    cacheControl.ttl = "1h";
+  return cacheControl;
+}
+function applyAnthropicCacheControl2(messages, tools, cacheControl) {
+  addCacheControlToSystemPrompt(messages, cacheControl);
+  addCacheControlToLastTool(tools, cacheControl);
+  addCacheControlToLastConversationMessage(messages, cacheControl);
+}
+function addCacheControlToSystemPrompt(messages, cacheControl) {
+  for (const message of messages) {
+    if (message.role === "system" || message.role === "developer") {
+      addCacheControlToTextContent(message, cacheControl);
+      return;
+    }
+  }
+}
+function addCacheControlToLastConversationMessage(messages, cacheControl) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
+      if (addCacheControlToMessage(message, cacheControl)) {
+        return;
+      }
+    }
+  }
+}
+function addCacheControlToLastTool(tools, cacheControl) {
+  if (!tools || tools.length === 0) {
+    return;
+  }
+  Object.assign(tools[tools.length - 1], { cache_control: cacheControl });
+}
+function addCacheControlToMessage(message, cacheControl) {
+  if (message.role === "user" || message.role === "assistant" || message.role === "tool") {
+    return addCacheControlToTextContent(message, cacheControl);
+  }
+  return false;
+}
+function addCacheControlToTextContent(message, cacheControl) {
+  const content = message.content;
+  if (Array.isArray(content)) {
+    const textPart = content.findLast((part) => part?.type === "text");
+    if (textPart === undefined)
+      return false;
+    Object.assign(textPart, { cache_control: cacheControl });
+    return true;
+  }
+  if (!content) {
+    return false;
+  }
+  const textPart = {
+    type: "text",
+    text: content,
+    cache_control: cacheControl
+  };
+  message.content = [textPart];
+  return true;
+}
+function normalizeToolCallId(id, provider) {
+  if (id.includes("|")) {
+    const [rawCallId, ...itemParts] = id.split("|");
+    const callId = rawCallId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const itemId = itemParts.join("|").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const combinedId = itemId.length > 0 ? `${callId}_${itemId}` : callId;
+    if (combinedId.length <= 40) {
+      return combinedId;
+    }
+    const hash = shortHash2(id).slice(0, 8);
+    const prefix = callId.slice(0, Math.max(1, 40 - hash.length - 1));
+    return `${prefix}_${hash}`;
+  }
+  if (provider === "openai")
+    return id.length > 40 ? id.slice(0, 40) : id;
+  return id;
+}
+function convertMessages2(model, context, compat, options) {
+  const normalizedContext = resolveTranscript2(context, compat.supportsMidConvoSystemMessages);
+  const params = [];
+  const transformedMessages = transformMessages2(normalizedContext.messages, model, (id) => normalizeToolCallId(id, model.provider));
+  const transcriptTools = resolveTranscriptTools2(normalizedContext.messages, compat.supportsMidConvoSystemMessages === true && compat.supportsMidConvoToolAdditions === true);
+  const requestTools = compat.deferredToolsMode === "kimi" ? transcriptTools.requestTools : [];
+  const instructionRole = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
+  let lastRole = null;
+  for (let i = 0;i < transformedMessages.length; i++) {
+    const msg = transformedMessages[i];
+    if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
+      params.push({
+        role: "assistant",
+        content: "I have processed the tool results."
+      });
+    }
+    if (msg.role === "system") {
+      const addedTools = i > 0 && transcriptTools.anchorsAdditions ? msg.toolsAdded ?? [] : [];
+      if (addedTools.length > 0) {
+        params.push(kimiToolSystemMessage(addedTools, compat));
+      }
+      const text = i === 0 ? getSystemMessageText2(msg) : renderSystemMessageUpdate2(msg);
+      if (text.length > 0) {
+        params.push({ role: instructionRole, content: sanitizeSurrogates2(text) });
+      }
+    } else if (msg.role === "user") {
+      if (!Array.isArray(msg.content)) {
+        params.push({
+          role: "user",
+          content: sanitizeSurrogates2(msg.content)
+        });
+      } else {
+        const content = msg.content.filter((item) => item.type !== "text" || item.text.length > 0).map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "text",
+              text: sanitizeSurrogates2(item.text)
+            };
+          } else {
+            return {
+              type: "image_url",
+              image_url: {
+                url: `data:${item.mimeType};base64,${item.data}`
+              }
+            };
+          }
+        });
+        if (content.length === 0)
+          continue;
+        params.push({
+          role: "user",
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const assistantMsg = {
+        role: "assistant",
+        content: compat.requiresAssistantAfterToolResult ? "" : null
+      };
+      const assistantTextParts = msg.content.filter((block) => block.type === "text").filter((block) => block.text.trim().length > 0).map((block) => ({
+        type: "text",
+        text: sanitizeSurrogates2(block.text)
+      }));
+      const assistantText = assistantTextParts.map((part) => part.text).join("");
+      const thinkingBlocks = msg.content.filter((block) => block.type === "thinking");
+      const toolCalls = msg.content.filter((block) => block.type === "toolCall");
+      const signedReasoningDetails = thinkingBlocks.map((block) => parseOpenAIReasoningDetails2(block.thinkingSignature)).find((details) => details !== undefined);
+      const legacyReasoningDetails = toolCalls.map((toolCall) => parseLegacyEncryptedReasoningDetail2(toolCall.thoughtSignature)).filter((detail) => detail !== undefined);
+      const preservedReasoningDetails = signedReasoningDetails ?? (legacyReasoningDetails.length > 0 ? legacyReasoningDetails : undefined);
+      const nonEmptyThinkingBlocks = thinkingBlocks.filter((block) => block.thinking.trim().length > 0);
+      const copilotReasoningOpaque = model.provider === "github-copilot" ? thinkingBlocks.map((block) => parseCopilotReasoningOpaque2(block.thinkingSignature)).find((opaque) => opaque !== undefined) : undefined;
+      if (model.provider === "github-copilot") {
+        if (assistantText.length > 0) {
+          assistantMsg.content = assistantText;
+        }
+        if (copilotReasoningOpaque !== undefined) {
+          assistantMsg.reasoning_opaque = copilotReasoningOpaque;
+          if (nonEmptyThinkingBlocks.length > 0) {
+            assistantMsg.reasoning_text = nonEmptyThinkingBlocks.map((block) => block.thinking).join(`
+`);
+          }
+        }
+      } else if (nonEmptyThinkingBlocks.length > 0) {
+        if (compat.requiresThinkingAsText) {
+          const thinkingText = nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates2(block.thinking)).join(`
+
+`);
+          assistantMsg.content = [{ type: "text", text: thinkingText }, ...assistantTextParts];
+        } else {
+          if (assistantText.length > 0) {
+            assistantMsg.content = assistantText;
+          }
+          if (!preservedReasoningDetails) {
+            let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+            if (model.provider === "opencode-go" && signature === "reasoning") {
+              signature = "reasoning_content";
+            }
+            if (signature && Value.Check(OpenAICompletionsReasoningFieldSchema2, signature)) {
+              assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join(`
+`);
+            }
+          }
+        }
+      } else if (assistantText.length > 0) {
+        assistantMsg.content = assistantText;
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls.map((tc) => {
+          const customInputProperty = options?.grammarToolInputProperties?.get(tc.name);
+          if (customInputProperty !== undefined) {
+            return {
+              id: tc.id,
+              type: "custom",
+              custom: {
+                name: tc.name,
+                input: sanitizeSurrogates2(getGrammarToolInput2(tc.name, tc.arguments, customInputProperty))
+              }
+            };
+          }
+          return {
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.arguments)
+            }
+          };
+        });
+      }
+      if (preservedReasoningDetails) {
+        assistantMsg.reasoning_details = preservedReasoningDetails;
+      }
+      if (compat.requiresReasoningContentOnAssistantMessages && model.reasoning && assistantMsg.reasoning_content === undefined) {
+        assistantMsg.reasoning_content = "";
+      }
+      const content = assistantMsg.content;
+      const hasContent = content !== null && content !== undefined && content.length > 0;
+      if (!hasContent && !assistantMsg.tool_calls) {
+        continue;
+      }
+      params.push(assistantMsg);
+    } else if (msg.role === "toolResult") {
+      const imageBlocks = [];
+      const deferredToolNames = new Set;
+      let j = i;
+      for (;j < transformedMessages.length; j++) {
+        const toolMsg = transformedMessages[j];
+        if (toolMsg.role !== "toolResult")
+          break;
+        const textResult = toolMsg.content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+        const hasImages = toolMsg.content.some((c) => c.type === "image");
+        const hasText = textResult.length > 0;
+        const toolResultText = hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)";
+        const toolResultMsg = {
+          role: "tool",
+          content: sanitizeSurrogates2(toolResultText),
+          tool_call_id: toolMsg.toolCallId
+        };
+        if (compat.requiresToolResultName && toolMsg.toolName) {
+          toolResultMsg.name = toolMsg.toolName;
+        }
+        params.push(toolResultMsg);
+        if (compat.deferredToolsMode === "kimi") {
+          for (const name of toolMsg.addedToolNames ?? []) {
+            deferredToolNames.add(name);
+          }
+        }
+        if (hasImages && model.input.includes("image")) {
+          for (const block of toolMsg.content) {
+            if (block.type === "image") {
+              imageBlocks.push({
+                type: "image_url",
+                image_url: {
+                  url: `data:${block.mimeType};base64,${block.data}`
+                }
+              });
+            }
+          }
+        }
+      }
+      i = j - 1;
+      if (imageBlocks.length > 0) {
+        if (compat.requiresAssistantAfterToolResult) {
+          params.push({
+            role: "assistant",
+            content: "I have processed the tool results."
+          });
+        }
+        params.push({
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "Attached image(s) from tool result:"
+            },
+            ...imageBlocks
+          ]
+        });
+        lastRole = "user";
+      } else {
+        lastRole = "toolResult";
+      }
+      if (deferredToolNames.size > 0) {
+        const deferredTools = getToolsByName(requestTools, deferredToolNames);
+        if (deferredTools.length > 0) {
+          params.push(kimiToolSystemMessage(deferredTools, compat));
+        }
+      }
+      continue;
+    }
+    lastRole = msg.role;
+  }
+  return params;
+}
+function convertTools2(tools, compat) {
+  return tools.map((tool) => {
+    const grammar = resolveGrammarConstrainedSampling2(tool, compat.supportsOpenAIGrammarTools);
+    if (grammar) {
+      return {
+        type: "custom",
+        custom: {
+          name: tool.name,
+          description: tool.description,
+          format: {
+            type: "grammar",
+            grammar: {
+              syntax: grammar.format,
+              definition: grammar.definition
+            }
+          }
+        }
+      };
+    }
+    const strict = resolveJsonSchemaStrictSampling2(tool, compat.supportsStrictMode !== false);
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: getJsonSchemaToolParameters2(tool, strict),
+        ...compat.supportsStrictMode !== false && { strict: strict ?? false }
+      }
+    };
+  });
+}
+
+export { resolveCompat2, getCompatCacheControl2, applyAnthropicCacheControl2, convertMessages2, convertTools2 };

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

@@ -0,0 +1,22 @@
+// src/providers/opencode-headers.ts
+var OPENCODE_SESSION_HEADER = "x-opencode-session";
+function withSessionHeader(options) {
+  if (!options?.sessionId)
+    return options;
+  const overridden = Object.keys(options.headers ?? {}).some((key) => key.toLowerCase() === OPENCODE_SESSION_HEADER);
+  if (overridden)
+    return options;
+  return {
+    ...options,
+    headers: { ...options.headers, [OPENCODE_SESSION_HEADER]: options.sessionId }
+  };
+}
+function withOpenCodeSessionHeader2(streams) {
+  return {
+    ...streams,
+    stream: (model, context, options) => streams.stream(model, context, withSessionHeader(options)),
+    streamSimple: (model, context, options) => streams.streamSimple(model, context, withSessionHeader(options))
+  };
+}
+
+export { withOpenCodeSessionHeader2 };

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

@@ -0,0 +1,17 @@
+import {
+  providerRequest2
+} from "./account-limits-cache-031vfpt3.js";
+
+// src/api/deferred.ts
+async function compactOpenAICodexContext2(selected, context, selectedOptions) {
+  const api = await import("../src/api/openai-codex-compact.js");
+  const { model, options } = providerRequest2(selected, selectedOptions);
+  return api.compactOpenAICodexContext(model, context, options);
+}
+async function compactOpenAIResponsesContext2(selected, context, selectedOptions) {
+  const api = await import("../src/api/openai-responses.js");
+  const { model, options } = providerRequest2(selected, selectedOptions);
+  return api.compactOpenAIResponsesContext(model, context, options);
+}
+
+export { compactOpenAICodexContext2, compactOpenAIResponsesContext2 };

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

@@ -0,0 +1,69 @@
+import {
+  normalizeProviderError2,
+  formatProviderError2
+} from "./account-limits-cache-zcbkmrvy.js";
+import {
+  AssistantMessageEventStream2
+} from "./account-limits-cache-a6cgeagz.js";
+
+// src/api/assistant-stream.ts
+function emptyCost2() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+}
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: emptyCost2() };
+}
+function emptyAssistantOutput2(model) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: emptyUsage(),
+    stopReason: "pending",
+    timestamp: Date.now()
+  };
+}
+function stripStreamingScratchState2(content) {
+  for (const block of content) {
+    if ("partialJson" in block)
+      delete block.partialJson;
+    if ("partialArgs" in block)
+      delete block.partialArgs;
+    if ("customInput" in block)
+      delete block.customInput;
+    if ("streamIndex" in block)
+      delete block.streamIndex;
+  }
+}
+function formatStreamError(error) {
+  return formatProviderError2(normalizeProviderError2(error));
+}
+function runAssistantStream2(model, signal, label, body, formatError = formatStreamError) {
+  const stream = new AssistantMessageEventStream2;
+  const output = emptyAssistantOutput2(model);
+  (async () => {
+    try {
+      await body(output, stream);
+      if (signal?.aborted)
+        throw new Error("Request was aborted");
+      if (output.stopReason === "pending") {
+        throw new Error(`${label} stream ended without a stop reason`);
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+      }
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+    } catch (error) {
+      stripStreamingScratchState2(output.content);
+      output.stopReason = signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatError(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+    }
+    stream.end();
+  })();
+  return stream;
+}
+
+export { emptyCost2, emptyAssistantOutput2, stripStreamingScratchState2, runAssistantStream2 };

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

@@ -0,0 +1,110 @@
+import {
+  providerHeadersToRecord2
+} from "./account-limits-cache-ag5b8dja.js";
+import {
+  getNyteUserAgent2
+} from "./account-limits-cache-gknnm1kv.js";
+
+// src/api/openai-codex-wire.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var CodexFrameJson2 = Type.Object({ type: Type.String() });
+var TextJson = Type.String();
+var BooleanJson = Type.Boolean();
+var NumberJson = Type.Number();
+var JsonObjectJson = Type.Record(Type.String(), Type.Unknown());
+function readText2(value) {
+  return Value.Check(TextJson, value) ? value : undefined;
+}
+function readBoolean2(value) {
+  return Value.Check(BooleanJson, value) ? value : undefined;
+}
+function readNumber2(value) {
+  return Value.Check(NumberJson, value) ? value : undefined;
+}
+function readRecord2(value) {
+  return Value.Check(JsonObjectJson, value) ? value : undefined;
+}
+var TERMINAL_RESPONSE_TYPES2 = new Set([
+  "response.completed",
+  "response.done",
+  "response.incomplete",
+  "response.failed"
+]);
+var DEFAULT_CODEX_BASE_URL2 = "https://chatgpt.com/backend-api";
+var OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+var AccessTokenClaimsSchema = Type.Object({
+  "https://api.openai.com/auth": Type.Object({
+    chatgpt_account_id: Type.String({ minLength: 1 })
+  })
+});
+function normalizeTimeoutMs2(value) {
+  if (value === undefined)
+    return;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`Invalid timeoutMs: ${String(value)}`);
+  }
+  return Math.floor(value);
+}
+function resolveCodexUrl2(baseUrl) {
+  const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL2;
+  const normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses"))
+    return normalized;
+  if (normalized.endsWith("/codex"))
+    return `${normalized}/responses`;
+  return `${normalized}/codex/responses`;
+}
+function resolveCodexWebSocketUrl2(baseUrl) {
+  const url = new URL(resolveCodexUrl2(baseUrl));
+  if (url.protocol === "https:")
+    url.protocol = "wss:";
+  if (url.protocol === "http:")
+    url.protocol = "ws:";
+  return url.toString();
+}
+function extractAccountId2(token) {
+  const parts = token.split(".");
+  let claims;
+  try {
+    claims = parts.length === 3 ? JSON.parse(atob(parts[1])) : undefined;
+  } catch {
+    claims = undefined;
+  }
+  if (!Value.Check(AccessTokenClaimsSchema, claims)) {
+    throw new Error("Failed to extract accountId from token");
+  }
+  return claims["https://api.openai.com/auth"].chatgpt_account_id;
+}
+function buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token) {
+  const headers = new Headers(Object.entries(providerHeadersToRecord2(initHeaders, additionalHeaders) ?? {}));
+  headers.set("Authorization", `Bearer ${token}`);
+  headers.set("chatgpt-account-id", accountId);
+  headers.set("originator", "nyte");
+  headers.set("User-Agent", getNyteUserAgent2());
+  return headers;
+}
+function buildSSEHeaders2(initHeaders, additionalHeaders, accountId, token, sessionId) {
+  const headers = buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token);
+  headers.set("OpenAI-Beta", "responses=experimental");
+  headers.set("accept", "text/event-stream");
+  headers.set("content-type", "application/json");
+  if (sessionId) {
+    headers.set("session-id", sessionId);
+    headers.set("x-client-request-id", sessionId);
+  }
+  return headers;
+}
+function buildWebSocketHeaders2(initHeaders, additionalHeaders, accountId, token, requestId) {
+  const headers = buildBaseCodexHeaders2(initHeaders, additionalHeaders, accountId, token);
+  headers.delete("accept");
+  headers.delete("content-type");
+  headers.delete("OpenAI-Beta");
+  headers.delete("openai-beta");
+  headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+  headers.set("x-client-request-id", requestId);
+  headers.set("session-id", requestId);
+  return headers;
+}
+
+export { CodexFrameJson2, readText2, readBoolean2, readNumber2, readRecord2, TERMINAL_RESPONSE_TYPES2, DEFAULT_CODEX_BASE_URL2, normalizeTimeoutMs2, resolveCodexUrl2, resolveCodexWebSocketUrl2, extractAccountId2, buildBaseCodexHeaders2, buildSSEHeaders2, buildWebSocketHeaders2 };

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

@@ -0,0 +1,13 @@
+// src/utils/nyte-user-agent.ts
+function loadNodeOs() {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  return process.getBuiltinModule?.("node:os") ?? null;
+}
+var nodeOs = loadNodeOs();
+function getNyteUserAgent2() {
+  return nodeOs ? `nyte (${nodeOs.platform()} ${nodeOs.release()}; ${nodeOs.arch()})` : "nyte (browser)";
+}
+
+export { getNyteUserAgent2 };

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

@@ -0,0 +1,40 @@
+// src/session-resources.ts
+var sessionResourceCleanups = new Set;
+var sessionResourceLeases = new Map;
+function registerSessionResourceCleanup2(cleanup) {
+  sessionResourceCleanups.add(cleanup);
+  return () => {
+    sessionResourceCleanups.delete(cleanup);
+  };
+}
+function cleanupSessionResources2(sessionId) {
+  const errors = [];
+  for (const cleanup of sessionResourceCleanups) {
+    try {
+      cleanup(sessionId);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) {
+    throw new AggregateError(errors, "Failed to cleanup session resources");
+  }
+}
+function acquireSessionResources2(sessionId) {
+  sessionResourceLeases.set(sessionId, (sessionResourceLeases.get(sessionId) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    const remaining = (sessionResourceLeases.get(sessionId) ?? 1) - 1;
+    if (remaining > 0) {
+      sessionResourceLeases.set(sessionId, remaining);
+      return;
+    }
+    sessionResourceLeases.delete(sessionId);
+    cleanupSessionResources2(sessionId);
+  };
+}
+
+export { registerSessionResourceCleanup2, cleanupSessionResources2, acquireSessionResources2 };