@juspay/neurolink 10.12.8 → 11.0.0

package/dist/utils/json/coerce.js

@@ -23,6 +23,48 @@ import { nextBalancedJsonSpan } from "./extract.js";
 function hasSafeParse(schema) {
     return typeof schema.safeParse === "function";
 }
+/**
+ * Does `value` satisfy `schema`? A schema we cannot validate with (absent, or
+ * without a Zod-style `safeParse`) accepts everything — callers use this as a
+ * gate, not as proof, so an unknown schema must never block a value.
+ *
+ * Exists so the consumers of coerceJsonToSchema can refuse to publish a
+ * recovered value as `structuredData` when the caller's schema rejects it —
+ * e.g. a raw *string* under an object schema, which is the shape a truncated
+ * response degrades to.
+ */
+export function schemaAccepts(schema, value) {
+    if (!schema || !hasSafeParse(schema)) {
+        return true;
+    }
+    return schema.safeParse(value).success;
+}
+/**
+ * Recover a JSON *scalar* root (string/number/boolean) from model text. The
+ * object/array case is handled by `coerceJsonToSchema`; this covers the
+ * residual scalar root after that path returns null. Encapsulates the JSON
+ * parsing, the empty-string normalization, and the `schemaAccepts` gate so the
+ * same policy cannot drift between consumers (`neurolink.recoverStructuredData`
+ * and `GenerationHandler.coerceTextMode`).
+ */
+export function recoverScalarRoot(text, schema) {
+    try {
+        const scalar = JSON.parse(text);
+        if (scalar === "") {
+            return { kind: "empty" };
+        }
+        if (scalar === null || scalar === undefined) {
+            return { kind: "nullish" };
+        }
+        if (schemaAccepts(schema, scalar)) {
+            return { kind: "accepted", value: scalar };
+        }
+        return { kind: "rejected", value: scalar };
+    }
+    catch {
+        return { kind: "not-json" };
+    }
+}
 /**
  * Parse `candidate` as JSON, repairing common escaping mistakes on failure.
  * Returns the parsed value plus whether jsonrepair had to alter the text.
@@ -51,6 +93,34 @@ function parseOrRepair(candidate) {
 }
 /** Bounds the recursive nested-string unwrap against pathological inputs. */
 const MAX_NESTED_UNWRAP_DEPTH = 6;
