@nyte-ai/ai 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,314 @@
+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";
+
+// src/api/openai-responses-convert.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { TextSignatureV1Schema } from "@nyte-ai/schema/model";
+var ReplayedItemSchema = Type.Object({ type: Type.String() });
+var CheckpointItemsSchema = Type.Array(ReplayedItemSchema);
+var ReplayedReasoningSchema = Type.Object({ type: Type.Literal("reasoning") });
+function encodeTextSignatureV12(id, phase) {
+  const payload = { v: 1, id };
+  if (phase)
+    payload.phase = phase;
+  return JSON.stringify(payload);
+}
+function parseTextSignature(signature) {
+  if (!signature)
+    return;
+  if (signature.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(signature);
+      if (Value.Check(TextSignatureV1Schema, parsed))
+        return parsed;
+    } catch {}
+  }
+  return { id: signature };
+}
+function convertToolResultOutput(model, content) {
+  const textResult = content.flatMap((c) => c.type === "text" ? [c.text] : []).join(`
+`);
+  const images = content.filter((c) => c.type === "image");
+  const hasText = textResult.length > 0;
+  if (images.length === 0 || !model.input.includes("image")) {
+    return sanitizeSurrogates2(hasText ? textResult : images.length > 0 ? "(see attached image)" : "(no tool output)");
+  }
+  const output = [];
+  if (hasText) {
+    output.push({ type: "input_text", text: sanitizeSurrogates2(textResult) });
+  }
+  for (const image of images) {
+    output.push({
+      type: "input_image",
+      detail: "auto",
+      image_url: `data:${image.mimeType};base64,${image.data}`
+    });
+  }
+  return output;
+}
+function convertResponsesMessages2(model, context, allowedToolCallProviders, options) {
+  const messages = [];
+  const normalizedContext = resolveTranscript2(context, options?.supportsMidConvoSystemMessages);
+  const checkpoint = normalizedContext.checkpoint;
+  if (checkpoint !== undefined) {
+    if (checkpoint.provider !== model.provider || checkpoint.api !== model.api || checkpoint.model !== model.id || !Value.Check(CheckpointItemsSchema, checkpoint.data)) {
+      throw new Error(`Checkpoint material does not match ${model.provider}/${model.id}`);
+    }
+    messages.push(...checkpoint.data);
+  }
+  const loadedToolNames = new Set;
+  const normalizeIdPart = (part) => {
+    const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+    return normalized.replace(/_+$/, "");
+  };
+  const buildForeignResponsesItemId = (itemId) => {
+    const normalized = `fc_${shortHash2(itemId)}`;
+    return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+  };
+  const normalizeToolCallId = (id, _targetModel, source) => {
+    if (!allowedToolCallProviders.has(model.provider))
+      return normalizeIdPart(id);
+    if (!id.includes("|"))
+      return normalizeIdPart(id);
+    const [callId, itemId] = id.split("|");
+    const normalizedCallId = normalizeIdPart(callId);
+    const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+    let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+    if (!normalizedItemId.startsWith("fc_")) {
+      normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+    }
+    return `${normalizedCallId}|${normalizedItemId}`;
+  };
+  const transformedMessages = transformMessages2(normalizedContext.messages, model, normalizeToolCallId);
+  const transcriptTools = resolveTranscriptTools2(normalizedContext.messages, options?.deferredToolsMode !== undefined);
+  const pushToolLoad = (tools, seed) => {
+    if (tools.length === 0 || options?.deferredToolsMode === undefined)
+      return;
+    if (options.deferredToolsMode === "additional-tools") {
+      messages.push({
+        type: "additional_tools",
+        role: "developer",
+        tools: convertResponsesTools2(tools, options.toolOptions)
+      });
+      return;
+    }
+    const names = tools.map((tool) => tool.name);
+    const callId = `pi_tool_load_${shortHash2(`${seed}:${names.join(",")}`)}`;
+    messages.push({
+      type: "tool_search_call",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      arguments: { query: names.join(" "), limit: names.length }
+    });
+    messages.push({
+      type: "tool_search_output",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      tools: convertResponsesTools2(tools, { ...options.toolOptions, deferLoading: true })
+    });
+  };
+  const appendSystemToolAdditions = (message, seed) => {
+    const tools = transcriptTools.anchorsAdditions ? message.toolsAdded ?? [] : [];
+    for (const tool of tools)
+      loadedToolNames.add(tool.name);
+    pushToolLoad(tools, seed);
+  };
+  const includeInitialSystemMessage = options?.includeSystemPrompt ?? true;
+  const instructionRole = model.reasoning && model.compat?.supportsDeveloperRole !== false ? "developer" : "system";
+  let msgIndex = 0;
+  let sourceIndex = 0;
+  for (const msg of transformedMessages) {
+    const isLeadingSystemMessage = sourceIndex++ === 0 && msg.role === "system";
+    if (msg.role === "system") {
+      if (!isLeadingSystemMessage)
+        appendSystemToolAdditions(msg, `system:${msgIndex}`);
+      if (!isLeadingSystemMessage || includeInitialSystemMessage) {
+        const text = isLeadingSystemMessage ? getSystemMessageText2(msg) : renderSystemMessageUpdate2(msg);
+        if (text.length > 0) {
+          messages.push({ role: instructionRole, content: sanitizeSurrogates2(text) });
+        }
+      }
+    } else if (msg.role === "user") {
+      if (!Array.isArray(msg.content)) {
+        messages.push({
+          role: "user",
+          content: [{ type: "input_text", text: sanitizeSurrogates2(msg.content) }]
+        });
+      } else {
+        const content = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "input_text",
+              text: sanitizeSurrogates2(item.text)
+            };
+          }
+          return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`
+          };
+        });
+        if (content.length === 0)
+          continue;
+        messages.push({
+          role: "user",
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const output = [];
+      const isSameProviderAndApi = msg.provider === model.provider && msg.api === model.api;
+      const isSameModel = isSameProviderAndApi && msg.model === model.id;
+      const isDifferentModel = isSameProviderAndApi && msg.model !== model.id;
+      let textBlockIndex = 0;
+      for (const block of msg.content) {
+        if (block.type === "thinking") {
+          const reasoningItem = block.thinkingSignature ? JSON.parse(block.thinkingSignature) : undefined;
+          if (Value.Check(ReplayedReasoningSchema, reasoningItem))
+            output.push(reasoningItem);
+        } else if (block.type === "text") {
+          const parsedSignature = parseTextSignature(block.textSignature);
+          const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
+          textBlockIndex++;
+          let msgId = parsedSignature?.id;
+          if (!msgId) {
+            msgId = fallbackMessageId;
+          } else if (msgId.length > 64) {
+            msgId = `msg_${shortHash2(msgId)}`;
+          }
+          output.push({
+            type: "message",
+            role: "assistant",
+            content: [
+              { type: "output_text", text: sanitizeSurrogates2(block.text), annotations: [] }
+            ],
+            status: "completed",
+            id: msgId,
+            phase: parsedSignature?.phase
+          });
+        } else if (block.type === "toolCall") {
+          const [callId, itemIdRaw] = block.id.split("|");
+          const customInputProperty = options?.grammarToolInputProperties?.get(block.name);
+          let itemId = itemIdRaw;
+          const itemIdPrefix = customInputProperty === undefined ? "fc_" : "ctc_";
+          if (isDifferentModel || !itemId?.startsWith(itemIdPrefix)) {
+            itemId = undefined;
+          }
+          const canReplayNamespace = isSameModel || options?.deferredTools?.has(block.name) === true;
+          const call = customInputProperty === undefined ? {
+            type: "function_call",
+            id: itemId,
+            call_id: callId,
+            name: block.name,
+            arguments: JSON.stringify(block.arguments)
+          } : {
+            type: "custom_tool_call",
+            id: itemId,
+            call_id: callId,
+            name: block.name,
+            input: sanitizeSurrogates2(getGrammarToolInput2(block.name, block.arguments, customInputProperty))
+          };
+          if (canReplayNamespace && block.namespace !== undefined) {
+            call.namespace = block.namespace;
+          }
+          output.push(call);
+        }
+      }
+      if (output.length === 0)
+        continue;
+      messages.push(...output);
+    } else if (msg.role === "toolResult") {
+      const [callId] = msg.toolCallId.split("|");
+      const output = convertToolResultOutput(model, msg.content);
+      if (options?.grammarToolInputProperties?.has(msg.toolName)) {
+        messages.push({
+          type: "custom_tool_call_output",
+          call_id: callId,
+          output
+        });
+      } else {
+        messages.push({
+          type: "function_call_output",
+          call_id: callId,
+          output
+        });
+      }
+      const deferredTools = [];
+      for (const name of msg.addedToolNames ?? []) {
+        const tool = options?.deferredTools?.get(name);
+        if (!tool || loadedToolNames.has(name))
+          continue;
+        loadedToolNames.add(name);
+        deferredTools.push(tool);
+      }
+      pushToolLoad(deferredTools, msg.toolCallId);
+    }
+    if (!isLeadingSystemMessage)
+      msgIndex++;
+  }
+  return messages;
+}
+function convertResponsesTools2(tools, options) {
+  const defaultStrict = options?.strict === undefined ? false : options.strict;
+  const supportsStrictMode = options?.supportsStrictMode ?? true;
+  const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
+  return tools.map((tool) => {
+    const grammar = resolveGrammarConstrainedSampling2(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      const customTool = {
+        type: "custom",
+        name: tool.name,
+        description: tool.description,
+        format: {
+          type: "grammar",
+          syntax: grammar.format,
+          definition: grammar.definition
+        }
+      };
+      if (options?.deferLoading)
+        customTool.defer_loading = true;
+      return customTool;
+    }
+    const constrainedStrict = resolveJsonSchemaStrictSampling2(tool, supportsStrictMode);
+    const strict = constrainedStrict ?? defaultStrict;
+    const functionTool = {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: getJsonSchemaToolParameters2(tool, strict === true)
+    };
+    if (options?.deferLoading)
+      functionTool.defer_loading = true;
+    if (supportsStrictMode) {
+      functionTool.strict = strict;
+    }
+    return functionTool;
+  });
+}
+
+export { encodeTextSignatureV12, convertResponsesMessages2, convertResponsesTools2 };

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

@@ -0,0 +1,72 @@
+import {
+  sleep2
+} from "./account-limits-cache-j2bt392s.js";
+
+// src/utils/provider-retry.ts
+var DEFAULT_MAX_RETRY_DELAY_MS = 60000;
+
+class RetryDelayExceededError2 extends Error {
+}
+function carriesHttpStatus(error) {
+  if (!(error instanceof Error) || !("status" in error) || !("headers" in error))
+    return false;
+  return (error.status === undefined || typeof error.status === "number") && (error.headers === undefined || error.headers instanceof Headers);
+}
+function sdkPolicyRetries(error) {
+  const shouldRetry = error.headers?.get("x-should-retry");
+  if (shouldRetry === "true")
+    return true;
+  if (shouldRetry === "false")
+    return false;
+  if (error.status === undefined)
+    return true;
+  return error.status === 408 || error.status === 409 || error.status === 429 || error.status >= 500;
+}
+function validateServerRetryDelayMs(delayMs, maxRetryDelayMs, providerErrorMessage) {
+  const maxDelayMs = maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  if (maxDelayMs > 0 && delayMs > maxDelayMs) {
+    throw new RetryDelayExceededError2(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxDelayMs / 1000)}s). ${providerErrorMessage}`);
+  }
+  return delayMs;
+}
+function getRetryDelayMs(error, retryIndex, maxRetryDelayMs) {
+  const retryAfterMs = error.headers?.get("retry-after-ms");
+  if (retryAfterMs) {
+    const value = Number.parseFloat(retryAfterMs);
+    if (Number.isFinite(value))
+      return validateServerRetryDelayMs(value, maxRetryDelayMs, error.message);
+  }
+  const retryAfter = error.headers?.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number.parseFloat(retryAfter);
+    const delayMs = Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1000;
+    if (Number.isFinite(delayMs))
+      return validateServerRetryDelayMs(delayMs, maxRetryDelayMs, error.message);
+  }
+  const exponentialDelay = Math.min(0.5 * 2 ** retryIndex, 8) * 1000;
+  return exponentialDelay * (1 - Math.random() * 0.25);
+}
+function createAbortError() {
+  const error = new Error("Request aborted");
+  error.name = "AbortError";
+  return error;
+}
+async function retryProviderRequest2(request, options = {}) {
+  const maxRetries = options.maxRetries ?? 0;
+  let retriesRemaining = maxRetries;
+  for (;; ) {
+    try {
+      return await request();
+    } catch (error) {
+      if (options.signal?.aborted)
+        throw createAbortError();
+      if (retriesRemaining <= 0 || !carriesHttpStatus(error) || !sdkPolicyRetries(error) || options.retryable?.(error) === false)
+        throw error;
+      const retryIndex = maxRetries - retriesRemaining;
+      retriesRemaining--;
+      await sleep2(getRetryDelayMs(error, retryIndex, options.maxRetryDelayMs), options.signal, createAbortError);
+    }
+  }
+}
+
+export { RetryDelayExceededError2, retryProviderRequest2 };

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

