@omnicross/contracts 0.1.0

package/dist/subscription-types.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/subscription-types.ts
+var subscription_types_exports = {};
+__export(subscription_types_exports, {
+  legacyCliBackendToSubscriptionProvider: () => legacyCliBackendToSubscriptionProvider,
+  subscriptionTargetForSession: () => subscriptionTargetForSession
+});
+module.exports = __toCommonJS(subscription_types_exports);
+function legacyCliBackendToSubscriptionProvider(cliBackend) {
+  switch (cliBackend) {
+    case "claude-code":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "gemini-cli":
+      return "gemini";
+    case "opencodego":
+      return "opencodego";
+    default:
+      return null;
+  }
+}
+function subscriptionTargetForSession(session) {
+  return session.subscriptionProviderId ?? legacyCliBackendToSubscriptionProvider(session.cliBackend);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  legacyCliBackendToSubscriptionProvider,
+  subscriptionTargetForSession
+});

package/dist/subscription-types.d.cts

@@ -0,0 +1,149 @@
+/**
+ * Multi-subscription dispatch contracts.
+ *
+ * Subscription providers are catalog entries that route an agent through a
+ * user's third-party subscription (Claude Pro/Max, ChatGPT Plus/Pro via Codex
+ * OAuth, Google Gemini OAuth, OpenCodeGo Bearer key). They are distinct from
+ * user-configured LLM providers.
+ *
+ * Holds the provider-id / OpenCodeGo / status / list contracts plus the resolver
+ * helpers the `@omnicross/*` packages consume.
+ */
+/** Stable IDs for built-in subscription providers. */
+type SubscriptionProviderId = 'claude' | 'codex' | 'gemini' | 'opencodego';
+/**
+ * OpenCodeGo routing scenarios, mirroring `_others/oc-go-cc/internal/router/`
+ * (and `_others/oc-go-cc/configs/config.example.json`).
+ *
+ * `background` is DORMANT in this version: the scenario router never
+ * auto-selects it (keyword-driven selection is a downstream change). It is
+ * reachable ONLY when a user explicitly keys `background` in
+ * `OpenCodeGoTokenConfig.modelMap` / `fallbacks`.
+ */
+type OpenCodeGoScenario = 'default' | 'long_context' | 'think' | 'complex' | 'fast' | 'background';
+/** One entry of the OpenCodeGo model map — selected by the scenario router. */
+interface OpenCodeGoModelEntry {
+    /** Provider model id sent upstream (e.g. `kimi-k2.6`, `minimax-m2.5`). */
+    modelId: string;
+    /**
+     * Which opencode provider HALF this model lives on. Mirrors the reference
+     * `ModelConfig.Provider` (`_others/oc-go-cc`). When ABSENT it defaults to
+     * `'go'` (the reference's `Provider("")` → `opencode-go`), so every existing
+     * stored config behaves byte-identically (no zen traffic). The built-in
+     * default `modelMap`/`fallbacks` are entirely `'go'`; a `'zen'` model is
+     * reachable ONLY via a user-supplied entry that explicitly sets this field
+     * (strict user-only parity, mirroring the reference's `model_overrides`).
+     */
+    provider?: 'go' | 'zen';
+    /** Optional temperature override. */
+    temperature?: number;
+    /** Optional max_tokens override. */
+    maxTokens?: number;
+    /** When set, the scenario router only picks this entry when the estimated
+     *  cl100k_base input-token count meets/exceeds the threshold. */
+    contextThreshold?: number;
+}
+/**
+ * Persisted OpenCodeGo subscription configuration. Mirrors the
+ * Claude/Codex/Gemini siblings in `account-tokens-types.ts` but is
+ * static-bearer only (no OAuth, no refresh token).
+ */
+interface OpenCodeGoTokenConfig {
+    /** No OAuth — only manual API key entry is supported. */
+    authMethod: 'manual';
+    status: 'unconfigured' | 'configured' | 'error';
+    /** Encrypted on disk; decrypted in memory only via the host's token store. */
+    apiKey?: string;
+    /** Optional override of the default OpenCodeGo upstream host. Applies to the
+     *  GO half ONLY (mirrors the reference's `OC_GO_CC_OPENCODE_URL`); the zen
+     *  half is overridden by `zenBaseUrl`. */
+    baseUrl?: string;
+    /** Optional override of the default opencode-ZEN upstream host. Applies to the
+     *  ZEN half ONLY (mirrors the reference's `OC_GO_CC_OPENCODE_ZEN_URL`). When
+     *  unset, zen models resolve under the built-in zen constants. A go-half
+     *  override (`baseUrl`) NEVER redirects zen traffic and vice-versa. */
+    zenBaseUrl?: string;
+    /** Optional override of the built-in model map per scenario. */
+    modelMap?: Partial<Record<OpenCodeGoScenario, OpenCodeGoModelEntry>>;
+    /** Optional override of the built-in fallback chain per scenario. */
+    fallbacks?: Partial<Record<OpenCodeGoScenario, OpenCodeGoModelEntry[]>>;
+    lastRefreshedAt?: string;
+    errorMessage?: string;
+}
+/** Sanitized view of `OpenCodeGoTokenConfig` for client display. */
+interface OpenCodeGoTokenSanitized {
+    authMethod: 'manual';
+    status: 'unconfigured' | 'configured' | 'error';
+    hasApiKey: boolean;
+    baseUrl?: string;
+    /** Mirrors `OpenCodeGoTokenConfig.zenBaseUrl` (zen-half host override) for
+     *  client display parity with `baseUrl`. */
+    zenBaseUrl?: string;
+    lastRefreshedAt?: string;
+    errorMessage?: string;
+}
+/** Status of a single subscription provider, surfaced by `subscription:status`. */
+interface SubscriptionStatusEntry {
+    providerId: SubscriptionProviderId;
+    ok: boolean;
+    /** Machine-readable reason when `ok === false`. */
+    reason?: 'missing-credential' | 'expired' | 'reauth-required' | 'refresh-failed' | 'not-refreshable' | 'unknown';
+    /** ISO timestamp when the credential expires (OAuth providers only). */
+    expiresAt?: string;
+}
+/** Catalog entry returned by `subscription:list`. */
+interface SubscriptionListEntry {
+    providerId: SubscriptionProviderId;
+    displayName: string;
+    /** Auth model — same discriminator as the dispatch `AuthStrategy.kind`. */
+    kind: 'pass-through' | 'oauth-bearer' | 'static-bearer';
+    credentialStatus: SubscriptionStatusEntry;
+}
+/**
+ * Map a legacy `cliBackend` engine-marker token to the subscription-target
+ * `SubscriptionProviderId` it used to imply. Pre-D6
+ * (`provider-proxy-transformer-matrix`) the subscription target was DERIVED
+ * from `cliBackend`; this function preserves that derivation as a backfill /
+ * in-flight fallback only. New sessions carry an explicit
+ * `subscriptionProviderId` and SHOULD NOT rely on this.
+ *
+ * `'opencodego'` is intentionally accepted as an input here even though it is
+ * no longer a `CodeCliBackend` member — the migration backfill reads raw DB
+ * rows that may still hold the legacy token.
+ */
+declare function legacyCliBackendToSubscriptionProvider(cliBackend: string | null | undefined): SubscriptionProviderId | null;
+/**
+ * Resolve the subscription-target `SubscriptionProviderId` for a session.
+ *
+ * Precedence (D6): the EXPLICIT `subscriptionProviderId` field wins. When it
+ * is unset (in-flight rows created before the field existed / before backfill),
+ * fall back to the legacy `cliBackend`-derived mapping. Returns `null` when
+ * neither resolves — the caller treats that as "no subscription target".
+ *
+ * This is the SINGLE place engine code should consult to find a session's
+ * upstream subscription Provider — never the `cliBackend` token directly.
+ */
+declare function subscriptionTargetForSession(session: {
+    subscriptionProviderId?: SubscriptionProviderId | null;
+    cliBackend?: string | null;
+}): SubscriptionProviderId | null;
+/**
+ * Provider-channel axis (Axis 2) — HOW a session's provider credential is
+ * sourced / routed, orthogonal to the engine (Axis 1, `EngineType`).
+ *
+ * - `native`       — the provider's own egress (e.g. a CLI binary talking to
+ *                    its own backend, or a direct first-party API). Replaces
+ *                    the old `EngineSource = 'cli'` value.
+ * - `subscription` — routed through a user's third-party subscription
+ *                    (Claude Pro/Max, Codex/ChatGPT, Gemini, OpenCodeGo).
+ * - `relay`        — routed through a relay / proxy endpoint.
+ * - `api-key`      — routed with a user-supplied BYO API key.
+ *
+ * Renamed from `EngineSource` and value-space-expanded by the
+ * `engine-provider-decouple` change (Phase 0). The engine type is now a pure
+ * `f(engine)` lookup and no longer reads this axis; per-channel injection
+ * wiring lands in Phase 1b.
+ */
+type ProviderChannel = 'native' | 'subscription' | 'relay' | 'api-key';
+
+export { type OpenCodeGoModelEntry, type OpenCodeGoScenario, type OpenCodeGoTokenConfig, type OpenCodeGoTokenSanitized, type ProviderChannel, type SubscriptionListEntry, type SubscriptionProviderId, type SubscriptionStatusEntry, legacyCliBackendToSubscriptionProvider, subscriptionTargetForSession };

