@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/api/openai-responses.js

@@ -0,0 +1,276 @@
+import {
+  applyServiceTierPricing2
+} from "../../chunks/account-limits-cache-f9z00x8c.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import {
+  resolveCacheRetention2
+} from "../../chunks/account-limits-cache-d2a51dka.js";
+import {
+  splitDeferredTools2
+} from "../../chunks/account-limits-cache-8s8bz4dr.js";
+import {
+  getSystemMessageText2
+} from "../../chunks/account-limits-cache-b4edaybk.js";
+import {
+  getDeclaredTools2,
+  getInitialSystemMessage2,
+  normalizeContext2,
+  resolveTranscript2,
+  resolveTranscriptTools2
+} from "../../chunks/account-limits-cache-6250ykn6.js";
+import {
+  normalizeProviderError2,
+  formatProviderError2
+} from "../../chunks/account-limits-cache-zcbkmrvy.js";
+import {
+  headersToRecord2,
+  mergeProviderHeaders2,
+  getClientApiKey2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import {
+  getNyteUserAgent2
+} from "../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import {
+  runAssistantStream2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import {
+  createGrammarToolInputProperties2
+} from "../../chunks/account-limits-cache-h92bzz1j.js";
+import {
+  buildCopilotDynamicHeaders2
+} from "../../chunks/account-limits-cache-za42x8a3.js";
+import {
+  clampOpenAIPromptCacheKey2
+} from "../../chunks/account-limits-cache-csbxvam7.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import {
+  convertResponsesMessages2,
+  convertResponsesTools2
+} from "../../chunks/account-limits-cache-n3yk6g5c.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+import"../../chunks/account-limits-cache-fbkaq46e.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+import"../../chunks/account-limits-cache-a558rjbg.js";
+import {
+  withPriorityTier2,
+  processResponsesStream2
+} from "../../chunks/account-limits-cache-53e64mhx.js";
+import {
+  readOpenAICompactResponse2
+} from "../../chunks/account-limits-cache-pfr14mcn.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import {
+  buildBaseOptions2,
+  simpleReasoningEffort2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+
+// src/api/openai-responses.ts
+import OpenAI from "openai";
+var OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+var OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
+function getCompat(model) {
+  return {
+    supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? "openai",
+    supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+    supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+    supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+    supportsAdditionalTools: model.compat?.supportsAdditionalTools ?? false,
+    supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+    supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false
+  };
+}
+function getPromptCacheRetention(compat, cacheRetention) {
+  return cacheRetention === "long" && compat.supportsLongCacheRetention && !compat.supportsExplicitPromptCacheMode ? "24h" : undefined;
+}
+function getPromptCacheOptions(compat, cacheRetention) {
+  if (!compat.supportsExplicitPromptCacheMode)
+    return;
+  if (cacheRetention === "none")
+    return { mode: "explicit" };
+  if (cacheRetention === "long" && compat.supportsLongCacheRetention)
+    return { ttl: "30m" };
+  return;
+}
+async function compactOpenAIResponsesContext(model, context, requested) {
+  const options = withPriorityTier2(requested);
+  const apiKey = getClientApiKey2(model.provider, options?.apiKey, options?.headers);
+  const compat = getCompat(model);
+  const cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env);
+  const transcript = resolveTranscript2(normalizeContext2(context), compat.supportsMidConvoSystemMessages);
+  const client = createClient({
+    model,
+    context: transcript,
+    apiKey,
+    options: { headers: options?.headers, fetch: options?.fetch },
+    compat,
+    cacheRetention
+  });
+  const initialSystemMessage = getInitialSystemMessage2(transcript.messages);
+  const instructions = initialSystemMessage ? getSystemMessageText2(initialSystemMessage) : undefined;
+  const input = buildParams(model, transcript, options, compat, cacheRetention, undefined, false).input;
+  const requestOptions = { maxRetries: 0 };
+  const serviceTier = options?.serviceTier === "priority" ? "priority" : undefined;
+  if (options?.signal !== undefined)
+    requestOptions.signal = options.signal;
+  if (options?.timeoutMs !== undefined)
+    requestOptions.timeout = options.timeoutMs;
+  const response = await retryProviderRequest2(() => client.post("/responses/compact", {
+    body: { model: model.id, input, instructions, service_tier: serviceTier },
+    ...requestOptions,
+    __security: { bearerAuth: true }
+  }).asResponse(), {
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    signal: options?.signal
+  });
+  await options?.onResponse?.({ status: response.status, headers: headersToRecord2(response.headers) }, model);
+  return readOpenAICompactResponse2(response, model, serviceTier);
+}
+var stream = (model, context, requested) => {
+  const options = withPriorityTier2(requested);
+  const normalizedContext = resolveTranscript2(context, getCompat(model).supportsMidConvoSystemMessages);
+  return runAssistantStream2(model, options?.signal, "OpenAI Responses", async (output, stream) => {
+    const apiKey = getClientApiKey2(model.provider, options?.apiKey, options?.headers);
+    const cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env);
+    const compat = getCompat(model);
+    const grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
+    const client = createClient({
+      model,
+      context: normalizedContext,
+      apiKey,
+      options,
+      cacheRetention,
+      compat
+    });
+    const params = buildParams(model, normalizedContext, options, compat, cacheRetention, grammarToolInputProperties);
+    await options?.onPayload?.(params, model);
+    const requestOptions = { maxRetries: 0 };
+    if (options?.signal)
+      requestOptions.signal = options.signal;
+    if (options?.timeoutMs !== undefined)
+      requestOptions.timeout = options.timeoutMs;
+    const result = await retryProviderRequest2(() => client.post("/responses", {
+      body: params,
+      ...requestOptions,
+      stream: true,
+      __security: { bearerAuth: true }
+    }).withResponse(), {
+      maxRetries: options?.maxRetries,
+      maxRetryDelayMs: options?.maxRetryDelayMs,
+      signal: options?.signal
+    });
+    await options?.onResponse?.({ status: result.response.status, headers: headersToRecord2(result.response.headers) }, model);
+    stream.push({ type: "start", partial: output });
+    await processResponsesStream2(result.data, output, stream, model, {
+      serviceTier: options?.serviceTier,
+      grammarToolInputProperties,
+      applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing2(usage, serviceTier, model)
+    });
+  }, (error) => formatProviderError2(normalizeProviderError2(error), `${model.provider === "openai" ? "OpenAI" : model.provider} API error`));
+};
+var streamSimple = (model, context, options) => {
+  getClientApiKey2(model.provider, options?.apiKey, options?.headers);
+  return stream(model, context, {
+    ...buildBaseOptions2(model, context, options),
+    reasoningEffort: simpleReasoningEffort2(model, options?.reasoning)
+  });
+};
+function createClient(input) {
+  const copilotHeaders = input.model.provider === "github-copilot" ? buildCopilotDynamicHeaders2({
+    messages: input.context.messages,
+    sessionId: input.options?.sessionId
+  }) : undefined;
+  const cacheSessionId = input.cacheRetention === "none" ? undefined : input.options?.sessionId;
+  const affinityHeaders = {};
+  if (cacheSessionId) {
+    if (input.compat.sessionAffinityFormat === "openrouter") {
+      affinityHeaders["x-session-id"] = cacheSessionId;
+    } else {
+      if (input.compat.sessionAffinityFormat === "openai") {
+        affinityHeaders.session_id = cacheSessionId;
+      }
+      affinityHeaders["x-client-request-id"] = cacheSessionId;
+    }
+  }
+  return new OpenAI({
+    apiKey: input.apiKey,
+    baseURL: input.model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch: input.options?.fetch,
+    defaultHeaders: mergeProviderHeaders2({ "User-Agent": getNyteUserAgent2() }, input.model.headers, copilotHeaders, affinityHeaders, input.options?.headers)
+  });
+}
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(context.messages), compat.supportsOpenAIGrammarTools), includeSystemPrompt = true) {
+  const deferredToolsMode = compat.supportsAdditionalTools ? "additional-tools" : 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, OPENAI_TOOL_CALL_PROVIDERS, {
+    includeSystemPrompt,
+    grammarToolInputProperties,
+    supportsMidConvoSystemMessages: compat.supportsMidConvoSystemMessages,
+    deferredTools: toolPlacement.deferred,
+    deferredToolsMode,
+    toolOptions: {
+      supportsStrictMode: compat.supportsStrictMode,
+      supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+    }
+  });
+  const params = {
+    model: model.id,
+    input: messages,
+    stream: true,
+    prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey2(options?.sessionId),
+    prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+    prompt_cache_options: getPromptCacheOptions(compat, cacheRetention),
+    store: false
+  };
+  if (options?.maxTokens) {
+    params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
+  }
+  if (options?.temperature !== undefined) {
+    params.temperature = options?.temperature;
+  }
+  if (options?.serviceTier !== undefined) {
+    params.service_tier = options.serviceTier;
+  }
+  if (toolPlacement.immediate.length > 0) {
+    params.tools = convertResponsesTools2(toolPlacement.immediate, {
+      supportsStrictMode: compat.supportsStrictMode,
+      supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+    });
+  }
+  if (options?.toolChoice !== undefined) {
+    params.tool_choice = options.toolChoice;
+  }
+  if (model.reasoning) {
+    if (options?.reasoningEffort || options?.reasoningSummary) {
+      const effort = options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium";
+      params.reasoning = { effort, summary: options?.reasoningSummary || "auto" };
+      params.include = ["reasoning.encrypted_content"];
+    } else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {
+      params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+    }
+    if (model.provider === "xai" || model.provider === "github-copilot") {
+      params.include = ["reasoning.encrypted_content"];
+    }
+  }
+  if (options?.samplingParams) {
+    Object.assign(params, options.samplingParams);
+  }
+  return params;
+}
+export {
+  compactOpenAIResponsesContext,
+  stream,
+  streamSimple
+};

