@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-031vfpt3.js

@@ -0,0 +1,37 @@
+import {
+  getFastModeCostMultiplier2
+} from "./account-limits-cache-f9z00x8c.js";
+
+// src/model-variants.ts
+var FAST_MODEL_SUFFIX2 = "-fast";
+function fastModelId2(base) {
+  return `${base}${FAST_MODEL_SUFFIX2}`;
+}
+function supportsFastMode2(model) {
+  return model.variant === undefined && model.modes?.includes("fast") === true && getFastModeCostMultiplier2(model) !== undefined;
+}
+function withFastVariants2(models) {
+  const ids = new Set(models.map((model) => model.id));
+  return models.flatMap((model) => supportsFastMode2(model) && !ids.has(fastModelId2(model.id)) ? [
+    model,
+    {
+      ...model,
+      id: fastModelId2(model.id),
+      name: `${model.name} Fast`,
+      variant: { mode: "fast", base: model.id }
+    }
+  ] : [model]);
+}
+function baseModel2(model) {
+  return model.variant === undefined ? model : { ...model, id: model.variant.base, variant: undefined };
+}
+function providerIdentity2(model) {
+  return { provider: model.provider, api: model.api, model: model.variant?.base ?? model.id };
+}
+function providerRequest2(model, options) {
+  if (model.variant?.mode !== "fast")
+    return { model, options };
+  return { model: baseModel2(model), options: { ...options, fast: true } };
+}
+
+export { FAST_MODEL_SUFFIX2, fastModelId2, supportsFastMode2, withFastVariants2, baseModel2, providerIdentity2, providerRequest2 };

package/dist/chunks/account-limits-cache-09vs98g6.js

@@ -0,0 +1,41 @@
+import {
+  openAICodexResponsesApi2
+} from "./account-limits-cache-5rx2pfm5.js";
+import {
+  fetchOpenAICodexAccountLimits2
+} from "./account-limits-cache-hj3ek3ty.js";
+import {
+  lazyOAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  loadOpenAICodexOAuth2
+} from "./account-limits-cache-v4n30az2.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+
+// src/providers/openai-codex.ts
+function openaiCodexProvider2() {
+  return createProvider2({
+    id: "openai-codex",
+    name: "OpenAI Codex",
+    baseUrl: "https://chatgpt.com/backend-api",
+    promptCache: {
+      minimumRetentionMs: { short: 5 * 60000, long: 5 * 60000 }
+    },
+    auth: {
+      oauth: lazyOAuth2({
+        name: "OpenAI (ChatGPT Plus/Pro)",
+        isSubscription: true,
+        load: loadOpenAICodexOAuth2
+      })
+    },
+    fetchAccountLimits: ({ auth, signal }) => fetchOpenAICodexAccountLimits2({
+      provider: "openai-codex",
+      baseUrl: auth.baseUrl ?? "https://chatgpt.com/backend-api"
+    }, { apiKey: auth.apiKey, headers: auth.headers, signal }),
+    api: { "openai-codex-responses": openAICodexResponsesApi2() }
+  });
+}
+
+export { openaiCodexProvider2 };

package/dist/chunks/account-limits-cache-0af5gqeg.js

