@juspay/neurolink 9.54.6 → 9.54.7

package/dist/evaluation/ragasEvaluator.js

@@ -2,6 +2,8 @@ import { AIProviderFactory } from "../core/factory.js";
 import { PromptBuilder } from "./prompts.js";
 import { logger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 /**
  * Implements a RAGAS-style evaluator that uses a "judge" LLM to score the
  * quality of an AI response based on rich, contextual information.
@@ -33,45 +35,60 @@ export class RAGASEvaluator {
      * @returns A promise that resolves to a detailed `EvaluationResult`.
      */
     async evaluate(context) {
-        const span = SpanSerializer.createSpan(SpanType.EVALUATION, "evaluation.ragas", {
-            "evaluation.dimension": "relevance|accuracy|completeness",
-            "ai.provider": this.providerName,
-            "ai.model": this.evaluationModel,
-        });
-        const startTime = Date.now();
-        try {
-            const prompt = this.promptBuilder.buildEvaluationPrompt(context, this.promptGenerator);
-            const provider = await AIProviderFactory.createProvider(this.providerName, this.evaluationModel);
-            const result = await provider.generate({
-                input: { text: prompt },
+        return withSpan({
+            name: "neurolink.evaluation.ragas",
+            tracer: tracers.sdk,
+            attributes: {
+                "evaluation.provider": this.providerName,
+                "evaluation.model": this.evaluationModel,
+            },
+        }, async (otelSpan) => {
+            const span = SpanSerializer.createSpan(SpanType.EVALUATION, "evaluation.ragas", {
+                "evaluation.dimension": "relevance|accuracy|completeness",
+                "ai.provider": this.providerName,
+                "ai.model": this.evaluationModel,
             });
-            if (!result) {
-                throw new Error("Evaluation generation failed to return a result.");
+            const startTime = Date.now();
+            try {
+                const prompt = this.promptBuilder.buildEvaluationPrompt(context, this.promptGenerator);
+                const provider = await AIProviderFactory.createProvider(this.providerName, this.evaluationModel);
+                const result = await provider.generate({
+                    input: { text: prompt },
+                });
+                if (!result) {
+                    throw new Error("Evaluation generation failed to return a result.");
+                }
+                const rawEvaluationResponse = result.content;
+                const parsedResult = this.parseEvaluationResponse(rawEvaluationResponse);
+                const evaluationTime = Date.now() - startTime;
+                const finalResult = {
+                    ...parsedResult,
+                    isPassing: parsedResult.finalScore >= this.threshold, // This will be recalculated, but is needed for the type
+                    evaluationModel: this.evaluationModel,
+                    evaluationTime,
+                    attemptNumber: context.attemptNumber,
+                    rawEvaluationResponse,
+                };
+                // Write evaluation scores to OTel span for Langfuse visibility
+                otelSpan.setAttribute("evaluation.relevance_score", finalResult.relevanceScore);
+                otelSpan.setAttribute("evaluation.accuracy_score", finalResult.accuracyScore);
+                otelSpan.setAttribute("evaluation.completeness_score", finalResult.completenessScore);
+                otelSpan.setAttribute("evaluation.final_score", finalResult.finalScore);
+                otelSpan.setAttribute("evaluation.is_passing", finalResult.isPassing);
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return finalResult;
             }
-            const rawEvaluationResponse = result.content;
-            const parsedResult = this.parseEvaluationResponse(rawEvaluationResponse);
-            const evaluationTime = Date.now() - startTime;
-            const finalResult = {
-                ...parsedResult,
-                isPassing: parsedResult.finalScore >= this.threshold, // This will be recalculated, but is needed for the type
-                evaluationModel: this.evaluationModel,
-                evaluationTime,
-                attemptNumber: context.attemptNumber,
-                rawEvaluationResponse,
-            };
-            span.durationMs = Date.now() - startTime;
-            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-            getMetricsAggregator().recordSpan(endedSpan);
-            return finalResult;
-        }
-        catch (error) {
-            span.durationMs = Date.now() - startTime;
-            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
-            endedSpan.statusMessage =
-                error instanceof Error ? error.message : String(error);
-            getMetricsAggregator().recordSpan(endedSpan);
-            throw error;
-        }
+            catch (error) {
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+                endedSpan.statusMessage =
+                    error instanceof Error ? error.message : String(error);
+                getMetricsAggregator().recordSpan(endedSpan);
+                throw error;
+            }
+        }); // end withSpan
     }
     /**
      * Parses the raw JSON string from the judge LLM into a structured `EvaluationResult` object.

package/dist/evaluation/reporting/metricsCollector.d.ts

@@ -2,65 +2,7 @@
  * @file Metrics Collector
  * Collect and aggregate evaluation metrics
  */
-import type { ScoreResult, PipelineResult } from "../../types/index.js";
-/**
- * Scorer metrics
- */
-type ScorerMetrics = {
-    scorerId: string;
-    scorerName: string;
-    totalExecutions: number;
-    successfulExecutions: number;
-    failedExecutions: number;
-    passedCount: number;
-    failedCount: number;
-    totalScore: number;
-    minScore: number;
-    maxScore: number;
-    totalDuration: number;
-    averageDuration: number;
-    averageScore: number;
-    passRate: number;
-    lastExecutionTime: number;
-};
-/**
- * Pipeline metrics
- */
-type PipelineMetrics = {
-    pipelineName: string;
-    totalExecutions: number;
-    passedCount: number;
-    failedCount: number;
-    totalScore: number;
-    minScore: number;
-    maxScore: number;
-    totalDuration: number;
-    averageDuration: number;
-    averageScore: number;
-    passRate: number;
-    lastExecutionTime: number;
-    scorerMetrics: Map<string, ScorerMetrics>;
-};
-/**
- * Aggregated metrics
- */
-type AggregatedMetrics = {
-    totalEvaluations: number;
-    overallPassRate: number;
-    averageScore: number;
-    averageDuration: number;
-    scoreDistribution: {
-        excellent: number;
-        good: number;
-        fair: number;
-        poor: number;
-        failing: number;
-    };
-    pipelineMetrics: Map<string, PipelineMetrics>;
-    scorerMetrics: Map<string, ScorerMetrics>;
-    collectionStartTime: number;
-    lastUpdateTime: number;
-};
+import type { AggregatedMetrics, PipelineMetrics, PipelineResult, ScoreResult, ScorerMetrics } from "../../types/index.js";
 /**
  * Metrics collector for evaluation data
  */
@@ -144,4 +86,3 @@ export declare function createMetricsCollector(): MetricsCollector;
  * Global metrics collector instance
  */
 export declare const globalMetricsCollector: MetricsCollector;
-export {};

package/dist/evaluation/reporting/reportGenerator.d.ts

@@ -2,22 +2,7 @@
  * @file Report Generator
  * Generate evaluation reports in various formats
  */
-import type { ReportData, ReportConfig, ReportFormat } from "../../types/index.js";
-/**
- * Generated report
- */
-type GeneratedReport = {
-    /** Report format */
-    format: ReportFormat;
-    /** Report content */
-    content: string;
-    /** Metadata */
-    metadata: {
-        generatedAt: number;
-        format: ReportFormat;
-        config: ReportConfig;
-    };
-};
+import type { GeneratedReport, ReportConfig, ReportData } from "../../types/index.js";
 /**
  * Report generator class
  */
@@ -70,4 +55,3 @@ export declare const Reports: {
     /** Generate HTML report */
     html: (data: ReportData) => GeneratedReport;
 };
-export {};

package/dist/evaluation/scorers/rule/contentSimilarityScorer.d.ts

@@ -2,35 +2,8 @@
  * @file Content Similarity Scorer
  * Evaluates text similarity using various metrics (Jaccard, cosine, Levenshtein)
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput } from "../../../types/index.js";
+import type { ContentSimilarityConfig, ScoreResult, ScorerInput } from "../../../types/index.js";
 import { BaseScorer } from "../baseScorer.js";
-/**
- * Similarity metric types
- */
-type SimilarityMetric = "jaccard" | "cosine" | "levenshtein" | "dice" | "overlap";
-/**
- * Configuration specific to content similarity scoring
- */
-type ContentSimilarityConfig = RuleScorerConfig & {
-    /** Similarity metric to use */
-    metric?: SimilarityMetric;
-    /** Multiple metrics to combine */
-    metrics?: SimilarityMetric[];
-    /** How to combine multiple metrics */
-    metricCombination?: "average" | "min" | "max" | "weighted";
-    /** Weights for each metric (if weighted combination) */
-    metricWeights?: Record<SimilarityMetric, number>;
-    /** Whether to normalize text before comparison */
-    normalizeText?: boolean;
-    /** Whether to use word-level or character-level comparison */
-    tokenLevel?: "word" | "character" | "ngram";
-    /** N-gram size if using ngram tokenization */
-    ngramSize?: number;
-    /** Compare against ground truth, context, or custom reference */
-    compareWith?: "groundTruth" | "context" | "custom";
-    /** Custom reference text if compareWith is "custom" */
-    referenceText?: string;
-};
 /**
  * ContentSimilarityScorer evaluates how similar the response is to a reference text
  */
@@ -106,4 +79,3 @@ export declare class ContentSimilarityScorer extends BaseScorer {
  * Factory function for creating ContentSimilarityScorer instances
  */
 export declare function createContentSimilarityScorer(config?: ContentSimilarityConfig): Promise<ContentSimilarityScorer>;
-export {};

package/dist/evaluation/scorers/rule/formatScorer.d.ts

@@ -2,48 +2,8 @@
  * @file Format Scorer
  * Evaluates response format compliance (JSON, markdown, code, etc.)
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { FormatScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Expected format types
- */
-type FormatType = "json" | "markdown" | "code" | "list" | "numbered-list" | "bullet-list" | "table" | "yaml" | "xml" | "plain" | "html" | "custom";
-/**
- * Code language types for code format validation
- */
-type CodeLanguage = "javascript" | "typescript" | "python" | "java" | "c" | "cpp" | "csharp" | "go" | "rust" | "sql" | "bash" | "any";
-/**
- * Configuration specific to format scoring
- */
-type FormatScorerConfig = RuleScorerConfig & {
-    /** Expected format type */
-    expectedFormat?: FormatType;
-    /** Multiple allowed formats */
-    allowedFormats?: FormatType[];
-    /** For code format: expected language */
-    codeLanguage?: CodeLanguage;
-    /** For JSON format: validate against schema */
-    jsonSchema?: object;
-    /** For markdown: required elements */
-    markdownRequirements?: {
-        hasHeadings?: boolean;
-        hasCodeBlocks?: boolean;
-        hasLinks?: boolean;
-        hasLists?: boolean;
-        minHeadingLevel?: number;
-        maxHeadingLevel?: number;
-    };
-    /** For list format: requirements */
-    listRequirements?: {
-        minItems?: number;
-        maxItems?: number;
-        itemPattern?: string;
-    };
-    /** Custom format regex pattern */
-    customPattern?: string;
-    /** Whether format must be exclusive (no other content) */
-    strictFormat?: boolean;
-};
 /**
  * FormatScorer evaluates response format against expected formats
  */
@@ -145,4 +105,3 @@ export declare const FormatScorerPresets: {
     /** Plain text only */
     readonly plainText: () => FormatScorer;
 };
-export {};

package/dist/evaluation/scorers/rule/keywordCoverageScorer.d.ts

@@ -2,25 +2,8 @@
  * @file Keyword Coverage Scorer
  * Evaluates how well the response covers expected keywords or topics
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { KeywordCoverageConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Configuration specific to keyword coverage scoring
- */
-type KeywordCoverageConfig = RuleScorerConfig & {
-    /** Keywords to check for */
-    keywords?: string[];
-    /** Minimum coverage ratio (0-1) to pass */
-    minCoverage?: number;
-    /** Whether to use case-insensitive matching */
-    caseInsensitive?: boolean;
-    /** Whether to use word boundary matching */
-    wordBoundary?: boolean;
-    /** Synonyms map for flexible matching */
-    synonyms?: Record<string, string[]>;
-    /** Weight different keywords differently */
-    keywordWeights?: Record<string, number>;
-};
 /**
  * KeywordCoverageScorer evaluates how well a response covers expected keywords
  */
@@ -81,4 +64,3 @@ export declare class KeywordCoverageScorer extends BaseRuleScorer {
  * Factory function for creating KeywordCoverageScorer instances
  */
 export declare function createKeywordCoverageScorer(config?: KeywordCoverageConfig): Promise<KeywordCoverageScorer>;
-export {};

package/dist/evaluation/scorers/rule/lengthScorer.d.ts

@@ -2,39 +2,8 @@
  * @file Length Scorer
  * Evaluates response length against configured constraints
  */
-import type { RuleScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
+import type { LengthScorerConfig, ScoreResult, ScorerInput, ScorerRule } from "../../../types/index.js";
 import { BaseRuleScorer } from "./baseRuleScorer.js";
-/**
- * Length measurement unit
- */
-type LengthUnit = "words" | "characters" | "sentences" | "paragraphs" | "tokens";
-/**
- * Length constraint type
- */
-type LengthConstraintType = "exact" | "range" | "minimum" | "maximum" | "ratio";
-/**
- * Configuration specific to length scoring
- */
-type LengthScorerConfig = RuleScorerConfig & {
-    /** Unit of measurement */
-    unit?: LengthUnit;
-    /** Constraint type */
-    constraintType?: LengthConstraintType;
-    /** Minimum length (for range/minimum constraints) */
-    minLength?: number;
-    /** Maximum length (for range/maximum constraints) */
-    maxLength?: number;
-    /** Exact length (for exact constraint) */
-    exactLength?: number;
-    /** Tolerance for exact length (as percentage) */
-    tolerance?: number;
-    /** Compare ratio with query/context length */
-    ratioTarget?: number;
-    /** Ratio reference: compare against query or context */
-    ratioReference?: "query" | "context";
-    /** Scoring mode: binary (pass/fail) or proportional */
-    scoringMode?: "binary" | "proportional";
-};
 /**
  * LengthScorer evaluates response length against configurable constraints
  */
@@ -103,4 +72,3 @@ export declare const LengthScorerPresets: {
     /** Tweet-length (max 280 characters) */
     readonly tweet: () => LengthScorer;
 };
-export {};

package/dist/factories/providerFactory.d.ts

@@ -1,19 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { UnknownRecord, AIProvider, NeurolinkCredentials } from "../types/index.js";
-/**
- * Provider constructor interface - supports both sync constructors and async factory functions
- */
-type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
-/**
- * Provider registration entry
- */
-type ProviderRegistration = {
-    constructor: ProviderConstructor;
-    defaultModel?: string;
-    aliases?: string[];
-};
+import type { AIProvider, NeurolinkCredentials, ProviderConstructor, ProviderRegistration, UnknownRecord } from "../types/index.js";
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements
@@ -72,4 +58,3 @@ export declare class ProviderFactory {
  * Helper function to create providers with backward compatibility
  */
 export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
-export {};

package/dist/factories/providerFactory.js

@@ -1,4 +1,6 @@
 import { logger } from "../utils/logger.js";
+// Pure factory pattern with no hardcoded imports
+// All providers loaded dynamically via registry to avoid circular dependencies
 /**
  * True Factory Pattern implementation for AI Providers
  * Uses registration-based approach to eliminate switch statements

package/dist/image-gen/ImageGenService.d.ts

@@ -26,6 +26,9 @@
  * ```
  */
 import type { ImageGenConfig, ImageGenOptions, ImageGenResult } from "../types/index.js";
+/**
+ * NeuroLink instance type (avoiding circular dependencies)
+ */
 /**
  * Image generation service for AI-powered image creation
  *

package/dist/image-gen/ImageGenService.js

@@ -27,6 +27,9 @@
  */
 import { withTimeout } from "../utils/errorHandling.js";
 import { DEFAULT_IMAGE_GEN_CONFIG } from "../types/index.js";
+/**
+ * NeuroLink instance type (avoiding circular dependencies)
+ */
 /**
  * Image generation service for AI-powered image creation
  *

package/dist/lib/action/actionInputs.d.ts

@@ -2,7 +2,7 @@
  * GitHub Action input parsing and validation
  * @module action/actionInputs
  */
-import type { ActionInputs, ActionProviderKeys, ActionInputValidation, ActionAWSConfig, ActionGoogleCloudConfig } from "../types/index.js";
+import type { ActionAWSConfig, ActionGoogleCloudConfig, ActionInputValidation, ActionInputs, ActionProviderKeys } from "../types/index.js";
 /**
  * Mask all secrets in logs
  */

package/dist/lib/adapters/video/directorPipeline.js

@@ -168,6 +168,9 @@ async function readImageFromDisk(filePath, segmentIndex) {
         });
     }
 }
+// ============================================================================
+// PHASE 1: PARALLEL CLIP GENERATION (with circuit breaker)
+// ============================================================================
 /**
  * Process clip completions in order to maintain an accurate consecutive failure count.
  * This prevents out-of-order completions from incorrectly resetting the failure streak.
@@ -307,6 +310,9 @@ async function generateClips(segments, videoOptions, region) {
     });
     return state.results;
 }
+// ============================================================================
+// PHASE 2: PARALLEL TRANSITION GENERATION
+// ============================================================================
 /**
  * Extract boundary frames and generate transition clips in parallel.
  *

package/dist/lib/adapters/video/vertexVideoHandler.js

@@ -437,6 +437,12 @@ export async function generateVideoWithVertex(image, prompt, options = {}, regio
         });
     }
 }
+// ============================================================================
+// POLLING HELPERS
+// ============================================================================
+/**
+ * Vertex AI operation result type for type safety
+ */
 /**
  * Extract video buffer from completed operation result
  *

package/dist/lib/agent/directTools.d.ts

@@ -2,6 +2,7 @@
  * Direct Tool Definitions for NeuroLink CLI Agent
  * Simple, reliable tools that work immediately with Vercel AI SDK
  */
+import type { AllToolsMap, BasicToolsMap, FilesystemToolsMap, UtilityToolsMap } from "../types/index.js";
 /**
  * Direct tool definitions that work immediately with Gemini/AI SDK
  * These bypass MCP complexity and provide reliable agent functionality
@@ -101,7 +102,7 @@ export declare const directAgentTools: {
     writeFile: import("ai").Tool<{
         path: string;
         content: string;
-        mode: "create" | "overwrite" | "append";
+        mode: "append" | "create" | "overwrite";
     }, {
         success: boolean;
         error: string;
@@ -112,7 +113,7 @@ export declare const directAgentTools: {
     } | {
         success: boolean;
         path: string;
-        mode: "create" | "overwrite" | "append";
+        mode: "append" | "create" | "overwrite";
         size: number;
         written: number;
         error?: undefined;
@@ -225,26 +226,6 @@ export declare const bashTool: import("ai").Tool<{
     timeout: number;
     cwd?: string | undefined;
 }, unknown>;
-/**
- * Type aliases for specific tool categories
- */
-type BasicToolsMap = {
-    getCurrentTime: typeof directAgentTools.getCurrentTime;
-    calculateMath: typeof directAgentTools.calculateMath;
-};
-type FilesystemToolsMap = {
-    readFile: typeof directAgentTools.readFile;
-    listDirectory: typeof directAgentTools.listDirectory;
-    writeFile: typeof directAgentTools.writeFile;
-};
-type UtilityToolsMap = {
-    getCurrentTime: typeof directAgentTools.getCurrentTime;
-    calculateMath: typeof directAgentTools.calculateMath;
-    listDirectory: typeof directAgentTools.listDirectory;
-};
-type AllToolsMap = typeof directAgentTools & {
-    executeBashCommand?: typeof bashTool;
-};
 /**
  * Get a subset of tools for specific use cases with improved type safety
  */
@@ -260,4 +241,3 @@ export declare function getAvailableToolNames(): string[];
  * Validate that all tools have proper structure
  */
 export declare function validateToolStructure(): boolean;
-export {};

package/dist/lib/auth/AuthProviderFactory.d.ts

@@ -5,8 +5,7 @@
  * extension, no singleton instance. Providers are registered by
  * AuthProviderRegistry using dynamic imports to avoid circular dependencies.
  */
-import type { AuthProviderConfig, AuthProviderMetadata, MastraAuthProvider } from "../types/index.js";
-type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+import type { AuthProviderConfig, AuthProviderConstructor, AuthProviderMetadata, MastraAuthProvider } from "../types/index.js";
 /**
  * AuthProviderFactory - Creates authentication provider instances
  *
@@ -68,4 +67,3 @@ export declare class AuthProviderFactory {
  * Create an auth provider using the factory
  */
 export declare function createAuthProvider(type: string, config: AuthProviderConfig): Promise<MastraAuthProvider>;
-export {};

package/dist/lib/auth/anthropicOAuth.d.ts

@@ -15,6 +15,7 @@
  * @module auth/anthropicOAuth
  */
 import type { Server } from "http";
+import type { ClaudeCodeIdentity } from "../types/index.js";
 /**
  * Claude Code's official OAuth client ID
  * Used to authenticate with Anthropic's OAuth system
@@ -46,12 +47,6 @@ export declare const DEFAULT_SCOPES: readonly string[];
 export declare const CLAUDE_CODE_VERSION = "2.1.87.6d6";
 export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
 export declare const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.87 (external, sdk-cli)";
-type ClaudeCodeIdentity = {
-    deviceId: string;
-    accountUuid: string;
-    sessionId: string;
-    metadataUserId: string;
-};
 export declare function parseClaudeCodeUserId(userId: unknown): ClaudeCodeIdentity | null;
 export declare function getOrCreateClaudeCodeIdentity(seed: string, options?: {
     existingUserId?: unknown;
@@ -214,6 +209,7 @@ export declare class AnthropicOAuth {
      * ```
      */
     exchangeCodeForTokens(code: string, codeVerifier: string, config?: AnthropicOAuthConfig): Promise<OAuthFlowTokens>;
+    private _exchangeCodeForTokens;
     /**
      * Refreshes an expired access token using a refresh token
      *
@@ -231,6 +227,7 @@ export declare class AnthropicOAuth {
      * ```
      */
     refreshAccessToken(refreshToken: string, config?: AnthropicOAuthConfig): Promise<OAuthFlowTokens>;
+    private _refreshAccessToken;
     /**
      * Validates an access token and returns token information
      *
@@ -268,6 +265,7 @@ export declare class AnthropicOAuth {
      * @throws OAuthTokenRevocationError if revocation fails
      */
     revokeToken(token: string, tokenType?: "access_token" | "refresh_token"): Promise<void>;
+    private _revokeToken;
     /**
      * Build the list of token endpoint URLs to try, with optional fallback.
      *
@@ -400,4 +398,3 @@ export declare function performOAuthFlow(oauth: AnthropicOAuth, options?: {
     /** Whether to automatically open browser (default: true) */
     openBrowser?: boolean;
 }): Promise<OAuthFlowTokens>;
-export {};

package/dist/lib/auth/anthropicOAuth.js

@@ -18,6 +18,8 @@ import { createHash, createHmac, randomBytes, randomUUID } from "crypto";
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { OAuthError, OAuthConfigurationError, OAuthTokenExchangeError, OAuthTokenRefreshError, OAuthTokenRevocationError, OAuthCallbackServerError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 /**
  * HTML-escape a string to prevent XSS when embedding in HTML responses.
  */
@@ -467,6 +469,13 @@ export class AnthropicOAuth {
      * ```
      */
     async exchangeCodeForTokens(code, codeVerifier, config = {}) {
+        return withSpan({
+            name: "neurolink.auth.oauth.exchange_code",
+            tracer: tracers.auth,
+            attributes: { "auth.oauth.grant_type": "authorization_code" },
+        }, async () => this._exchangeCodeForTokens(code, codeVerifier, config));
+    }
+    async _exchangeCodeForTokens(code, codeVerifier, config = {}) {
         if (!code) {
             throw new OAuthTokenExchangeError("Authorization code is required");
         }
@@ -555,6 +564,13 @@ export class AnthropicOAuth {
      * ```
      */
     async refreshAccessToken(refreshToken, config = {}) {
+        return withSpan({
+            name: "neurolink.auth.oauth.refresh",
+            tracer: tracers.auth,
+            attributes: { "auth.oauth.grant_type": "refresh_token" },
+        }, async () => this._refreshAccessToken(refreshToken, config));
+    }
+    async _refreshAccessToken(refreshToken, config = {}) {
         if (!refreshToken) {
             throw new OAuthTokenRefreshError("Refresh token is required");
         }
@@ -751,6 +767,13 @@ export class AnthropicOAuth {
      * @throws OAuthTokenRevocationError if revocation fails
      */
     async revokeToken(token, tokenType = "access_token") {
+        return withSpan({
+            name: "neurolink.auth.oauth.revoke",
+            tracer: tracers.auth,
+            attributes: { "auth.oauth.token_type": tokenType },
+        }, async () => this._revokeToken(token, tokenType));
+    }
+    async _revokeToken(token, tokenType = "access_token") {
         if (!token) {
             throw new OAuthTokenRevocationError("Token is required for revocation");
         }