package/dist/src/api/openai-responses.lazy.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderStreams } from "../types.ts";
+export declare const openAIResponsesApi: () => ProviderStreams;

package/dist/src/api/openai-responses.lazy.js

@@ -0,0 +1,11 @@
+import {
+  openAIResponsesApi2
+} from "../../chunks/account-limits-cache-q1ebtvet.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  openAIResponsesApi2 as openAIResponsesApi
+};

package/dist/src/api/simple-options.d.ts

@@ -0,0 +1,17 @@
+import type { Api, Model, ModelThinkingLevel, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel, TranscriptContext } from "../types.ts";
+export declare function clampMaxTokensToContext(model: Model<Api>, context: TranscriptContext, maxTokens: number): number;
+/** The request options every API's `streamSimple` forwards unchanged to its `stream`. */
+export declare function buildBaseOptions(model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions): StreamOptions & Pick<SimpleStreamOptions, "toolChoice">;
+/** The simple reasoning level clamped to what `model` supports, or undefined for no reasoning. */
+export declare function simpleReasoningEffort(model: Model<Api>, reasoning: ThinkingLevel | undefined): Exclude<ModelThinkingLevel, "off"> | undefined;
+export declare function thinkingBudgetForLevel(reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): number;
+/** Cap a thinking budget so at least MIN_ANSWER_TOKENS remain under a shared response ceiling. */
+export declare function clampThinkingBudgetToAnswerRoom(thinkingBudget: number, ceiling: number): number;
+/**
+ * The output cap and thinking budget for a budget-based thinking request. An undefined
+ * `baseMaxTokens` means the caller set no cap: the model cap is used and thinking fits inside it.
+ */
+export declare function adjustMaxTokensForThinking(baseMaxTokens: number | undefined, modelMaxTokens: number, reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): {
+    maxTokens: number;
+    thinkingBudget: number;
+};