+/** Bounds the structural back-off when salvaging a truncated root object. */
+const MAX_SALVAGE_TRIMS = 8;
+/**
+ * Last-resort recovery for output cut off mid-JSON: walk the unclosed root span
+ * backwards to successively earlier structural boundaries (`,` / `}` / `]`) and
+ * re-attempt parse+repair at each one. Truncation can land somewhere jsonrepair
+ * cannot close on its own (inside an escape, a half-written key, a dangling
+ * separator); dropping back to the last completed field gives it a repairable
+ * prefix. Returns a PARTIAL object — the fields the model did finish — so a
+ * truncated response degrades to an incomplete object rather than to raw text.
+ */
+function salvageTruncatedRoot(span) {
+    let candidate = span;
+    for (let i = 0; i < MAX_SALVAGE_TRIMS && candidate.length > 1; i++) {
+        const cut = Math.max(candidate.lastIndexOf(","), candidate.lastIndexOf("}"), candidate.lastIndexOf("]"));
+        if (cut <= 0) {
+            break;
+        }
+        candidate = candidate.slice(0, cut);
+        const outcome = parseOrRepair(candidate);
+        if (outcome !== undefined &&
+            outcome.value !== null &&
+            typeof outcome.value === "object") {
+            return outcome.value;
+        }
+    }
+    return undefined;
+}
 /**
  * Recursively replace any string-valued field whose content is itself a JSON
  * object/array with the parsed value. Models sometimes double-encode a NESTED
@@ -135,30 +205,54 @@ export function coerceJsonToSchema(text, schema) {
     //  3. first "{" or "[" to end of text (TRUNCATED output —
     //     finishReason=length — where the closing bracket was cut off;
     //     jsonrepair closes it)
-    // `truncated` marks the first-open-to-end candidate: it is only reachable
-    // when no balanced span and no first-to-last span matched, i.e. there was no
-    // closing bracket at all — the signature of token-truncated output.
+    // `truncated` marks a candidate that could only come from output cut short:
+    // the first-open-to-end span, and — when the ROOT bracket never closes —
+    // every other candidate too, since all of them are then partial views of an
+    // unfinished document.
+    //
+    // `rootAligned` marks candidates that start at the document's first opening
+    // bracket, i.e. at the real root. Candidates are ordered root-aligned FIRST.
+    // On truncated output the root brace never balances, so the balanced scan
+    // walks on and matches brackets that live INSIDE a string value (`[step 1]`
+    // in a shell script, say) — a syntactically fine but semantically bogus
+    // array. Preferring the root keeps the partial real object ahead of that.
     const candidates = [];
+    const openIndexes = [text.indexOf("{"), text.indexOf("[")].filter((i) => i >= 0);
+    const firstOpen = openIndexes.length > 0 ? Math.min(...openIndexes) : -1;
+    let rootClosed = false;
     let searchFrom = 0;
     for (;;) {
         const found = nextBalancedJsonSpan(text, searchFrom);
         if (!found) {
             break;
         }
-        candidates.push({ text: found.span, truncated: false });
+        const start = found.end - found.span.length;
+        if (start === firstOpen) {
+            rootClosed = true;
+        }
+        candidates.push({
+            text: found.span,
+            truncated: false,
+            rootAligned: start === firstOpen,
+        });
         searchFrom = found.end;
     }
-    const openIndexes = [text.indexOf("{"), text.indexOf("[")].filter((i) => i >= 0);
-    const firstOpen = openIndexes.length > 0 ? Math.min(...openIndexes) : -1;
+    // No balanced span starts at the root bracket → the document is unclosed.
+    const rootUnclosed = firstOpen >= 0 && !rootClosed;
     const lastClose = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
     if (firstOpen >= 0 && lastClose > firstOpen) {
         candidates.push({
             text: text.slice(firstOpen, lastClose + 1),
-            truncated: false,
+            truncated: rootUnclosed,
+            rootAligned: true,
         });
     }
     if (firstOpen >= 0) {
-        candidates.push({ text: text.slice(firstOpen), truncated: true });
+        candidates.push({
+            text: text.slice(firstOpen),
+            truncated: true,
+            rootAligned: true,
+        });
     }
     // JSON-string-literal wrapper: some providers double-encode and return the
     // object as a JSON *string* (e.g. `"{\"k\":1}"`). Unwrap one layer and add
@@ -174,7 +268,11 @@ export function coerceJsonToSchema(text, schema) {
                     if (!innerSpan) {
                         break;
                     }
-                    candidates.push({ text: innerSpan.span, truncated: false });
+                    candidates.push({
+                        text: innerSpan.span,
+                        truncated: false,
+                        rootAligned: false,
+                    });
                     innerFrom = innerSpan.end;
                 }
             }
@@ -183,11 +281,20 @@ export function coerceJsonToSchema(text, schema) {
             // not a string literal — ignore
         }
     }
+    // Stable partition: root-aligned candidates first. Only the ORDER changes —
+    // no candidate is dropped — so the multi-object "prefer the most complete
+    // schema-valid candidate" selection below is unaffected (it is order
+    // independent), while the unschema'd first-parseable-wins path and the
+    // `firstValid` fallback now favour the document's real root.
+    const ordered = [
+        ...candidates.filter((c) => c.rootAligned),
+        ...candidates.filter((c) => !c.rootAligned),
+    ];
     let firstValid;
     const schemaValid = [];
     const hasSchema = !!(schema && hasSafeParse(schema));
     const seen = new Set();
-    for (const candidate of candidates) {
+    for (const candidate of ordered) {
         if (seen.has(candidate.text)) {
             continue;
         }
@@ -202,6 +309,7 @@ export function coerceJsonToSchema(text, schema) {
             value: outcome.value,
             repaired: outcome.repaired,
             truncated: candidate.truncated,
+            rootAligned: candidate.rootAligned,
         };
         if (firstValid === undefined) {
             firstValid = record;
@@ -229,6 +337,7 @@ export function coerceJsonToSchema(text, schema) {
                     value: unwrapped.value,
                     repaired: true,
                     truncated: candidate.truncated,
+                    rootAligned: candidate.rootAligned,
                 });
             }
             else if (
@@ -247,6 +356,7 @@ export function coerceJsonToSchema(text, schema) {
                     value: outcome.value[0],
                     repaired: true,
                     truncated: candidate.truncated,
+                    rootAligned: candidate.rootAligned,
                 });
             }
         }
@@ -261,7 +371,34 @@ export function coerceJsonToSchema(text, schema) {
             ? cur
             : best)
         : undefined;
-    const chosen = schemaMatch ?? firstValid;
+    let chosen = schemaMatch ?? firstValid;
+    // Salvage the root when the document is unclosed AND nothing trustworthy came
+    // out of it: either nothing parsed at all, or the only parseable candidate is
+    // a bracket pair scraped from INSIDE a string value (not root-aligned, not
+    // schema-valid) — the `["step 1"]`-from-a-shell-script case. Backing off to
+    // the last completed field yields a PARTIAL OBJECT flagged `truncated`,
+    // instead of a bogus value or raw text degrading to a string.
+    if (rootUnclosed &&
+        schemaMatch === undefined &&
+        (chosen === undefined || !chosen.rootAligned)) {
+        const salvaged = salvageTruncatedRoot(text.slice(firstOpen));
+        if (salvaged !== undefined) {
+            logger.debug("[coerceJsonToSchema] salvaged a partial truncated object", {
+                textLength: text.length,
+            });
+            chosen = {
+                value: salvaged,
+                repaired: true,
+                truncated: true,
+                rootAligned: true,
+            };
+        }
+        else if (chosen !== undefined) {
+            // Nothing salvageable, but we still know the output was truncated —
+            // never report a candidate scraped from a truncated document as complete.
+            chosen = { ...chosen, truncated: true };
+        }
+    }
     if (chosen === undefined) {
         return null;
     }

package/dist/utils/providerConfig.d.ts

@@ -115,14 +115,6 @@ export declare function createDeepSeekConfig(): ProviderConfigOptions;
  * Creates NVIDIA NIM provider configuration
  */
 export declare function createNvidiaNimConfig(): ProviderConfigOptions;