@@ -0,0 +1,15 @@
+// src/utils/hash.ts
+function shortHash2(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0;i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+
+export { shortHash2 };

package/dist/chunks/account-limits-cache-0yd6bde8.js

@@ -0,0 +1,103 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+
+// src/utils/node-http-proxy.ts
+var DEFAULT_PROXY_PORTS = new Map([
+  ["ftp", 21],
+  ["gopher", 70],
+  ["http", 80],
+  ["https", 443],
+  ["ws", 80],
+  ["wss", 443]
+]);
+function getProxyEnv(key, env) {
+  const lowercaseKey = key.toLowerCase();
+  const uppercaseKey = key.toUpperCase();
+  return env?.[lowercaseKey] || env?.[uppercaseKey] || getProviderEnvValue2(lowercaseKey) || getProviderEnvValue2(uppercaseKey) || "";
+}
+function parseProxyTargetUrl(targetUrl) {
+  if (targetUrl instanceof URL) {
+    return targetUrl;
+  }
+  try {
+    return new URL(targetUrl);
+  } catch {
+    return;
+  }
+}
+function stripBrackets(host) {
+  return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+}
+function parseNoProxyEntry(entry) {
+  const trimmed = entry.trim().toLowerCase();
+  if (!trimmed)
+    return;
+  const bracketed = /^\[([^\]]*)\](.*)$/su.exec(trimmed);
+  if (bracketed) {
+    const [, host, rest] = bracketed;
+    const port = rest.startsWith(":") ? Number.parseInt(rest.slice(1), 10) : 0;
+    return { host, port: Number.isNaN(port) ? 0 : port };
+  }
+  const parts = trimmed.split(":");
+  if (parts.length !== 2)
+    return { host: trimmed, port: 0 };
+  const [host, portText] = parts;
+  const port = Number.parseInt(portText, 10);
+  return Number.isNaN(port) ? { host: trimmed, port: 0 } : { host, port };
+}
+function shouldProxyHostname(hostname, port, env) {
+  const noProxy = getProxyEnv("no_proxy", env).toLowerCase();
+  if (!noProxy) {
+    return true;
+  }
+  if (noProxy === "*") {
+    return false;
+  }
+  const targetHost = stripBrackets(hostname.toLowerCase());
+  return noProxy.split(/[,\s]/).every((entry) => {
+    const parsed = parseNoProxyEntry(entry);
+    if (!parsed || parsed.port && parsed.port !== port) {
+      return true;
+    }
+    const host = stripBrackets(parsed.host);
+    const domain = host.startsWith("*.") ? host.slice(2) : host.startsWith(".") || host.startsWith("*") ? host.slice(1) : host;
+    return !domain || targetHost !== domain && !targetHost.endsWith(`.${domain}`);
+  });
+}
+function getProxyForUrl(targetUrl, env) {
+  const parsedUrl = parseProxyTargetUrl(targetUrl);
+  if (!parsedUrl?.protocol || !parsedUrl.host) {
+    return "";
+  }
+  const protocol = parsedUrl.protocol.split(":", 1)[0];
+  const hostname = stripBrackets(parsedUrl.hostname || parsedUrl.host.replace(/:\d*$/, ""));
+  const port = Number.parseInt(parsedUrl.port, 10) || DEFAULT_PROXY_PORTS.get(protocol) || 0;
+  if (!shouldProxyHostname(hostname, port, env)) {
+    return "";
+  }
+  let proxy = getProxyEnv(`${protocol}_proxy`, env) || getProxyEnv("all_proxy", env);
+  if (proxy && !proxy.includes("://")) {
+    proxy = `${protocol}://${proxy}`;
+  }
+  return proxy;
+}
+var UNSUPPORTED_PROXY_PROTOCOL_MESSAGE2 = "Unsupported proxy protocol. SOCKS and PAC proxy URLs are not supported; use an HTTP or HTTPS proxy URL.";
+function resolveHttpProxyUrlForTarget2(targetUrl, env) {
+  const proxy = getProxyForUrl(targetUrl, env);
+  if (!proxy) {
+    return;
+  }
+  let proxyUrl;
+  try {
+    proxyUrl = new URL(proxy);
+  } catch (error) {
+    throw new Error(`Invalid proxy URL ${JSON.stringify(proxy)}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (proxyUrl.protocol !== "http:" && proxyUrl.protocol !== "https:") {
+    throw new Error(`${UNSUPPORTED_PROXY_PROTOCOL_MESSAGE2} Got ${proxyUrl.protocol}`);
+  }
+  return proxyUrl;
+}
+
+export { UNSUPPORTED_PROXY_PROTOCOL_MESSAGE2, resolveHttpProxyUrlForTarget2 };

package/dist/chunks/account-limits-cache-1jv43fhh.js

@@ -0,0 +1,22 @@
+// src/auth/context.ts
+function defaultProviderAuthContext2() {
+  return {
+    async env(name) {
+      if (typeof process === "undefined")
+        return;
+      const value = process.env[name];
+      return value !== undefined && value.trim().length > 0 ? value : undefined;
+    },
+    async fileExists(path) {
+      try {
+        const resolved = path.startsWith("~") ? process.getBuiltinModule("node:os").homedir() + path.slice(1) : path;
+        await process.getBuiltinModule("node:fs/promises").access(resolved);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+export { defaultProviderAuthContext2 };

package/dist/chunks/account-limits-cache-3ykqmnj5.js

@@ -0,0 +1,88 @@
+import {
+  NullableTokenCount2
+} from "./account-limits-cache-736tdyme.js";
+
+// src/api/anthropic-events.ts
+import { Type } from "typebox";
+var UsageSchema = Type.Object({
+  input_tokens: NullableTokenCount2,
+  output_tokens: NullableTokenCount2,
+  cache_read_input_tokens: NullableTokenCount2,
+  cache_creation_input_tokens: NullableTokenCount2,
+  cache_creation: Type.Optional(Type.Union([Type.Object({ ephemeral_1h_input_tokens: NullableTokenCount2 }), Type.Null()])),
+  output_tokens_details: Type.Optional(Type.Union([Type.Object({ thinking_tokens: NullableTokenCount2 }), Type.Null()])),
+  speed: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+});
+var ContentBlockSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("text"),
+    text: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+  }),
+  Type.Object({
+    type: Type.Literal("thinking"),
+    thinking: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    signature: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+  }),
+  Type.Object({ type: Type.Literal("redacted_thinking"), data: Type.String() }),
+  Type.Object({
+    type: Type.Literal("tool_use"),
+    id: Type.String(),
+    name: Type.String(),
+    input: Type.Optional(Type.Union([Type.Record(Type.String(), Type.Unknown()), Type.Null()]))
+  })
+]);
+var ContentDeltaSchema = Type.Union([
+  Type.Object({ type: Type.Literal("text_delta"), text: Type.String() }),
+  Type.Object({ type: Type.Literal("thinking_delta"), thinking: Type.String() }),
+  Type.Object({ type: Type.Literal("input_json_delta"), partial_json: Type.String() }),
+  Type.Object({ type: Type.Literal("signature_delta"), signature: Type.String() })
+]);
+var ContentIndex = Type.Integer({ minimum: 0 });
+var AnthropicEventSchema2 = Type.Union([
+  Type.Object({
+    type: Type.Literal("message_start"),
+    message: Type.Object({ id: Type.String(), model: Type.String(), usage: UsageSchema })
+  }),
+  Type.Object({
+    type: Type.Literal("message_delta"),
+    delta: Type.Object({
+      stop_reason: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+      stop_details: Type.Optional(Type.Union([
+        Type.Object({ explanation: Type.Optional(Type.Union([Type.String(), Type.Null()])) }),
+        Type.Null()
+      ]))
+    }),
+    usage: Type.Optional(Type.Union([UsageSchema, Type.Null()]))
+  }),
+  Type.Object({ type: Type.Literal("message_stop") }),
+  Type.Object({
+    type: Type.Literal("content_block_start"),
+    index: ContentIndex,
+    content_block: ContentBlockSchema
+  }),
+  Type.Object({
+    type: Type.Literal("content_block_delta"),
+    index: ContentIndex,
+    delta: ContentDeltaSchema
+  }),
+  Type.Object({ type: Type.Literal("content_block_stop"), index: ContentIndex })
+]);
+var AnthropicEventTypeSchema2 = Type.Index(AnthropicEventSchema2, ["type"]);
+var IgnoredAnthropicEventSchema2 = Type.Union([
+  Type.Object({
+    type: Type.Literal("content_block_start"),
+    index: ContentIndex,
+    content_block: Type.Object({
+      type: Type.String({ not: Type.Index(ContentBlockSchema, ["type"]) })
+    })
+  }),
+  Type.Object({
+    type: Type.Literal("content_block_delta"),
+    index: ContentIndex,
+    delta: Type.Object({
+      type: Type.String({ not: Type.Index(ContentDeltaSchema, ["type"]) })
+    })
+  })
+]);
+
+export { AnthropicEventSchema2, AnthropicEventTypeSchema2, IgnoredAnthropicEventSchema2 };

package/dist/chunks/account-limits-cache-4b8ckwqw.js

@@ -0,0 +1,293 @@
+import {
+  sanitizeSurrogates2
+} from "./account-limits-cache-eqwweapz.js";
+import {
+  renderSystemMessageUpdate2
+} from "./account-limits-cache-b4edaybk.js";
+import {
+  getJsonSchemaToolParameters2,
+  resolveJsonSchemaStrictSampling2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  toClaudeCodeName2
+} from "./account-limits-cache-ks1sjym9.js";
+
+// src/api/anthropic-convert.ts
+import { IsProperties, IsRequired } from "typebox/schema";
+var ANTHROPIC_IMAGE_MEDIA_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+function convertImageBlock(image) {
+  const mediaType = ANTHROPIC_IMAGE_MEDIA_TYPES.find((type) => type === image.mimeType);
+  if (mediaType === undefined) {
+    throw new Error(`Anthropic does not support ${image.mimeType} images`);
+  }
+  return { type: "image", source: { type: "base64", media_type: mediaType, data: image.data } };
+}
+function convertContentBlocks(content) {
+  const hasImages = content.some((c) => c.type === "image");
+  if (!hasImages) {
+    return sanitizeSurrogates2(content.map((c) => c.type === "text" ? c.text : "").join(`
+`));
+  }
+  const blocks = content.map((block) => block.type === "text" ? { type: "text", text: sanitizeSurrogates2(block.text) } : convertImageBlock(block));
+  const hasText = blocks.some((b) => b.type === "text");
+  if (!hasText) {
+    blocks.unshift({
+      type: "text",
+      text: "(see attached image)"
+    });
+  }
+  return blocks;
+}
+function normalizeToolCallId2(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
+  const references = [];
+  for (const name of msg.addedToolNames ?? []) {
+    const normalizedName = normalizeToolName(name);
+    if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
+      continue;
+    loadedToolNames.add(normalizedName);
+    references.push({
+      type: "tool_reference",
+      tool_name: isOAuthToken ? toClaudeCodeName2(name) : name
+    });
+  }
+  const convertedContent = convertContentBlocks(msg.content);
+  return {
+    toolResult: {
+      type: "tool_result",
+      tool_use_id: msg.toolCallId,
+      content: references.length > 0 ? references : convertedContent,
+      is_error: msg.isError
+    },
+    siblingContent: references.length === 0 ? [] : Array.isArray(convertedContent) ? convertedContent : [{ type: "text", text: convertedContent }]
+  };
+}
+function convertMessages3(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set, normalizeToolName = (name) => name, nativeToolChanges = false) {
+  const params = [];
+  const loadedToolNames = new Set;
+  const pendingSystemMessages = [];
+  const flushPendingSystemMessages = () => {
+    params.push(...pendingSystemMessages);
+    pendingSystemMessages.length = 0;
+  };
+  for (let i = 0;i < transformedMessages.length; i++) {
+    const msg = transformedMessages[i];
+    if (msg.role === "system") {
+      const text = renderSystemMessageUpdate2(msg);
+      const blocks = [];
+      if (text.length > 0)
+        blocks.push({ type: "text", text: sanitizeSurrogates2(text) });
+      if (nativeToolChanges) {
+        for (const tool of msg.toolsRemoved ?? []) {
+          blocks.push({
+            type: "tool_removal",
+            tool: {
+              type: "tool_reference",
+              name: isOAuthToken ? toClaudeCodeName2(tool.name) : tool.name
+            }
+          });
+        }
+        for (const tool of msg.toolsAdded ?? []) {
+          blocks.push({
+            type: "tool_addition",
+            tool: {
+              type: "tool_reference",
+              name: isOAuthToken ? toClaudeCodeName2(tool.name) : tool.name
+            }
+          });
+        }
+      }
+      if (blocks.length > 0)
+        pendingSystemMessages.push({ role: "system", content: blocks });
+    } else if (msg.role === "user") {
+      if (!Array.isArray(msg.content)) {
+        if (msg.content.trim().length > 0) {
+          params.push({
+            role: "user",
+            content: sanitizeSurrogates2(msg.content)
+          });
+        }
+      } else {
+        const blocks = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "text",
+              text: sanitizeSurrogates2(item.text)
+            };
+          } else {
+            return convertImageBlock(item);
+          }
+        });
+        const filteredBlocks = blocks.filter((b) => {
+          if (b.type === "text") {
+            return b.text.trim().length > 0;
+          }
+          return true;
+        });
+        if (filteredBlocks.length === 0)
+          continue;
+        params.push({
+          role: "user",
+          content: filteredBlocks
+        });
+      }
+    } else if (msg.role === "assistant") {
+      flushPendingSystemMessages();
+      const blocks = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          if (block.text.trim().length === 0)
+            continue;
+          blocks.push({
+            type: "text",
+            text: sanitizeSurrogates2(block.text)
+          });
+        } else if (block.type === "thinking") {
+          if (block.redacted) {
+            blocks.push({
+              type: "redacted_thinking",
+              data: block.thinkingSignature
+            });
+            continue;
+          }
+          const thinkingSignature = block.thinkingSignature;
+          const hasThinkingSignature = !!thinkingSignature && thinkingSignature.trim().length > 0;
+          if (block.thinking.trim().length === 0 && !hasThinkingSignature)
+            continue;
+          if (!hasThinkingSignature) {
+            blocks.push(allowEmptySignature ? {
+              type: "thinking",
+              thinking: sanitizeSurrogates2(block.thinking),
+              signature: ""
+            } : {
+              type: "text",
+              text: sanitizeSurrogates2(block.thinking)
+            });
+          } else {
+            blocks.push({
+              type: "thinking",
+              thinking: sanitizeSurrogates2(block.thinking),
+              signature: thinkingSignature
+            });
+          }
+        } else if (block.type === "toolCall") {
+          blocks.push({
+            type: "tool_use",
+            id: block.id,
+            name: isOAuthToken ? toClaudeCodeName2(block.name) : block.name,
+            input: block.arguments ?? {}
+          });
+        }
+      }
+      if (blocks.length === 0)
+        continue;
+      params.push({
+        role: "assistant",
+        content: blocks
+      });
+    } else if (msg.role === "toolResult") {
+      const toolResults = [];
+      const siblingContent = [];
+      let j = i;
+      for (;j < transformedMessages.length; j++) {
+        const next = transformedMessages[j];
+        if (next.role !== "toolResult")
+          break;
+        const converted = convertToolResult(next, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+        toolResults.push(converted.toolResult);
+        siblingContent.push(...converted.siblingContent);
+      }
+      i = j - 1;
+      params.push({
+        role: "user",
+        content: [...toolResults, ...siblingContent]
+      });
+    }
+  }
+  flushPendingSystemMessages();
+  if (cacheControl && params.length > 0) {
+    const lastMessage = params[params.length - 1];
+    if (lastMessage.role === "user" || lastMessage.role === "system") {
+      if (Array.isArray(lastMessage.content)) {
+        const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+        if (lastBlock && (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result" || lastBlock.type === "tool_addition" || lastBlock.type === "tool_removal")) {
+          lastBlock.cache_control = cacheControl;
+        }
+      } else {
+        lastMessage.content = [
+          {
+            type: "text",
+            text: lastMessage.content,
+            cache_control: cacheControl
+          }
+        ];
+      }
+    }
+  }
+  return params;
+}
+var ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS = new Set([
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "maxItems",
+  "uniqueItems",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties"
+]);
+var ANTHROPIC_STRICT_STRING_FORMATS = new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+var rejectedByAnthropicStrictTools = (key, value) => {
+  if (ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS.has(key))
+    return true;
+  if (key === "minItems")
+    return value !== 0 && value !== 1;
+  if (key === "format")
+    return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
+  return false;
+};
+function convertTools3(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
+  if (!tools)
+    return [];
+  return tools.map((tool, index) => {
+    const strict = resolveJsonSchemaStrictSampling2(tool, supportsStrictTools, rejectedByAnthropicStrictTools);
+    const parameters = getJsonSchemaToolParameters2(tool, strict);
+    const legacyInputSchema = {
+      type: "object",
+      properties: IsProperties(parameters) ? parameters.properties : {},
+      required: IsRequired(parameters) ? parameters.required : []
+    };
+    const converted = {
+      name: isOAuthToken ? toClaudeCodeName2(tool.name) : tool.name,
+      description: tool.description,
+      input_schema: strict === true ? { ...parameters, ...legacyInputSchema } : legacyInputSchema
+    };
+    if (supportsEagerToolInputStreaming)
+      converted.eager_input_streaming = true;
+    if (strict === true)
+      converted.strict = true;
+    if (deferLoading)
+      converted.defer_loading = true;
+    if (cacheControl && index === tools.length - 1)
+      converted.cache_control = cacheControl;
+    return converted;
+  });
+}
+
+export { normalizeToolCallId2, convertMessages3, convertTools3 };