package/dist/src/api/simple-options.js

@@ -0,0 +1,18 @@
+import {
+  clampMaxTokensToContext2,
+  buildBaseOptions2,
+  simpleReasoningEffort2,
+  thinkingBudgetForLevel2,
+  clampThinkingBudgetToAnswerRoom2,
+  adjustMaxTokensForThinking2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+export {
+  adjustMaxTokensForThinking2 as adjustMaxTokensForThinking,
+  buildBaseOptions2 as buildBaseOptions,
+  clampMaxTokensToContext2 as clampMaxTokensToContext,
+  clampThinkingBudgetToAnswerRoom2 as clampThinkingBudgetToAnswerRoom,
+  simpleReasoningEffort2 as simpleReasoningEffort,
+  thinkingBudgetForLevel2 as thinkingBudgetForLevel
+};

package/dist/src/api/token-count.d.ts

@@ -0,0 +1,5 @@
+import { Type } from "typebox";
+/** A provider token count. */
+export declare const TokenCount: Type.TInteger;
+/** A token count a provider may also send as `null` or leave out. */
+export declare const NullableTokenCount: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;

package/dist/src/api/token-count.js

@@ -0,0 +1,8 @@
+import {
+  TokenCount2,
+  NullableTokenCount2
+} from "../../chunks/account-limits-cache-736tdyme.js";
+export {
+  NullableTokenCount2 as NullableTokenCount,
+  TokenCount2 as TokenCount
+};

package/dist/src/api/transform-messages.d.ts

@@ -0,0 +1,9 @@
+import type { Api, AssistantMessage, Message, Model } from "../types.ts";
+/**
+ * Normalize tool call ID for cross-provider compatibility.
+ * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+ * Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+ * Null or undefined content from untyped callers (custom tools, hand-built histories, old session
+ * files) becomes an empty array first, so downstream code can rely on the type contract.
+ */
+export declare function transformMessages<TApi extends Api>(messages: Message[], model: Model<TApi>, normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string): Message[];

package/dist/src/api/transform-messages.js

@@ -0,0 +1,6 @@
+import {
+  transformMessages2
+} from "../../chunks/account-limits-cache-8qzk56vj.js";
+export {
+  transformMessages2 as transformMessages
+};

package/dist/src/api-options.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The per-API stream option map. It imports each API module's option type, so it
+ * lives apart from `types.ts`, which those modules import for the base contract.
+ */
+import type { AnthropicOptions } from "./api/anthropic-messages.ts";
+import type { GoogleOptions } from "./api/google-generative-ai.ts";
+import type { OpenAICodexResponsesOptions } from "./api/openai-codex-protocol.ts";
+import type { OpenAICompletionsOptions } from "./api/openai-completions-params.ts";
+import type { OpenAIResponsesOptions } from "./api/openai-responses.ts";
+import type { Api, StreamOptions } from "./types.ts";
+/**
+ * Maps known APIs to their full provider-specific stream option types.
+ * Type-only imports from API implementation modules are erased at emit, so
+ * this is tree-shake safe.
+ */
+export interface ApiOptionsMap {
+    "anthropic-messages": AnthropicOptions;
+    "google-generative-ai": GoogleOptions;
+    "openai-completions": OpenAICompletionsOptions;
+    "openai-responses": OpenAIResponsesOptions;
+    "openai-codex-responses": OpenAICodexResponsesOptions;
+}
+/**
+ * Full stream options for an API. Known APIs resolve to their concrete option
+ * type; custom API strings fall back to the generic shape.
+ */
+export type ApiStreamOptions<TApi extends Api> = StreamOptions & (TApi extends keyof ApiOptionsMap ? ApiOptionsMap[TApi] : Record<string, unknown>);

package/dist/src/auth/context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Default `AuthContext`: env vars from `process.env` and file existence via
+ * node:fs, both loaded through `process.getBuiltinModule` so browser bundlers do
+ * not try to resolve node builtins (where they simply report nothing).
+ */
+import type { AuthContext } from "./types.ts";
+/**
+ * Default auth context: env vars from `process.env` (undefined in browsers),
+ * file existence via node:fs (always false in browsers).
+ */
+export declare function defaultProviderAuthContext(): AuthContext;

package/dist/src/auth/context.js

@@ -0,0 +1,6 @@
+import {
+  defaultProviderAuthContext2
+} from "../../chunks/account-limits-cache-1jv43fhh.js";
+export {
+  defaultProviderAuthContext2 as defaultProviderAuthContext
+};

package/dist/src/auth/credential-store.d.ts

@@ -0,0 +1,17 @@
+import type { AuthOperationOptions, CredentialAccounts, CredentialInfo, CredentialStore } from "./types.ts";
+/**
+ * Default in-memory credential store. Apps inject persistent stores.
+ * Keyed by `Provider.id`, with accounts and selection stored together.
+ * Writes run one at a time per provider.
+ */
+export declare class InMemoryCredentialStore implements CredentialStore {
+    private credentials;
+    private readonly writes;
+    /** Runs `task` after the provider's earlier writes; a cancelled caller stops waiting, and a task cancelled before it starts never runs. */
+    private enqueue;
+    read(providerId: string, options?: AuthOperationOptions): Promise<CredentialAccounts | undefined>;
+    list(options?: AuthOperationOptions): Promise<readonly CredentialInfo[]>;
+    /** Stores what `fn` returns even after abort: a rotated token has no second copy. */
+    modify(providerId: string, fn: (current: CredentialAccounts | undefined) => Promise<CredentialAccounts | undefined>, options?: AuthOperationOptions): Promise<CredentialAccounts | undefined>;
+    delete(providerId: string, options?: AuthOperationOptions): Promise<void>;
+}

package/dist/src/auth/credential-store.js

@@ -0,0 +1,7 @@
+import {
+  InMemoryCredentialStore2
+} from "../../chunks/account-limits-cache-emg5b4hj.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  InMemoryCredentialStore2 as InMemoryCredentialStore
+};