-/**
- * Creates LM Studio provider configuration (local server)
- */
-export declare function createLmStudioConfig(): ProviderConfigOptions;
-/**
- * Creates llama.cpp provider configuration (local server)
- */
-export declare function createLlamaCppConfig(): ProviderConfigOptions;
 /**
  * Creates xAI Grok provider configuration.
  */

package/dist/utils/providerConfig.js

@@ -411,43 +411,6 @@ export function createNvidiaNimConfig() {
         ],
     };
 }
-/**
- * Creates LM Studio provider configuration (local server)
- */
-export function createLmStudioConfig() {
-    return {
-        providerName: "LM Studio",
-        envVarName: "LM_STUDIO_BASE_URL",
-        setupUrl: "https://lmstudio.ai/",
-        description: "LM Studio server URL",
-        instructions: [
-            "1. Install LM Studio: https://lmstudio.ai/",
-            "2. Open LM Studio and download a model (e.g. Llama 3.2 3B Instruct)",
-            '3. Click "Local Server" → Start Server',
-            "4. Default URL is http://localhost:1234/v1 (override via LM_STUDIO_BASE_URL)",
-        ],
-        // Base URL is optional — defaults to http://localhost:1234/v1 if unset.
-        optional: true,
-    };
-}
-/**
- * Creates llama.cpp provider configuration (local server)
- */
-export function createLlamaCppConfig() {
-    return {
-        providerName: "llama.cpp",
-        envVarName: "LLAMACPP_BASE_URL",
-        setupUrl: "https://github.com/ggerganov/llama.cpp",
-        description: "llama.cpp server URL",
-        instructions: [
-            "1. Build llama.cpp: https://github.com/ggerganov/llama.cpp#build",
-            "2. Run: ./llama-server -m model.gguf --port 8080",
-            "3. Default URL is http://localhost:8080/v1 (override via LLAMACPP_BASE_URL)",
-        ],
-        // Base URL is optional — defaults to http://localhost:8080/v1 if unset.
-        optional: true,
-    };
-}
 /**
  * Creates xAI Grok provider configuration.
  */