package/dist/subscription-types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Multi-subscription dispatch contracts.
+ *
+ * Subscription providers are catalog entries that route an agent through a
+ * user's third-party subscription (Claude Pro/Max, ChatGPT Plus/Pro via Codex
+ * OAuth, Google Gemini OAuth, OpenCodeGo Bearer key). They are distinct from
+ * user-configured LLM providers.
+ *
+ * Holds the provider-id / OpenCodeGo / status / list contracts plus the resolver
+ * helpers the `@omnicross/*` packages consume.
+ */
+/** Stable IDs for built-in subscription providers. */
+type SubscriptionProviderId = 'claude' | 'codex' | 'gemini' | 'opencodego';
+/**
+ * OpenCodeGo routing scenarios, mirroring `_others/oc-go-cc/internal/router/`
+ * (and `_others/oc-go-cc/configs/config.example.json`).
+ *
+ * `background` is DORMANT in this version: the scenario router never
+ * auto-selects it (keyword-driven selection is a downstream change). It is
+ * reachable ONLY when a user explicitly keys `background` in
+ * `OpenCodeGoTokenConfig.modelMap` / `fallbacks`.
+ */
+type OpenCodeGoScenario = 'default' | 'long_context' | 'think' | 'complex' | 'fast' | 'background';
+/** One entry of the OpenCodeGo model map — selected by the scenario router. */
+interface OpenCodeGoModelEntry {
+    /** Provider model id sent upstream (e.g. `kimi-k2.6`, `minimax-m2.5`). */
+    modelId: string;
+    /**
+     * Which opencode provider HALF this model lives on. Mirrors the reference
+     * `ModelConfig.Provider` (`_others/oc-go-cc`). When ABSENT it defaults to
+     * `'go'` (the reference's `Provider("")` → `opencode-go`), so every existing
+     * stored config behaves byte-identically (no zen traffic). The built-in
+     * default `modelMap`/`fallbacks` are entirely `'go'`; a `'zen'` model is
+     * reachable ONLY via a user-supplied entry that explicitly sets this field
+     * (strict user-only parity, mirroring the reference's `model_overrides`).
+     */
+    provider?: 'go' | 'zen';
+    /** Optional temperature override. */
+    temperature?: number;
+    /** Optional max_tokens override. */
+    maxTokens?: number;
+    /** When set, the scenario router only picks this entry when the estimated
+     *  cl100k_base input-token count meets/exceeds the threshold. */
+    contextThreshold?: number;
+}
+/**
+ * Persisted OpenCodeGo subscription configuration. Mirrors the
+ * Claude/Codex/Gemini siblings in `account-tokens-types.ts` but is
+ * static-bearer only (no OAuth, no refresh token).
+ */
+interface OpenCodeGoTokenConfig {
+    /** No OAuth — only manual API key entry is supported. */
+    authMethod: 'manual';
+    status: 'unconfigured' | 'configured' | 'error';
+    /** Encrypted on disk; decrypted in memory only via the host's token store. */
+    apiKey?: string;
+    /** Optional override of the default OpenCodeGo upstream host. Applies to the
+     *  GO half ONLY (mirrors the reference's `OC_GO_CC_OPENCODE_URL`); the zen
+     *  half is overridden by `zenBaseUrl`. */
+    baseUrl?: string;
+    /** Optional override of the default opencode-ZEN upstream host. Applies to the
+     *  ZEN half ONLY (mirrors the reference's `OC_GO_CC_OPENCODE_ZEN_URL`). When
+     *  unset, zen models resolve under the built-in zen constants. A go-half
+     *  override (`baseUrl`) NEVER redirects zen traffic and vice-versa. */
+    zenBaseUrl?: string;
+    /** Optional override of the built-in model map per scenario. */
+    modelMap?: Partial<Record<OpenCodeGoScenario, OpenCodeGoModelEntry>>;
+    /** Optional override of the built-in fallback chain per scenario. */
+    fallbacks?: Partial<Record<OpenCodeGoScenario, OpenCodeGoModelEntry[]>>;
+    lastRefreshedAt?: string;
+    errorMessage?: string;
+}
+/** Sanitized view of `OpenCodeGoTokenConfig` for client display. */
+interface OpenCodeGoTokenSanitized {
+    authMethod: 'manual';
+    status: 'unconfigured' | 'configured' | 'error';
+    hasApiKey: boolean;
+    baseUrl?: string;
+    /** Mirrors `OpenCodeGoTokenConfig.zenBaseUrl` (zen-half host override) for
+     *  client display parity with `baseUrl`. */
+    zenBaseUrl?: string;
+    lastRefreshedAt?: string;
+    errorMessage?: string;
+}
+/** Status of a single subscription provider, surfaced by `subscription:status`. */
+interface SubscriptionStatusEntry {
+    providerId: SubscriptionProviderId;
+    ok: boolean;
+    /** Machine-readable reason when `ok === false`. */
+    reason?: 'missing-credential' | 'expired' | 'reauth-required' | 'refresh-failed' | 'not-refreshable' | 'unknown';
+    /** ISO timestamp when the credential expires (OAuth providers only). */
+    expiresAt?: string;
+}
+/** Catalog entry returned by `subscription:list`. */
+interface SubscriptionListEntry {
+    providerId: SubscriptionProviderId;
+    displayName: string;
+    /** Auth model — same discriminator as the dispatch `AuthStrategy.kind`. */
+    kind: 'pass-through' | 'oauth-bearer' | 'static-bearer';
+    credentialStatus: SubscriptionStatusEntry;
+}
+/**
+ * Map a legacy `cliBackend` engine-marker token to the subscription-target
+ * `SubscriptionProviderId` it used to imply. Pre-D6
+ * (`provider-proxy-transformer-matrix`) the subscription target was DERIVED
+ * from `cliBackend`; this function preserves that derivation as a backfill /
+ * in-flight fallback only. New sessions carry an explicit
+ * `subscriptionProviderId` and SHOULD NOT rely on this.
+ *
+ * `'opencodego'` is intentionally accepted as an input here even though it is
+ * no longer a `CodeCliBackend` member — the migration backfill reads raw DB
+ * rows that may still hold the legacy token.
+ */
+declare function legacyCliBackendToSubscriptionProvider(cliBackend: string | null | undefined): SubscriptionProviderId | null;
+/**
+ * Resolve the subscription-target `SubscriptionProviderId` for a session.
+ *
+ * Precedence (D6): the EXPLICIT `subscriptionProviderId` field wins. When it
+ * is unset (in-flight rows created before the field existed / before backfill),
+ * fall back to the legacy `cliBackend`-derived mapping. Returns `null` when
+ * neither resolves — the caller treats that as "no subscription target".
+ *
+ * This is the SINGLE place engine code should consult to find a session's
+ * upstream subscription Provider — never the `cliBackend` token directly.
+ */
+declare function subscriptionTargetForSession(session: {
+    subscriptionProviderId?: SubscriptionProviderId | null;
+    cliBackend?: string | null;
+}): SubscriptionProviderId | null;
+/**
+ * Provider-channel axis (Axis 2) — HOW a session's provider credential is
+ * sourced / routed, orthogonal to the engine (Axis 1, `EngineType`).
+ *
+ * - `native`       — the provider's own egress (e.g. a CLI binary talking to
+ *                    its own backend, or a direct first-party API). Replaces
+ *                    the old `EngineSource = 'cli'` value.
+ * - `subscription` — routed through a user's third-party subscription
+ *                    (Claude Pro/Max, Codex/ChatGPT, Gemini, OpenCodeGo).
+ * - `relay`        — routed through a relay / proxy endpoint.
+ * - `api-key`      — routed with a user-supplied BYO API key.
+ *
+ * Renamed from `EngineSource` and value-space-expanded by the
+ * `engine-provider-decouple` change (Phase 0). The engine type is now a pure
+ * `f(engine)` lookup and no longer reads this axis; per-channel injection
+ * wiring lands in Phase 1b.
+ */
+type ProviderChannel = 'native' | 'subscription' | 'relay' | 'api-key';
+
+export { type OpenCodeGoModelEntry, type OpenCodeGoScenario, type OpenCodeGoTokenConfig, type OpenCodeGoTokenSanitized, type ProviderChannel, type SubscriptionListEntry, type SubscriptionProviderId, type SubscriptionStatusEntry, legacyCliBackendToSubscriptionProvider, subscriptionTargetForSession };