package/dist/src/auth/helpers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Building blocks for provider auth definitions: the standard env-var api-key
+ * auth with a paste-your-key login, and a lazy OAuth wrapper that defers
+ * loading Node-only flow code until first use.
+ */
+import type { ApiKeyAuth, OAuthAuth } from "./types.ts";
+/**
+ * Standard api-key auth: a stored credential key wins, otherwise the first
+ * set env var resolves. Includes a `login` that prompts for the key.
+ * Providers with non-standard resolution (provider env, ambient files, IAM)
+ * write their own `ApiKeyAuth`.
+ */
+export declare function envApiKeyAuth(name: string, envVars: readonly string[]): ApiKeyAuth;
+/**
+ * Loads an OAuth flow on first login, refresh, or auth conversion.
+ * Only a successful load is kept: a cached rejection would poison every later
+ * login, refresh, and toAuth call for the life of the process.
+ */
+export declare function lazyOAuth(input: {
+    name: string;
+    isSubscription?: boolean;
+    loginLabel?: string;
+    load: () => Promise<OAuthAuth>;
+}): OAuthAuth;

package/dist/src/auth/helpers.js

@@ -0,0 +1,8 @@
+import {
+  envApiKeyAuth2,
+  lazyOAuth2
+} from "../../chunks/account-limits-cache-6x05n06z.js";
+export {
+  envApiKeyAuth2 as envApiKeyAuth,
+  lazyOAuth2 as lazyOAuth
+};