package/dist/utils/providerUtils.js

@@ -20,19 +20,6 @@ export async function getBestProvider(requestedProvider) {
         // For explicit provider requests, ALWAYS honor the request
         // Never override explicit provider selection with health-based fallbacks
         logger.debug(`[getBestProvider] Using explicitly requested provider: ${requestedProvider}`);
-        // Optional health check for logging purposes only
-        try {
-            const health = await ProviderHealthChecker.checkProviderHealth(requestedProvider, { includeConnectivityTest: false, cacheResults: true });
-            if (health.isHealthy) {
-                logger.debug(`[getBestProvider] Explicitly requested provider ${requestedProvider} is healthy`);
-            }
-            else {
-                logger.warn(`[getBestProvider] Explicitly requested provider ${requestedProvider} may have issues, but using anyway`, { error: health.error });
-            }
-        }
-        catch (error) {
-            logger.warn(`[getBestProvider] Health check failed for explicitly requested provider ${requestedProvider}, using anyway`, { error: error instanceof Error ? error.message : String(error) });
-        }
         // ALWAYS return the explicitly requested provider
         return requestedProvider;
     }
@@ -402,18 +389,7 @@ export function hasProviderEnvVars(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return [
-        "bedrock",
-        "vertex",
-        "openai",
-        "anthropic",
-        "azure",
-        "google-ai",
-        "litellm",
-        "huggingface",
-        "ollama",
-        "mistral",
-    ];
+    return Object.values(AIProviderName).filter((name) => name !== AIProviderName.AUTO);
 }
 /**
  * Validate provider name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.12.8",
+  "version": "11.0.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -103,8 +103,10 @@
     "test:mcp:limits": "npx tsx test/continuous-test-suite-mcp-output-limits.ts",
     "test:mcp:infra": "npx tsx test/continuous-test-suite-mcp-infra.ts",
     "test:providers-mocked": "npx tsx test/continuous-test-suite-providers-mocked.ts",
+    "test:provider-structure": "npx tsx test/continuous-test-suite-provider-structure.ts",
     "test:provider-fallback": "npx tsx test/continuous-test-suite-provider-fallback.ts",
     "test:provider-fallback-latency": "npx tsx test/continuous-test-suite-provider-fallback-latency.ts",
+    "test:provider-wiring": "npx tsx test/continuous-test-suite-provider-wiring.ts",
     "test:rag": "npx tsx test/continuous-test-suite-rag.ts",
     "test:vector-pinecone": "npx tsx test/continuous-test-suite-vector-pinecone.ts",
     "test:vector-pgvector": "npx tsx test/continuous-test-suite-vector-pgvector.ts",
@@ -158,16 +160,16 @@
     "test:retry-after:vitest": "pnpm exec vitest run test/retryAfter.test.ts",
     "test:websearch-grounding": "npx tsx test/continuous-test-suite-websearch-grounding.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
-    "// CI tier — fast, no live AI calls, safe for every commit": "",
+    "// CI tier — fast, no live AI calls, safe for every commit (test:unit; also see the separate provider-safety-net CI job, which runs build + test:providers-mocked + test:provider-structure on every PR)": "",
     "test:tool-routing": "npx tsx test/continuous-test-suite-tool-routing.ts",
     "test:classifier-router": "npx tsx test/continuous-test-suite-classifier-router.ts",
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:unified-files-prompt-sync && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:proxy:vitest",
-    "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:unified-files-prompt-sync && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:proxy:vitest && pnpm run test:provider-wiring",
+    "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit; test:matrix, a different suite covering the full provider capability matrix, runs nightly via .github/workflows/live-matrix.yml — test:providers itself is still only wired into test:live, not any GitHub Actions workflow)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
-    "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",
+    "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run (not wired into any GitHub Actions workflow as of this comment; run manually or add to live-matrix.yml if nightly coverage is needed)": "",
     "test:product": "pnpm run test:media && pnpm run test:tts && pnpm run test:ppt && pnpm run test:proxy",
     "test:performance": "tsx tools/testing/performanceMonitor.ts",
     "// Content Generation (Cross-platform JS)": "",
@@ -224,7 +226,7 @@
     "quality:metrics": "tsx scripts/quality-metrics.ts",
     "quality:report": "pnpm run quality:metrics && echo 'Quality metrics saved to quality-metrics.json'",
     "pre-commit": "lint-staged",
-    "pre-push": "pnpm run validate:commit && pnpm run validate:env && pnpm run validate && pnpm run test:ci",
+    "pre-push": "pnpm run build && pnpm run test:providers-mocked && pnpm run test:provider-structure",
     "check:all": "pnpm run lint && pnpm run format --check && pnpm run validate && pnpm run validate:commit",
     "test:litellm-context": "npx tsx test/continuous-test-suite-litellm-context-windows.ts",
     "test:dedup-execute-map": "npx tsx test/continuous-test-suite-dedup-execute-map.ts",

package/dist/lib/providers/anthropic/utils.d.ts

@@ -1,7 +0,0 @@
-import type { AnthropicAuthMethod, AnthropicRateLimitInfo, ClaudeSubscriptionTier, OAuthToken } from "../../types/index.js";
-export declare const getAnthropicApiKey: () => string;
-export declare const getDefaultAnthropicModel: () => string;
-export declare const getOAuthToken: () => OAuthToken | null;
-export declare const detectSubscriptionTier: (oauthToken: OAuthToken | null) => ClaudeSubscriptionTier;
-export declare const detectAuthMethod: (oauthToken: OAuthToken | null) => AnthropicAuthMethod;
-export declare const parseRateLimitHeaders: (headers: Headers | Record<string, string>) => AnthropicRateLimitInfo;

package/dist/lib/providers/anthropic/utils.js

@@ -1,150 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { AnthropicModels } from "../../constants/enums.js";
-import { logger } from "../../utils/logger.js";
-import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const getAnthropicApiKey = () => {
-    return validateApiKey(createAnthropicConfig());
-};
-export const getDefaultAnthropicModel = () => {
-    return getProviderModel("ANTHROPIC_MODEL", AnthropicModels.CLAUDE_SONNET_4_6);
-};
-export const getOAuthToken = () => {
-    // First, check stored credentials file (highest priority)
-    try {
-        const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
-        if (existsSync(credentialsPath)) {
-            const credentialsContent = readFileSync(credentialsPath, "utf-8");
-            const credentials = JSON.parse(credentialsContent);
-            if (credentials.type === "oauth" && credentials.oauth?.accessToken) {
-                logger.debug("[AnthropicProvider] Using OAuth token from stored credentials file");
-                return credentials.oauth;
-            }
-        }
-    }
-    catch (error) {
-        logger.debug("[AnthropicProvider] Failed to read stored credentials:", error);
-    }
-    // Fallback to environment variables
-    const tokenString = process.env.ANTHROPIC_OAUTH_TOKEN || process.env.CLAUDE_OAUTH_TOKEN;
-    if (!tokenString) {
-        return null;
-    }
-    // Try to parse as JSON (for full token object with refresh token and expiry)
-    try {
-        const parsed = JSON.parse(tokenString);
-        if (typeof parsed === "object" && parsed.accessToken) {
-            return parsed;
-        }
-        // If it's a simple string in JSON, use it as access token
-        if (typeof parsed === "string") {
-            return { accessToken: parsed };
-        }
-    }
-    catch {
-        // Not JSON, treat as plain access token string
-    }
-    // Treat as plain access token string
-    return { accessToken: tokenString };
-};
-export const detectSubscriptionTier = (oauthToken) => {
-    // Check explicit environment variable first
-    const envTier = process.env.ANTHROPIC_SUBSCRIPTION_TIER?.toLowerCase();
-    if (envTier) {
-        const validTiers = [
-            "free",
-            "pro",
-            "max",
-            "max_5",
-            "max_20",
-            "api",
-        ];
-        if (validTiers.includes(envTier)) {
-            logger.debug("[detectSubscriptionTier] Using environment override", {
-                tier: envTier,
-            });
-            return envTier;
-        }
-        logger.warn("[detectSubscriptionTier] Invalid ANTHROPIC_SUBSCRIPTION_TIER", {
-            value: envTier,
-            validTiers,
-        });
-    }
-    // If using OAuth, default to 'pro' (most common subscription tier)
-    if (oauthToken) {
-        // Check if token scopes indicate tier (future-proofing)
-        const scopes = oauthToken.scopes ?? [];
-        let detectedTier = "pro";
-        if (scopes.includes("max_20")) {
-            detectedTier = "max_20";
-        }
-        else if (scopes.includes("max_5")) {
-            detectedTier = "max_5";
-        }
-        else if (scopes.includes("max")) {
-            detectedTier = "max";
-        }
-        logger.debug("[detectSubscriptionTier] Detected from OAuth token", {
-            tier: detectedTier,
-            scopes,
-        });
-        return detectedTier;
-    }
-    // Default to 'api' for API key authentication
-    logger.debug("[detectSubscriptionTier] No OAuth token, defaulting to API tier");
-    return "api";
-};
-export const detectAuthMethod = (oauthToken) => {
-    // Explicit env var takes highest precedence — allows forcing api_key mode
-    // even when OAuth credentials exist (e.g., when using a proxy that handles auth)
-    const explicit = process.env.ANTHROPIC_AUTH_METHOD?.toLowerCase();
-    if (explicit === "api_key" || explicit === "apikey") {
-        logger.debug("[detectAuthMethod] Forced to api_key by ANTHROPIC_AUTH_METHOD env var");
-        return "api_key";
-    }
-    if (explicit === "oauth") {
-        if (oauthToken) {
-            logger.debug("[detectAuthMethod] Forced to oauth by ANTHROPIC_AUTH_METHOD env var");
-            return "oauth";
-        }
-        logger.warn("[detectAuthMethod] ANTHROPIC_AUTH_METHOD=oauth but no OAuth token found; falling through to auto-detection");
-    }
-    else if (explicit) {
-        logger.warn("[detectAuthMethod] Unrecognized ANTHROPIC_AUTH_METHOD value; falling through to auto-detection", {
-            value: explicit,
-        });
-    }
-    // Auto-detect: OAuth takes precedence if available
-    const method = oauthToken ? "oauth" : "api_key";
-    logger.debug("[detectAuthMethod] Auth method resolved", {
-        method,
-        hasOAuthToken: !!oauthToken,
-    });
-    return method;
-};
-export const parseRateLimitHeaders = (headers) => {
-    const getHeader = (name) => {
-        if (headers instanceof Headers) {
-            return headers.get(name);
-        }
-        return headers[name] || headers[name.toLowerCase()] || null;
-    };
-    const parseNumber = (value) => {
-        if (!value) {
-            return undefined;
-        }
-        const num = parseInt(value, 10);
-        return isNaN(num) ? undefined : num;
-    };
-    return {
-        requestsLimit: parseNumber(getHeader("anthropic-ratelimit-requests-limit")),
-        requestsRemaining: parseNumber(getHeader("anthropic-ratelimit-requests-remaining")),
-        requestsReset: getHeader("anthropic-ratelimit-requests-reset") || undefined,
-        tokensLimit: parseNumber(getHeader("anthropic-ratelimit-tokens-limit")),
-        tokensRemaining: parseNumber(getHeader("anthropic-ratelimit-tokens-remaining")),
-        tokensReset: getHeader("anthropic-ratelimit-tokens-reset") || undefined,
-        retryAfter: parseNumber(getHeader("retry-after")),
-    };
-};
-//# sourceMappingURL=utils.js.map

package/dist/lib/providers/googleAiStudio/utils.d.ts

@@ -1,2 +0,0 @@
-import type { GenAIClient } from "../../types/index.js";
-export declare function createGoogleGenAIClient(apiKey: string): Promise<GenAIClient>;

package/dist/lib/providers/googleAiStudio/utils.js

@@ -1,19 +0,0 @@
-import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
-import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
-export async function createGoogleGenAIClient(apiKey) {
-    const mod = await import("@google/genai");
-    const ctor = mod.GoogleGenAI;
-    if (!ctor) {
-        throw new NeuroLinkError({
-            code: ERROR_CODES.INVALID_CONFIGURATION,
-            message: "@google/genai does not export GoogleGenAI",
-            category: ErrorCategory.CONFIGURATION,
-            severity: ErrorSeverity.CRITICAL,
-            retriable: false,
-            context: { module: "@google/genai", expectedExport: "GoogleGenAI" },
-        });
-    }
-    const Ctor = ctor;
-    return new Ctor({ apiKey });
-}
-//# sourceMappingURL=utils.js.map

package/dist/lib/providers/googleNativeGemini3/constants.d.ts

@@ -1 +0,0 @@
-export declare const GEMINI3_NATIVE_MAX_STEPS = 100;

package/dist/lib/providers/googleNativeGemini3/constants.js

@@ -1,2 +0,0 @@
-export const GEMINI3_NATIVE_MAX_STEPS = 100;
-//# sourceMappingURL=constants.js.map

package/dist/lib/providers/huggingFace/utils.d.ts

@@ -1,2 +0,0 @@
-export declare const getHuggingFaceApiKey: () => string;
-export declare const getDefaultHuggingFaceModel: () => string;

package/dist/lib/providers/huggingFace/utils.js

@@ -1,8 +0,0 @@
-import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const getHuggingFaceApiKey = () => {
-    return validateApiKey(createHuggingFaceConfig());
-};
-export const getDefaultHuggingFaceModel = () => {
-    return getProviderModel("HUGGINGFACE_MODEL", "microsoft/DialoGPT-medium");
-};
-//# sourceMappingURL=utils.js.map

package/dist/lib/providers/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * Provider exports for Vercel AI SDK integration
- * This file centralizes all AI provider classes for easy import and usage
- */
-export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex/index.js";
-export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock/index.js";
-export { AmazonSageMakerProvider as AmazonSageMaker } from "./amazonSagemaker.js";
-export { OpenAIProvider as OpenAI } from "./openAI/index.js";
-export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible/index.js";
-export { AnthropicProvider as AnthropicProvider } from "./anthropic/index.js";
-export { AzureOpenAIProvider } from "./azureOpenai.js";
-export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio/index.js";
-export { HuggingFaceProvider as HuggingFace } from "./huggingFace/index.js";
-export { OllamaProvider as Ollama } from "./ollama/index.js";
-export { MistralProvider as MistralAI } from "./mistral.js";
-export { LiteLLMProvider as LiteLLM } from "./litellm/index.js";
-export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
-export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim/index.js";
-export { LMStudioProvider as LMStudio } from "./lmStudio.js";
-export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";
-export { XaiProvider as Xai } from "./xai.js";
-export { GroqProvider as Groq } from "./groq.js";
-export { CohereProvider as Cohere } from "./cohere.js";
-export { TogetherAIProvider as TogetherAI } from "./togetherAi.js";
-export { FireworksProvider as Fireworks } from "./fireworks.js";
-export { PerplexityProvider as Perplexity } from "./perplexity.js";
-export { CloudflareProvider as Cloudflare } from "./cloudflare.js";
-export { VoyageProvider as Voyage } from "./voyage.js";
-export { JinaProvider as Jina } from "./jina.js";
-export { StabilityProvider as Stability } from "./stability.js";
-export { IdeogramProvider as Ideogram } from "./ideogram.js";
-export { RecraftProvider as Recraft } from "./recraft.js";
-export { ReplicateProvider as Replicate } from "./replicate.js";