package/dist/subscription-types.js

@@ -0,0 +1,22 @@
+// src/subscription-types.ts
+function legacyCliBackendToSubscriptionProvider(cliBackend) {
+  switch (cliBackend) {
+    case "claude-code":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "gemini-cli":
+      return "gemini";
+    case "opencodego":
+      return "opencodego";
+    default:
+      return null;
+  }
+}
+function subscriptionTargetForSession(session) {
+  return session.subscriptionProviderId ?? legacyCliBackendToSubscriptionProvider(session.cliBackend);
+}
+export {
+  legacyCliBackendToSubscriptionProvider,
+  subscriptionTargetForSession
+};

package/dist/thinking-CBWSLel8.d.cts

@@ -0,0 +1,33 @@
+/**
+ * @module shared/completion-types/thinking
+ *
+ * Thinking / reasoning effort level + reasoning-config types. Provider-
+ * neutral surface used by both OpenAI- and Anthropic-style requests.
+ */
+/**
+ * Thinking/reasoning effort levels
+ * Used to configure the amount of reasoning in model responses
+ */
+type ThinkLevel = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * Thinking content with optional signature for verification
+ */
+interface ThinkingContent {
+    /** The thinking/reasoning content */
+    content: string;
+    /** Optional cryptographic signature for thinking verification */
+    signature?: string;
+}
+/**
+ * Reasoning configuration for model requests
+ */
+interface ReasoningConfig {
+    /** Reasoning effort level */
+    effort?: ThinkLevel;
+    /** Maximum tokens for reasoning */
+    max_tokens?: number;
+    /** Whether reasoning is enabled */
+    enabled?: boolean;
+}
+
+export type { ReasoningConfig as R, ThinkLevel as T, ThinkingContent as a };