package/dist/src/auth/oauth/anthropic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Anthropic OAuth flow (Claude Pro/Max): PKCE against claude.ai with browser
+ * callback or copy-code login, and token refresh against platform.claude.com.
+ * Node-only (node:http); the callback server is for CLI use, not browsers.
+ */
+import { type OAuthAuth } from "../types.ts";
+export declare const anthropicOAuth: OAuthAuth;

package/dist/src/auth/oauth/anthropic.js

@@ -0,0 +1,12 @@
+import {
+  anthropicOAuth2
+} from "../../../chunks/account-limits-cache-4fn5w63p.js";
+import"../../../chunks/account-limits-cache-d1ypzqzp.js";
+import"../../../chunks/account-limits-cache-8vzx8k6r.js";
+import"../../../chunks/account-limits-cache-tc38g0ca.js";
+import"../../../chunks/account-limits-cache-b0x2sfya.js";
+import"../../../chunks/account-limits-cache-v4n30az2.js";
+import"../../../chunks/account-limits-cache-b23sbrke.js";
+export {
+  anthropicOAuth2 as anthropicOAuth
+};

package/dist/src/auth/oauth/authorization-input.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parse a pasted authorization code: a redirect URL, `code#state`, a
+ * `code=...&state=...` query string, or a bare code. Browser-safe.
+ */
+export declare function parseAuthorizationInput(input: string): {
+    code?: undefined;
+    state?: undefined;
+} | {
+    code: string | undefined;
+    state: string | undefined;
+} | {
+    code: string;
+    state?: undefined;
+};