@@ -0,0 +1,42 @@
+import {
+  anthropicMessagesApi2
+} from "./account-limits-cache-zqdb4yh4.js";
+import {
+  googleGenerativeAIApi2
+} from "./account-limits-cache-x9fvb3s5.js";
+import {
+  openAICompletionsApi2
+} from "./account-limits-cache-eyx1jcxc.js";
+import {
+  openAIResponsesApi2
+} from "./account-limits-cache-q1ebtvet.js";
+import {
+  envApiKeyAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+import {
+  withOpenCodeSessionHeader2
+} from "./account-limits-cache-fht68jp2.js";
+
+// src/providers/opencode.ts
+var OPENCODE_PROMPT_CACHE2 = {
+  minimumRetentionMs: { short: 5 * 60000, long: 5 * 60000 }
+};
+function opencodeProvider2() {
+  return createProvider2({
+    id: "opencode",
+    name: "OpenCode Zen",
+    promptCache: OPENCODE_PROMPT_CACHE2,
+    auth: { apiKey: envApiKeyAuth2("OpenCode API key", ["OPENCODE_API_KEY"]) },
+    api: {
+      "anthropic-messages": withOpenCodeSessionHeader2(anthropicMessagesApi2()),
+      "google-generative-ai": withOpenCodeSessionHeader2(googleGenerativeAIApi2()),
+      "openai-completions": withOpenCodeSessionHeader2(openAICompletionsApi2()),
+      "openai-responses": withOpenCodeSessionHeader2(openAIResponsesApi2())
+    }
+  });
+}
+
+export { OPENCODE_PROMPT_CACHE2, opencodeProvider2 };

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

@@ -0,0 +1,26 @@
+// src/utils/fifo-queue.ts
+class FifoQueue2 {
+  incoming = [];
+  outgoing = [];
+  get length() {
+    return this.incoming.length + this.outgoing.length;
+  }
+  enqueue(value) {
+    this.incoming.push(value);
+  }
+  dequeue() {
+    if (this.outgoing.length === 0) {
+      const drained = this.incoming;
+      drained.reverse();
+      this.incoming = this.outgoing;
+      this.outgoing = drained;
+    }
+    return this.outgoing.pop();
+  }
+  clear() {
+    this.incoming = [];
+    this.outgoing = [];
+  }
+}
+
+export { FifoQueue2 };

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

@@ -0,0 +1,13 @@
+import {
+  classifyAssistantFailure2
+} from "./account-limits-cache-xds88kxd.js";
+
+// src/utils/overflow.ts
+function overflowsContext2(message, contextWindow) {
+  return classifyAssistantFailure2(message, contextWindow === undefined ? undefined : { contextWindow }).class === "context_window";
+}
+function stoppedShort2(message, desiredMaxOutput) {
+  return message.stopReason === "length" && desiredMaxOutput > 0 && message.usage.output < desiredMaxOutput;
+}
+
+export { overflowsContext2, stoppedShort2 };

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

@@ -0,0 +1,38 @@
+import {
+  anthropicMessagesApi2
+} from "./account-limits-cache-zqdb4yh4.js";
+import {
+  openAICompletionsApi2
+} from "./account-limits-cache-eyx1jcxc.js";
+import {
+  openAIResponsesApi2
+} from "./account-limits-cache-q1ebtvet.js";
+import {
+  envApiKeyAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+import {
+  withOpenCodeSessionHeader2
+} from "./account-limits-cache-fht68jp2.js";
+import {
+  OPENCODE_PROMPT_CACHE2
+} from "./account-limits-cache-nbkyhs6v.js";
+
+// src/providers/opencode-go.ts
+function opencodeGoProvider2() {
+  return createProvider2({
+    id: "opencode-go",
+    name: "OpenCode Go",
+    promptCache: OPENCODE_PROMPT_CACHE2,
+    auth: { apiKey: envApiKeyAuth2("OpenCode API key", ["OPENCODE_API_KEY"]) },
+    api: {
+      "anthropic-messages": withOpenCodeSessionHeader2(anthropicMessagesApi2()),
+      "openai-completions": withOpenCodeSessionHeader2(openAICompletionsApi2()),
+      "openai-responses": withOpenCodeSessionHeader2(openAIResponsesApi2())
+    }
+  });
+}
+
+export { opencodeGoProvider2 };

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

@@ -0,0 +1,45 @@
+import {
+  openAICompletionsApi2
+} from "./account-limits-cache-eyx1jcxc.js";
+import {
+  envApiKeyAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  verifyWithRequest2
+} from "./account-limits-cache-ydq8p8qp.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+
+// src/providers/openrouter.ts
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+function openrouterProvider2() {
+  return createProvider2({
+    id: "openrouter",
+    name: "OpenRouter",
+    baseUrl: OPENROUTER_BASE_URL,
+    auth: {
+      apiKey: envApiKeyAuth2("OpenRouter API key", ["OPENROUTER_API_KEY"]),
+      verify: ({ auth, signal }) => verifyWithRequest2({
+        provider: "OpenRouter",
+        url: `${auth.baseUrl ?? OPENROUTER_BASE_URL}/key`,
+        headers: { ...auth.headers, Authorization: `Bearer ${auth.apiKey ?? ""}` },
+        signal,
+        detail: (body) => {
+          if (typeof body !== "object" || body === null || !("data" in body))
+            return;
+          const key = body.data;
+          if (typeof key !== "object" || key === null)
+            return;
+          if (!("limit" in key) || typeof key.limit !== "number")
+            return "no credit limit";
+          const remaining = "limit_remaining" in key && typeof key.limit_remaining === "number" ? `, ${String(key.limit_remaining)} remaining` : "";
+          return `credit limit ${String(key.limit)}${remaining}`;
+        }
+      })
+    },
+    api: { "openai-completions": openAICompletionsApi2() }
+  });
+}
+
+export { openrouterProvider2 };

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

@@ -0,0 +1,59 @@
+import {
+  applyServiceTierPricing2
+} from "./account-limits-cache-f9z00x8c.js";
+import {
+  calculateCost2
+} from "./account-limits-cache-zgzptd0z.js";
+import {
+  emptyCost2
+} from "./account-limits-cache-fsktnetm.js";
+
+// src/api/openai-compact.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var tokenCount = Type.Number({ minimum: 0 });
+var compactResponse = Type.Object({
+  output: Type.Array(Type.Object({ type: Type.String({ minLength: 1 }) }), { minItems: 1 }),
+  service_tier: Type.Optional(Type.Union([
+    Type.Literal("auto"),
+    Type.Literal("default"),
+    Type.Literal("flex"),
+    Type.Literal("priority"),
+    Type.Null()
+  ])),
+  usage: Type.Optional(Type.Object({
+    input_tokens: tokenCount,
+    output_tokens: tokenCount,
+    total_tokens: tokenCount,
+    input_tokens_details: Type.Optional(Type.Object({
+      cached_tokens: Type.Optional(tokenCount),
+      cache_write_tokens: Type.Optional(tokenCount)
+    })),
+    output_tokens_details: Type.Optional(Type.Object({ reasoning_tokens: Type.Optional(tokenCount) }))
+  }))
+});
+async function readOpenAICompactResponse2(response, model, requestedServiceTier) {
+  const decoded = await response.json();
+  if (!Value.Check(compactResponse, decoded)) {
+    throw new Error("OpenAI compact response did not contain valid output items and usage");
+  }
+  const data = decoded.output;
+  if (decoded.usage === undefined)
+    return { data };
+  const cached = decoded.usage.input_tokens_details?.cached_tokens ?? 0;
+  const written = decoded.usage.input_tokens_details?.cache_write_tokens ?? 0;
+  const usage = {
+    input: Math.max(0, decoded.usage.input_tokens - cached - written),
+    output: decoded.usage.output_tokens,
+    cacheRead: cached,
+    cacheWrite: written,
+    reasoning: decoded.usage.output_tokens_details?.reasoning_tokens ?? 0,
+    totalTokens: decoded.usage.total_tokens,
+    cost: emptyCost2()
+  };
+  calculateCost2(model, usage);
+  applyServiceTierPricing2(usage, decoded.service_tier ?? requestedServiceTier, model);
+  return { data, usage };
+}
+
+export { readOpenAICompactResponse2 };

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

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

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

@@ -0,0 +1,51 @@
+import {
+  anthropicMessagesApi2
+} from "./account-limits-cache-zqdb4yh4.js";
+import {
+  envApiKeyAuth2
+} from "./account-limits-cache-6x05n06z.js";
+import {
+  verifyWithRequest2
+} from "./account-limits-cache-ydq8p8qp.js";
+import {
+  createProvider2
+} from "./account-limits-cache-ykbqsvv6.js";
+
+// src/providers/vercel-ai-gateway.ts
+var VERCEL_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
+function vercelAiGatewayProvider2() {
+  const apiKey = envApiKeyAuth2("Vercel AI Gateway API key", [
+    "AI_GATEWAY_API_KEY",
+    "VERCEL_OIDC_TOKEN"
+  ]);
+  return createProvider2({
+    id: "vercel-ai-gateway",
+    name: "Vercel AI Gateway",
+    baseUrl: VERCEL_AI_GATEWAY_BASE_URL,
+    auth: {
+      apiKey: {
+        ...apiKey,
+        resolve: async (input) => {
+          const result = await apiKey.resolve(input);
+          if (!result?.auth.apiKey)
+            return result;
+          const { apiKey: key, ...auth } = result.auth;
+          return {
+            ...result,
+            auth: { ...auth, headers: { ...auth.headers, Authorization: `Bearer ${key}` } }
+          };
+        }
+      },
+      verify: ({ auth, signal }) => verifyWithRequest2({
+        provider: "Vercel AI Gateway",
+        url: `${auth.baseUrl ?? VERCEL_AI_GATEWAY_BASE_URL}/v1/credits`,
+        headers: auth.headers ?? {},
+        signal,
+        detail: (body) => typeof body === "object" && body !== null && ("balance" in body) && typeof body.balance === "string" ? `balance ${body.balance}` : undefined
+      })
+    },
+    api: { "anthropic-messages": anthropicMessagesApi2() }
+  });
+}
+
+export { vercelAiGatewayProvider2 };