package/dist/thinking-CBWSLel8.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @module shared/completion-types/thinking
+ *
+ * Thinking / reasoning effort level + reasoning-config types. Provider-
+ * neutral surface used by both OpenAI- and Anthropic-style requests.
+ */
+/**
+ * Thinking/reasoning effort levels
+ * Used to configure the amount of reasoning in model responses
+ */
+type ThinkLevel = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * Thinking content with optional signature for verification
+ */
+interface ThinkingContent {
+    /** The thinking/reasoning content */
+    content: string;
+    /** Optional cryptographic signature for thinking verification */
+    signature?: string;
+}
+/**
+ * Reasoning configuration for model requests
+ */
+interface ReasoningConfig {
+    /** Reasoning effort level */
+    effort?: ThinkLevel;
+    /** Maximum tokens for reasoning */
+    max_tokens?: number;
+    /** Whether reasoning is enabled */
+    enabled?: boolean;
+}
+
+export type { ReasoningConfig as R, ThinkLevel as T, ThinkingContent as a };

package/dist/thinking-config.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/thinking-config.ts
+var thinking_config_exports = {};
+__export(thinking_config_exports, {
+  CANNOT_DISABLE_THINKING_PATTERNS: () => CANNOT_DISABLE_THINKING_PATTERNS,
+  DEFAULT_MAX_TOKENS: () => DEFAULT_MAX_TOKENS,
+  EFFORT_RATIO: () => EFFORT_RATIO,
+  REASONING_MODEL_PATTERNS: () => REASONING_MODEL_PATTERNS,
+  THINKING_TOKEN_MAP: () => THINKING_TOKEN_MAP,
+  buildAnthropicThinking: () => buildAnthropicThinking,
+  buildGeminiThinkingConfig: () => buildGeminiThinkingConfig,
+  buildQwenThinkingConfig: () => buildQwenThinkingConfig,
+  calculateThinkingBudget: () => calculateThinkingBudget,
+  canDisableThinking: () => canDisableThinking,
+  findTokenLimit: () => findTokenLimit,
+  getClaudeMaxTokens: () => getClaudeMaxTokens,
+  getOpenAIReasoningEffort: () => getOpenAIReasoningEffort,
+  isReasoningModel: () => isReasoningModel
+});
+module.exports = __toCommonJS(thinking_config_exports);
+var EFFORT_RATIO = {
+  none: 0.01,
+  minimal: 0.02,
+  low: 0.05,
+  medium: 0.5,
+  high: 0.8,
+  xhigh: 0.92,
+  max: 0.95
+};
+var DEFAULT_MAX_TOKENS = 4096;
+var THINKING_TOKEN_MAP = {
+  // Gemini
+  "gemini-2\\.5-flash-lite": { min: 512, max: 24576 },
+  "gemini-.*-flash": { min: 0, max: 24576 },
+  "gemini-.*-pro": { min: 128, max: 32768 },
+  // Qwen
+  "qwen3-235b-a22b-thinking": { min: 0, max: 81920 },
+  "qwen3-30b-a3b-thinking": { min: 0, max: 81920 },
+  "qwen3-vl-235b-a22b-thinking": { min: 0, max: 81920 },
+  "qwen3-vl-30b-a3b-thinking": { min: 0, max: 81920 },
+  "qwen-plus-2025": { min: 0, max: 38912 },
+  "qwen-plus": { min: 0, max: 81920 },
+  "qwen-turbo": { min: 0, max: 38912 },
+  "qwen-flash": { min: 0, max: 81920 },
+  "qwen3-": { min: 1024, max: 38912 },
+  qwq: { min: 1024, max: 38912 },
+  // Claude (incl. AWS Bedrock, GCP Vertex AI)
+  "claude-opus-4[.-]7": { min: 1024, max: 128e3 },
+  "claude-(sonnet|opus)-4[.-]6": { min: 1024, max: 128e3 },
+  "claude-3[.-]7.*sonnet": { min: 1024, max: 64e3 },
+  "claude-(haiku|sonnet|opus)-4[.-]5": { min: 1024, max: 64e3 },
+  "claude-opus-4[.-]1": { min: 1024, max: 32e3 },
+  "claude-sonnet-4": { min: 1024, max: 64e3 },
+  "claude-opus-4": { min: 1024, max: 32e3 },
+  "claude-3[.-]5-sonnet": { min: 1024, max: 64e3 },
+  // OpenAI o-series
+  "o1-preview": { min: 0, max: 32768 },
+  "o1-mini": { min: 0, max: 32768 },
+  "o1-pro": { min: 0, max: 32768 },
+  "o3-mini": { min: 0, max: 32768 },
+  o3: { min: 0, max: 65536 },
+  "o4-mini": { min: 0, max: 32768 },
+  // GPT-5 series (Response API reasoning models)
+  "gpt-5\\.5": { min: 0, max: 128e3 },
+  "gpt-5\\.4": { min: 0, max: 128e3 },
+  "gpt-5\\.3": { min: 0, max: 128e3 },
+  "gpt-5\\.2": { min: 0, max: 65536 },
+  "gpt-5\\.1": { min: 0, max: 65536 },
+  "gpt-5": { min: 0, max: 65536 },
+  // DeepSeek
+  "deepseek-v4-pro": { min: 0, max: 32768 },
+  "deepseek-v4-flash": { min: 0, max: 32768 },
+  "deepseek-r1": { min: 0, max: 32768 },
+  "deepseek-reasoner": { min: 0, max: 32768 },
+  // Baichuan
+  "baichuan-m2": { min: 0, max: 3e4 },
+  "baichuan-m3": { min: 0, max: 3e4 },
+  // Grok
+  "grok-3": { min: 0, max: 32768 },
+  // Zhipu GLM
+  "glm.*zero": { min: 0, max: 16384 },
+  // Hunyuan
+  "hunyuan.*t1": { min: 0, max: 16384 },
+  // Doubao
+  "doubao.*think": { min: 0, max: 16384 }
+};
+var REASONING_MODEL_PATTERNS = [
+  /^o[134](-mini|-preview|-pro)?$/i,
+  /^gpt-5(\.\d)?(-pro|-codex|-codex-max)?/i,
+  /claude.*3[.-]?5.*sonnet|claude.*sonnet.*3[.-]?5|claude-sonnet-4|claude-opus-4|claude-(haiku|sonnet|opus)-4[.-]?5/i,
+  /gemini.*(2\.0|2-|2\.5|3).*flash|gemini.*(2\.5|3).*pro|gemini.*think/i,
+  /grok-3/i,
+  /qwq|qwen.*qwq|qwen.*thinking/i,
+  /deepseek-v4|deepseek.*r1|r1.*deepseek|deepseek-reasoner/i,
+  /glm.*zero/i,
+  /hunyuan.*t1/i,
+  /doubao.*think/i,
+  /baichuan-m[23]/i
+];
+var CANNOT_DISABLE_THINKING_PATTERNS = [
+  /gemini.*3.*pro/i,
+  /gemini.*2\.5.*pro/i,
+  /^o1-pro$/i
+];
+function isReasoningModel(modelId) {
+  if (!modelId) return false;
+  return REASONING_MODEL_PATTERNS.some((pattern) => pattern.test(modelId));
+}
+function canDisableThinking(modelId) {
+  if (!modelId) return true;
+  return !CANNOT_DISABLE_THINKING_PATTERNS.some((pattern) => pattern.test(modelId));
+}
+function findTokenLimit(modelOrId) {
+  if (!modelOrId) return null;
+  if (typeof modelOrId === "object") {
+    if (modelOrId.thinkingTokenLimit) return modelOrId.thinkingTokenLimit;
+    return findTokenLimit(modelOrId.id);
+  }
+  const lowerModelId = modelOrId.toLowerCase();
+  for (const [pattern, limit] of Object.entries(THINKING_TOKEN_MAP)) {
+    const regex = new RegExp(pattern, "i");
+    if (regex.test(lowerModelId)) {
+      return limit;
+    }
+  }
+  return null;
+}
+function calculateThinkingBudget(modelId, level, userMaxTokens) {
+  if (level === "none") {
+    const tokenLimit2 = findTokenLimit(modelId);
+    if (tokenLimit2 && tokenLimit2.min > 0) {
+      return tokenLimit2.min;
+    }
+    return void 0;
+  }
+  const tokenLimit = findTokenLimit(modelId);
+  const ratio = EFFORT_RATIO[level];
+  if (!tokenLimit) {
+    if (userMaxTokens) {
+      const maxBudget = Math.floor(userMaxTokens * 0.75);
+      return Math.floor(Math.min(userMaxTokens * ratio, maxBudget));
+    }
+    return void 0;
+  }
+  const formulaResult = Math.floor((tokenLimit.max - tokenLimit.min) * ratio + tokenLimit.min);
+  if (userMaxTokens !== void 0) {
+    const maxBudgetFromUserTokens = Math.floor(userMaxTokens * Math.min(ratio, 0.75));
+    return Math.max(tokenLimit.min, Math.min(formulaResult, maxBudgetFromUserTokens));
+  }
+  return formulaResult;
+}
+function getClaudeMaxTokens(userMaxTokens, thinkingBudget) {
+  if (!userMaxTokens) return void 0;
+  if (!thinkingBudget) return userMaxTokens;
+  const outputTokens = userMaxTokens - thinkingBudget;
+  return outputTokens > 0 ? outputTokens : void 0;
+}
+function getOpenAIReasoningEffort(level) {
+  switch (level) {
+    case "none":
+      return "none";
+    case "minimal":
+      return "minimal";
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "xhigh";
+    case "max":
+      return "high";
+    default:
+      return void 0;
+  }
+}
+function buildGeminiThinkingConfig(modelId, level, userMaxTokens) {
+  if (!isReasoningModel(modelId)) {
+    return void 0;
+  }
+  const budget = calculateThinkingBudget(modelId, level, userMaxTokens);
+  if (budget === void 0) {
+    return void 0;
+  }
+  return { thinking_budget: budget };
+}
+function buildAnthropicThinking(modelId, level, userMaxTokens) {
+  if (level === "none") {
+    return void 0;
+  }
+  const budget = calculateThinkingBudget(modelId, level, userMaxTokens);
+  if (!budget || budget < 1024) {
+    return { type: "enabled", budget_tokens: 1024 };
+  }
+  return { type: "enabled", budget_tokens: budget };
+}
+function buildQwenThinkingConfig(level, userMaxTokens) {
+  if (level === "none") {
+    return { enable_thinking: false };
+  }
+  const ratio = EFFORT_RATIO[level];
+  const budget = userMaxTokens ? Math.floor(userMaxTokens * ratio) : void 0;
+  return {
+    enable_thinking: true,
+    thinking_budget: budget
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CANNOT_DISABLE_THINKING_PATTERNS,
+  DEFAULT_MAX_TOKENS,
+  EFFORT_RATIO,
+  REASONING_MODEL_PATTERNS,
+  THINKING_TOKEN_MAP,
+  buildAnthropicThinking,
+  buildGeminiThinkingConfig,
+  buildQwenThinkingConfig,
+  calculateThinkingBudget,
+  canDisableThinking,
+  findTokenLimit,
+  getClaudeMaxTokens,
+  getOpenAIReasoningEffort,
+  isReasoningModel
+});