package/dist/src/auth/oauth/authorization-input.js

@@ -0,0 +1,6 @@
+import {
+  parseAuthorizationInput2
+} from "../../../chunks/account-limits-cache-d1ypzqzp.js";
+export {
+  parseAuthorizationInput2 as parseAuthorizationInput
+};

package/dist/src/auth/oauth/device-code.d.ts

@@ -0,0 +1,29 @@
+type OAuthDeviceCodeIncompletePollResult = {
+    status: "pending";
+} | {
+    status: "slow_down";
+    intervalSeconds?: number;
+} | {
+    status: "failed";
+    message: string;
+};
+export type OAuthDeviceCodePollResult<T> = OAuthDeviceCodeIncompletePollResult | {
+    status: "complete";
+    value: T;
+};
+export type OAuthDeviceCodePollOptions<T> = {
+    intervalSeconds?: number;
+    expiresInSeconds?: number;
+    waitBeforeFirstPoll?: boolean;
+    poll: () => Promise<OAuthDeviceCodePollResult<T>>;
+    signal: AbortSignal;
+};
+export declare function abortableSleep(ms: number, signal: AbortSignal, cancelMessage: string): Promise<void>;
+/**
+ * Polls a device-code grant until it completes, fails, or expires. On `slow_down` it uses the
+ * server-provided interval when given (GitHub reports the new required minimum in `interval`);
+ * trusting only a client-tracked value risks polling early forever under WSL/VM clock drift.
+ * Otherwise it applies RFC 8628 section 3.5 and adds 5 seconds.
+ */
+export declare function pollOAuthDeviceCodeFlow<T>(options: OAuthDeviceCodePollOptions<T>): Promise<T>;
+export {};

package/dist/src/auth/oauth/device-code.js

@@ -0,0 +1,9 @@
+import {
+  abortableSleep3,
+  pollOAuthDeviceCodeFlow2
+} from "../../../chunks/account-limits-cache-4hptgd2h.js";
+import"../../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  abortableSleep3 as abortableSleep,
+  pollOAuthDeviceCodeFlow2 as pollOAuthDeviceCodeFlow
+};

