@juspay/neurolink 8.26.0 → 8.26.1

package/dist/lib/utils/schemaConversion.js

@@ -2,6 +2,96 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { jsonSchemaToZod } from "json-schema-to-zod";
 import { z } from "zod";
 import { logger } from "./logger.js";
+/**
+ * Inline a JSON Schema by recursively resolving all $ref references.
+ * zodToJsonSchema with 'name' option produces schemas with $ref pointing to definitions.
+ * Some SDKs (like @google/genai) expect flat schemas without $ref.
+ *
+ * This function handles:
+ * - Top-level $ref resolution
+ * - Nested $ref within properties, items, additionalProperties
+ * - $ref within allOf, anyOf, oneOf arrays
+ * - Circular reference detection to prevent infinite loops
+ */
+export function inlineJsonSchema(schema, definitions, visited = new Set()) {
+    // Use definitions from schema if not provided
+    const defs = definitions ||
+        schema.definitions;
+    // Handle $ref at current level
+    if (typeof schema.$ref === "string" &&
+        schema.$ref.startsWith("#/definitions/")) {
+        const defName = schema.$ref.replace("#/definitions/", "");
+        // Prevent circular reference infinite loops
+        if (visited.has(defName)) {
+            logger.debug(`[SCHEMA-INLINE] Circular reference detected for: ${defName}`);
+            // Return a simple object placeholder for circular refs
+            return { type: "object" };
+        }
+        if (defs && defs[defName]) {
+            visited.add(defName);
+            // Recursively inline the resolved definition
+            const resolved = inlineJsonSchema({ ...defs[defName] }, defs, visited);
+            visited.delete(defName);
+            return resolved;
+        }
+    }
+    // Create result without $ref and definitions
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Skip $ref and definitions keys
+        if (key === "$ref" || key === "definitions") {
+            continue;
+        }
+        // Recursively process nested schemas
+        if (key === "properties" && value && typeof value === "object") {
+            const properties = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                if (propSchema && typeof propSchema === "object") {
+                    properties[propName] = inlineJsonSchema(propSchema, defs, visited);
+                }
+                else {
+                    properties[propName] = propSchema;
+                }
+            }
+            result[key] = properties;
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            // Handle array items schema
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => item && typeof item === "object"
+                    ? inlineJsonSchema(item, defs, visited)
+                    : item);
+            }
+            else {
+                result[key] = inlineJsonSchema(value, defs, visited);
+            }
+        }
+        else if (key === "additionalProperties" &&
+            value &&
+            typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else if ((key === "allOf" || key === "anyOf" || key === "oneOf") &&
+            Array.isArray(value)) {
+            // Handle composition schemas
+            result[key] = value.map((item) => item && typeof item === "object"
+                ? inlineJsonSchema(item, defs, visited)
+                : item);
+        }
+        else if (key === "not" && value && typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else if ((key === "if" || key === "then" || key === "else") &&
+            value &&
+            typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
 /**
  * Convert Zod schema to JSON Schema format for Claude AI
  */

package/dist/lib/utils/thinkingConfig.d.ts

@@ -0,0 +1,108 @@
+/**
+ * ThinkingConfig utility functions for constructing thinking configuration objects.
+ *
+ * This module provides helper functions to create thinkingConfig objects consistently
+ * across the codebase, reducing duplication in CLI and providers.
+ */
+/**
+ * ThinkingLevel type for Gemini 3 models
+ */
+export type ThinkingLevel = "minimal" | "low" | "medium" | "high";
+/**
+ * ThinkingConfig interface matching the SDK's expected structure
+ */
+export interface ThinkingConfig {
+    enabled?: boolean;
+    type?: "enabled" | "disabled";
+    /** Token budget for thinking (Anthropic models: 5000-100000) */
+    budgetTokens?: number;
+    /** Thinking level for Gemini 3 models */
+    thinkingLevel?: ThinkingLevel;
+}
+/**
+ * Options for creating a thinkingConfig from CLI-style options
+ */
+export interface CreateThinkingConfigOptions {
+    /** Enable thinking mode */
+    thinking?: boolean;
+    /** Token budget for thinking (defaults to 10000) */
+    thinkingBudget?: number;
+    /** Thinking level for Gemini 3 models */
+    thinkingLevel?: ThinkingLevel;
+}
+/**
+ * Native SDK thinkingConfig structure for Gemini native SDK.
+ */
+export interface NativeThinkingConfig {
+    includeThoughts: boolean;
+    thinkingLevel: ThinkingLevel;
+}
+/**
+ * Default token budget for thinking operations
+ */
+export declare const DEFAULT_THINKING_BUDGET_TOKENS = 10000;
+/**
+ * Default thinking level for Gemini 3 models
+ */
+export declare const DEFAULT_THINKING_LEVEL: ThinkingLevel;
+/**
+ * Creates a thinkingConfig object from CLI-style options.
+ *
+ * This helper consolidates the pattern used in CLI command handlers
+ * to convert simple CLI flags into the full thinkingConfig structure.
+ *
+ * @param options - CLI-style options with thinking, thinkingBudget, thinkingLevel
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * // From CLI options
+ * const config = createThinkingConfig({
+ *   thinking: true,
+ *   thinkingBudget: 15000,
+ *   thinkingLevel: "high"
+ * });
+ * // Returns: { enabled: true, budgetTokens: 15000, thinkingLevel: "high" }
+ * ```
+ */
+export declare function createThinkingConfig(options: CreateThinkingConfigOptions): ThinkingConfig | undefined;
+/**
+ * Creates a thinkingConfig from record-style options (useful for CLI handlers).
+ *
+ * This handles the type casting that's commonly needed when working with
+ * CLI argument records.
+ *
+ * @param options - Record-style options from CLI argv
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * const config = createThinkingConfigFromRecord(argv as Record<string, unknown>);
+ * ```
+ */
+export declare function createThinkingConfigFromRecord(options: Record<string, unknown>): ThinkingConfig | undefined;
+/**
+ * Creates thinkingConfig for native Gemini SDK (not AI SDK).
+ *
+ * This is used for direct calls to the Gemini SDK where the config
+ * structure is different from the AI SDK providerOptions.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns NativeThinkingConfig object or undefined
+ *
+ * @example
+ * ```typescript
+ * const nativeConfig = createNativeThinkingConfig(options.thinkingConfig);
+ * if (nativeConfig) {
+ *   sdkConfig.thinkingConfig = nativeConfig;
+ * }
+ * ```
+ */
+export declare function createNativeThinkingConfig(config: ThinkingConfig | undefined): NativeThinkingConfig | undefined;
+/**
+ * Checks if thinkingConfig should be applied based on options.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns true if thinking should be enabled
+ */
+export declare function shouldEnableThinking(config: ThinkingConfig | undefined): boolean;

package/dist/lib/utils/thinkingConfig.js

@@ -0,0 +1,105 @@
+/**
+ * ThinkingConfig utility functions for constructing thinking configuration objects.
+ *
+ * This module provides helper functions to create thinkingConfig objects consistently
+ * across the codebase, reducing duplication in CLI and providers.
+ */
+/**
+ * Default token budget for thinking operations
+ */
+export const DEFAULT_THINKING_BUDGET_TOKENS = 10000;
+/**
+ * Default thinking level for Gemini 3 models
+ */
+export const DEFAULT_THINKING_LEVEL = "high";
+/**
+ * Creates a thinkingConfig object from CLI-style options.
+ *
+ * This helper consolidates the pattern used in CLI command handlers
+ * to convert simple CLI flags into the full thinkingConfig structure.
+ *
+ * @param options - CLI-style options with thinking, thinkingBudget, thinkingLevel
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * // From CLI options
+ * const config = createThinkingConfig({
+ *   thinking: true,
+ *   thinkingBudget: 15000,
+ *   thinkingLevel: "high"
+ * });
+ * // Returns: { enabled: true, budgetTokens: 15000, thinkingLevel: "high" }
+ * ```
+ */
+export function createThinkingConfig(options) {
+    // Only create config if thinking is explicitly enabled or thinkingLevel is set
+    if (!options.thinking && !options.thinkingLevel) {
+        return undefined;
+    }
+    return {
+        enabled: true,
+        budgetTokens: options.thinkingBudget ?? DEFAULT_THINKING_BUDGET_TOKENS,
+        thinkingLevel: options.thinkingLevel,
+    };
+}
+/**
+ * Creates a thinkingConfig from record-style options (useful for CLI handlers).
+ *
+ * This handles the type casting that's commonly needed when working with
+ * CLI argument records.
+ *
+ * @param options - Record-style options from CLI argv
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * const config = createThinkingConfigFromRecord(argv as Record<string, unknown>);
+ * ```
+ */
+export function createThinkingConfigFromRecord(options) {
+    const thinking = options.thinking;
+    const thinkingLevel = options.thinkingLevel;
+    const thinkingBudget = options.thinkingBudget;
+    return createThinkingConfig({
+        thinking,
+        thinkingLevel,
+        thinkingBudget,
+    });
+}
+/**
+ * Creates thinkingConfig for native Gemini SDK (not AI SDK).
+ *
+ * This is used for direct calls to the Gemini SDK where the config
+ * structure is different from the AI SDK providerOptions.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns NativeThinkingConfig object or undefined
+ *
+ * @example
+ * ```typescript
+ * const nativeConfig = createNativeThinkingConfig(options.thinkingConfig);
+ * if (nativeConfig) {
+ *   sdkConfig.thinkingConfig = nativeConfig;
+ * }
+ * ```
+ */
+export function createNativeThinkingConfig(config) {
+    if (!config?.enabled && !config?.thinkingLevel) {
+        return undefined;
+    }
+    return {
+        includeThoughts: true,
+        thinkingLevel: config.thinkingLevel ?? DEFAULT_THINKING_LEVEL,
+    };
+}
+/**
+ * Checks if thinkingConfig should be applied based on options.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns true if thinking should be enabled
+ */
+export function shouldEnableThinking(config) {
+    return Boolean(config?.enabled || config?.thinkingLevel);
+}
+//# sourceMappingURL=thinkingConfig.js.map

package/dist/lib/utils/tokenUtils.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Centralized token usage extraction utilities
+ * Handles multiple provider formats and optional fields
+ *
+ * Consolidates token extraction logic from:
+ * - GenerationHandler.ts
+ * - analytics.ts
+ * - streamAnalytics.ts
+ */
+import type { TokenUsage } from "../types/analytics.js";
+/**
+ * Raw usage object that may come from various AI providers
+ * Supports multiple naming conventions and nested structures
+ */
+export interface RawUsageObject {
+    input?: number;
+    output?: number;
+    total?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    reasoningTokens?: number;
+    reasoning?: number;
+    reasoning_tokens?: number;
+    thinkingTokens?: number;
+    usage?: RawUsageObject;
+}
+/**
+ * Options for token extraction behavior
+ */
+export interface TokenExtractionOptions {
+    /**
+     * Whether to calculate cache savings percentage
+     * @default true
+     */
+    calculateCacheSavings?: boolean;
+    /**
+     * How to handle missing optional fields
+     * - "zero": Return 0 for missing optional fields
+     * - "undefined": Return undefined for missing optional fields (default)
+     */
+    missingOptionalBehavior?: "zero" | "undefined";
+}
+/**
+ * Extract input token count from various provider formats
+ * Priority: input > inputTokens > promptTokens
+ */
+export declare function extractInputTokens(usage: RawUsageObject): number;
+/**
+ * Extract output token count from various provider formats
+ * Priority: output > outputTokens > completionTokens
+ */
+export declare function extractOutputTokens(usage: RawUsageObject): number;
+/**
+ * Extract total token count from various provider formats
+ * Falls back to input + output if total is not provided
+ */
+export declare function extractTotalTokens(usage: RawUsageObject, input: number, output: number): number;
+/**
+ * Extract reasoning/thinking token count from various provider formats
+ * Supports: reasoningTokens, thinkingTokens, reasoning_tokens, reasoning
+ */
+export declare function extractReasoningTokens(usage: RawUsageObject): number | undefined;
+/**
+ * Extract cache creation token count from various provider formats
+ * Supports: cacheCreationInputTokens, cacheCreationTokens
+ */
+export declare function extractCacheCreationTokens(usage: RawUsageObject): number | undefined;
+/**
+ * Extract cache read token count from various provider formats
+ * Supports: cacheReadInputTokens, cacheReadTokens
+ */
+export declare function extractCacheReadTokens(usage: RawUsageObject): number | undefined;
+/**
+ * Calculate cache savings percentage
+ *
+ * This represents the percentage of input tokens served from cache.
+ * For Anthropic, cache read tokens cost 0.1x, so actual cost savings = cacheSavingsPercent * 0.9
+ * For other providers, cost savings may vary based on their cache pricing.
+ *
+ * @param cacheReadTokens Number of tokens read from cache
+ * @param inputTokens Number of non-cached input tokens
+ * @returns Percentage of tokens served from cache (0-100), or undefined if no cache usage
+ */
+export declare function calculateCacheSavingsPercent(cacheReadTokens: number | undefined, inputTokens: number): number | undefined;
+/**
+ * Extract token usage from various provider response formats
+ *
+ * Handles multiple input formats:
+ * - BaseProvider normalized format (input/output/total)
+ * - AI SDK format (inputTokens/outputTokens/totalTokens)
+ * - OpenAI/Mistral format (promptTokens/completionTokens)
+ * - Nested usage objects
+ *
+ * Also extracts optional fields:
+ * - Cache creation and read tokens (Anthropic-style)
+ * - Reasoning/thinking tokens (OpenAI o1, Anthropic, Google)
+ * - Cache savings percentage
+ *
+ * @param result Raw usage object from provider response
+ * @param options Extraction options
+ * @returns Normalized TokenUsage object
+ */
+export declare function extractTokenUsage(result: RawUsageObject | undefined | null, options?: TokenExtractionOptions): TokenUsage;
+/**
+ * Create a default/empty TokenUsage object
+ * Useful for error handling and fallback scenarios
+ */
+export declare function createEmptyTokenUsage(): TokenUsage;
+/**
+ * Check if a TokenUsage object has any non-zero values
+ */
+export declare function hasTokenUsage(usage: TokenUsage): boolean;
+/**
+ * Merge two TokenUsage objects by summing their values
+ * Useful for aggregating usage across multiple calls
+ */
+export declare function mergeTokenUsage(a: TokenUsage, b: TokenUsage): TokenUsage;

package/dist/lib/utils/tokenUtils.js

@@ -0,0 +1,240 @@
+/**
+ * Centralized token usage extraction utilities
+ * Handles multiple provider formats and optional fields
+ *
+ * Consolidates token extraction logic from:
+ * - GenerationHandler.ts
+ * - analytics.ts
+ * - streamAnalytics.ts
+ */
+/**
+ * Extract input token count from various provider formats
+ * Priority: input > inputTokens > promptTokens
+ */
+export function extractInputTokens(usage) {
+    if (typeof usage.input === "number") {
+        return usage.input;
+    }
+    if (typeof usage.inputTokens === "number") {
+        return usage.inputTokens;
+    }
+    if (typeof usage.promptTokens === "number") {
+        return usage.promptTokens;
+    }
+    return 0;
+}
+/**
+ * Extract output token count from various provider formats
+ * Priority: output > outputTokens > completionTokens
+ */
+export function extractOutputTokens(usage) {
+    if (typeof usage.output === "number") {
+        return usage.output;
+    }
+    if (typeof usage.outputTokens === "number") {
+        return usage.outputTokens;
+    }
+    if (typeof usage.completionTokens === "number") {
+        return usage.completionTokens;
+    }
+    return 0;
+}
+/**
+ * Extract total token count from various provider formats
+ * Falls back to input + output if total is not provided
+ */
+export function extractTotalTokens(usage, input, output) {
+    if (typeof usage.total === "number") {
+        return usage.total;
+    }
+    if (typeof usage.totalTokens === "number") {
+        return usage.totalTokens;
+    }
+    return input + output;
+}
+/**
+ * Extract reasoning/thinking token count from various provider formats
+ * Supports: reasoningTokens, thinkingTokens, reasoning_tokens, reasoning
+ */
+export function extractReasoningTokens(usage) {
+    if (typeof usage.reasoningTokens === "number" && usage.reasoningTokens > 0) {
+        return usage.reasoningTokens;
+    }
+    if (typeof usage.thinkingTokens === "number" && usage.thinkingTokens > 0) {
+        return usage.thinkingTokens;
+    }
+    if (typeof usage.reasoning_tokens === "number" &&
+        usage.reasoning_tokens > 0) {
+        return usage.reasoning_tokens;
+    }
+    if (typeof usage.reasoning === "number" && usage.reasoning > 0) {
+        return usage.reasoning;
+    }
+    return undefined;
+}
+/**
+ * Extract cache creation token count from various provider formats
+ * Supports: cacheCreationInputTokens, cacheCreationTokens
+ */
+export function extractCacheCreationTokens(usage) {
+    if (typeof usage.cacheCreationInputTokens === "number" &&
+        usage.cacheCreationInputTokens > 0) {
+        return usage.cacheCreationInputTokens;
+    }
+    if (typeof usage.cacheCreationTokens === "number" &&
+        usage.cacheCreationTokens > 0) {
+        return usage.cacheCreationTokens;
+    }
+    return undefined;
+}
+/**
+ * Extract cache read token count from various provider formats
+ * Supports: cacheReadInputTokens, cacheReadTokens
+ */
+export function extractCacheReadTokens(usage) {
+    if (typeof usage.cacheReadInputTokens === "number" &&
+        usage.cacheReadInputTokens > 0) {
+        return usage.cacheReadInputTokens;
+    }
+    if (typeof usage.cacheReadTokens === "number" && usage.cacheReadTokens > 0) {
+        return usage.cacheReadTokens;
+    }
+    return undefined;
+}
+/**
+ * Calculate cache savings percentage
+ *
+ * This represents the percentage of input tokens served from cache.
+ * For Anthropic, cache read tokens cost 0.1x, so actual cost savings = cacheSavingsPercent * 0.9
+ * For other providers, cost savings may vary based on their cache pricing.
+ *
+ * @param cacheReadTokens Number of tokens read from cache
+ * @param inputTokens Number of non-cached input tokens
+ * @returns Percentage of tokens served from cache (0-100), or undefined if no cache usage
+ */
+export function calculateCacheSavingsPercent(cacheReadTokens, inputTokens) {
+    if (cacheReadTokens === undefined || cacheReadTokens <= 0) {
+        return undefined;
+    }
+    const totalInputWithCache = inputTokens + cacheReadTokens;
+    if (totalInputWithCache <= 0) {
+        return undefined;
+    }
+    return Math.round((cacheReadTokens / totalInputWithCache) * 100);
+}
+/**
+ * Extract token usage from various provider response formats
+ *
+ * Handles multiple input formats:
+ * - BaseProvider normalized format (input/output/total)
+ * - AI SDK format (inputTokens/outputTokens/totalTokens)
+ * - OpenAI/Mistral format (promptTokens/completionTokens)
+ * - Nested usage objects
+ *
+ * Also extracts optional fields:
+ * - Cache creation and read tokens (Anthropic-style)
+ * - Reasoning/thinking tokens (OpenAI o1, Anthropic, Google)
+ * - Cache savings percentage
+ *
+ * @param result Raw usage object from provider response
+ * @param options Extraction options
+ * @returns Normalized TokenUsage object
+ */
+export function extractTokenUsage(result, options = {}) {
+    const { calculateCacheSavings = true, missingOptionalBehavior = "undefined", } = options;
+    // Handle null/undefined input
+    if (!result) {
+        return { input: 0, output: 0, total: 0 };
+    }
+    // Handle nested usage object (some providers wrap usage in a usage property)
+    const usage = result.usage && typeof result.usage === "object" ? result.usage : result;
+    // Extract base token counts
+    const input = extractInputTokens(usage);
+    const output = extractOutputTokens(usage);
+    const total = extractTotalTokens(usage, input, output);
+    // Extract optional token fields
+    const reasoning = extractReasoningTokens(usage);
+    const cacheCreationTokens = extractCacheCreationTokens(usage);
+    const cacheReadTokens = extractCacheReadTokens(usage);
+    // Calculate cache savings if enabled
+    const cacheSavingsPercent = calculateCacheSavings
+        ? calculateCacheSavingsPercent(cacheReadTokens, input)
+        : undefined;
+    // Build result object
+    const tokenUsage = {
+        input,
+        output,
+        total,
+    };
+    // Add optional fields based on behavior setting
+    if (missingOptionalBehavior === "zero") {
+        tokenUsage.cacheCreationTokens = cacheCreationTokens ?? 0;
+        tokenUsage.cacheReadTokens = cacheReadTokens ?? 0;
+        tokenUsage.reasoning = reasoning ?? 0;
+        tokenUsage.cacheSavingsPercent = cacheSavingsPercent ?? 0;
+    }
+    else {
+        // Only include optional fields if they have values
+        if (cacheCreationTokens !== undefined) {
+            tokenUsage.cacheCreationTokens = cacheCreationTokens;
+        }
+        if (cacheReadTokens !== undefined) {
+            tokenUsage.cacheReadTokens = cacheReadTokens;
+        }
+        if (reasoning !== undefined) {
+            tokenUsage.reasoning = reasoning;
+        }
+        if (cacheSavingsPercent !== undefined) {
+            tokenUsage.cacheSavingsPercent = cacheSavingsPercent;
+        }
+    }
+    return tokenUsage;
+}
+/**
+ * Create a default/empty TokenUsage object
+ * Useful for error handling and fallback scenarios
+ */
+export function createEmptyTokenUsage() {
+    return {
+        input: 0,
+        output: 0,
+        total: 0,
+    };
+}
+/**
+ * Check if a TokenUsage object has any non-zero values
+ */
+export function hasTokenUsage(usage) {
+    return usage.input > 0 || usage.output > 0 || usage.total > 0;
+}
+/**
+ * Merge two TokenUsage objects by summing their values
+ * Useful for aggregating usage across multiple calls
+ */
+export function mergeTokenUsage(a, b) {
+    const merged = {
+        input: a.input + b.input,
+        output: a.output + b.output,
+        total: a.total + b.total,
+    };
+    // Merge optional fields if present in either
+    const cacheCreationTokens = (a.cacheCreationTokens ?? 0) + (b.cacheCreationTokens ?? 0);
+    const cacheReadTokens = (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0);
+    const reasoning = (a.reasoning ?? 0) + (b.reasoning ?? 0);
+    if (cacheCreationTokens > 0) {
+        merged.cacheCreationTokens = cacheCreationTokens;
+    }
+    if (cacheReadTokens > 0) {
+        merged.cacheReadTokens = cacheReadTokens;
+    }
+    if (reasoning > 0) {
+        merged.reasoning = reasoning;
+    }
+    // Recalculate cache savings for merged usage
+    const cacheSavingsPercent = calculateCacheSavingsPercent(merged.cacheReadTokens, merged.input);
+    if (cacheSavingsPercent !== undefined) {
+        merged.cacheSavingsPercent = cacheSavingsPercent;
+    }
+    return merged;
+}
+//# sourceMappingURL=tokenUtils.js.map