package/dist/src/auth/oauth/github-copilot.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fetch-only Copilot OAuth.
+ * Hosts own interaction and storage; login and refresh publish only complete credentials.
+ */
+import { Type, type Static } from "typebox";
+import type { FetchFunction } from "../../types.ts";
+import type { OAuthAuth } from "../types.ts";
+declare const CopilotCredential: Type.TObject<{
+    type: Type.TLiteral<"oauth">;
+    refresh: Type.TString;
+    access: Type.TString;
+    expires: Type.TInteger;
+    availableModelIds: Type.TArray<Type.TString>;
+}>;
+export interface GitHubCopilotOAuthOptions {
+    fetch?: FetchFunction;
+    /** The client must be permitted to use Copilot's session-token exchange. */
+    clientId?: string;
+}
+/** Credential storage is an external boundary, including provider-specific metadata. */
+export declare function matchesCopilotCredential(value: unknown): value is Static<typeof CopilotCredential>;
+export declare function githubCopilotOAuth(options?: GitHubCopilotOAuthOptions, knownModelIds?: () => ReadonlySet<string>): OAuthAuth;
+export {};

package/dist/src/auth/oauth/github-copilot.js

@@ -0,0 +1,12 @@
+import {
+  matchesCopilotCredential2,
+  githubCopilotOAuth2
+} from "../../../chunks/account-limits-cache-cw7q7vfy.js";
+import"../../../chunks/account-limits-cache-gs8a3fhw.js";
+import"../../../chunks/account-limits-cache-za42x8a3.js";
+import"../../../chunks/account-limits-cache-4hptgd2h.js";
+import"../../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  githubCopilotOAuth2 as githubCopilotOAuth,
+  matchesCopilotCredential2 as matchesCopilotCredential
+};

package/dist/src/auth/oauth/load.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lazy loaders for the built-in OAuth flows. Provider definitions advertise
+ * OAuth through `lazyOAuth` + one of these, so the Node-only flow modules
+ * (callback servers, PKCE) are imported only when a login or refresh runs.
+ * Each flow module registers its flow when it loads, so a loader reads a typed
+ * registry instead of an untyped module namespace.
+ */
+import type { OAuthAuth } from "../types.ts";
+type OAuthFlowId = "anthropic" | "openaiCodex";
+/** Records a built-in flow; its module calls this on load, and bundled hosts call it up front. */
+export declare function registerOAuthFlow(id: OAuthFlowId, flow: OAuthAuth): void;
+export declare const loadAnthropicOAuth: () => Promise<OAuthAuth>;
+export declare const loadOpenAICodexOAuth: () => Promise<OAuthAuth>;
+export {};

package/dist/src/auth/oauth/load.js

@@ -0,0 +1,10 @@
+import {
+  registerOAuthFlow2,
+  loadAnthropicOAuth2,
+  loadOpenAICodexOAuth2
+} from "../../../chunks/account-limits-cache-v4n30az2.js";
+export {
+  loadAnthropicOAuth2 as loadAnthropicOAuth,
+  loadOpenAICodexOAuth2 as loadOpenAICodexOAuth,
+  registerOAuthFlow2 as registerOAuthFlow
+};

package/dist/src/auth/oauth/oauth-page.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Self-contained HTML pages served by the localhost OAuth callback servers
+ * (success and failure), rendered as plain strings with escaped content.
+ *
+ * The page follows the Nyte landing language (paper/ink, hairline rules with corner
+ * ticks, square corners), picks light or dark from the OS, and carries the
+ * provider name in the heading. No mark yet, one system font, no JS, no
+ * network: the page has to work offline and load from nothing but this string.
+ */
+export declare function oauthSuccessHtml(options: {
+    provider: string;
+}): string;
+export declare function oauthErrorHtml(message: string, details?: string): string;

package/dist/src/auth/oauth/oauth-page.js

@@ -0,0 +1,8 @@
+import {
+  oauthSuccessHtml2,
+  oauthErrorHtml2
+} from "../../../chunks/account-limits-cache-8vzx8k6r.js";
+export {
+  oauthErrorHtml2 as oauthErrorHtml,
+  oauthSuccessHtml2 as oauthSuccessHtml
+};