@juspay/neurolink 9.54.3 → 9.54.5

package/dist/lib/types/{clientTypes.js → client.js}

@@ -8,4 +8,4 @@
  * @module @neurolink/client/types
  */
 export {};
-//# sourceMappingURL=clientTypes.js.map
+//# sourceMappingURL=client.js.map

package/dist/lib/types/common.d.ts

@@ -1,7 +1,7 @@
 /**
  * Common utility types for NeuroLink
  */
-import type { AutoresearchErrorEvent, AutoresearchExperimentCompletedEvent, AutoresearchExperimentStartedEvent, AutoresearchInitializedEvent, AutoresearchMetricImprovedEvent, AutoresearchPhaseChangedEvent, AutoresearchResumedEvent, AutoresearchRevertEvent, AutoresearchRevertFailedEvent, AutoresearchStateUpdatedEvent } from "./autoresearchTypes.js";
+import type { AutoresearchErrorEvent, AutoresearchExperimentCompletedEvent, AutoresearchExperimentStartedEvent, AutoresearchInitializedEvent, AutoresearchMetricImprovedEvent, AutoresearchPhaseChangedEvent, AutoresearchResumedEvent, AutoresearchRevertEvent, AutoresearchRevertFailedEvent, AutoresearchStateUpdatedEvent } from "./autoresearch.js";
 /**
  * Type-safe unknown value - use when type is truly unknown
  */
@@ -80,7 +80,7 @@ export declare function toErrorInfo(error: unknown): ErrorInfo;
 /**
  * Stream event types for real-time communication
  */
-export type StreamEvent = {
+export type InternalStreamEvent = {
     type: "stream:chunk" | "stream:complete" | "stream:error";
     content?: string;
     metadata?: JsonObject;
@@ -193,6 +193,17 @@ export type SafeParseResult<T> = {
     data: T | null;
     error: Error | null;
 };
+/**
+ * Simple retry options for infrastructure-level retry logic.
+ * Named InfraRetryOptions to avoid collision with utilities.ts RetryOptions and
+ * common.ts AsyncRetryOptions.
+ */
+export type InfraRetryOptions = {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs?: number;
+    shouldRetry?: (error: Error) => boolean;
+};
 /**
  * Configuration options for retry operations with exponential backoff.
  * Named AsyncRetryOptions to avoid collision with utilities.ts RetryOptions.
@@ -301,6 +312,8 @@ export type InfraRegistryEntry<TItem, TMetadata = unknown> = {
 /** Error code type (string-based). */
 export type ErrorCode = string;
 import type { z } from "zod";
+import type { TTSOptions, TTSResult, TTSVoice } from "./tts.js";
+import type { SageMakerStreamChunk, SageMakerUsage } from "./providers.js";
 /** Utility functions for tool management. */
 export type ToolUtilities = {
     isZodSchema?: (schema: unknown) => boolean;
@@ -308,3 +321,123 @@ export type ToolUtilities = {
     createPermissiveZodSchema?: () => z.ZodSchema;
     fixSchemaForOpenAIStrictMode?: (schema: Record<string, unknown>) => Record<string, unknown>;
 };
+/**
+ * TTS Handler interface for provider-specific implementations
+ *
+ * Each provider (Google AI, OpenAI, etc.) implements this interface
+ * to provide TTS generation capabilities using their respective APIs.
+ *
+ * **Timeout Handling:**
+ * Implementations MUST handle their own timeouts for the `synthesize()` method.
+ * Recommended timeout: 30 seconds. Implementations should use `withTimeout()` utility
+ * or provider-specific timeout mechanisms (e.g., Google Cloud client timeout).
+ *
+ * **Error Handling:**
+ * Implementations should throw TTSError for all failures, including timeouts.
+ * Use appropriate error codes from TTS_ERROR_CODES.
+ *
+ * @example
+ * ```typescript
+ * class MyTTSHandler implements TTSHandler {
+ *   async synthesize(text: string, options: TTSOptions): Promise<TTSResult> {
+ *     // REQUIRED: Implement timeout handling
+ *     return await withTimeout(
+ *       this.actualSynthesis(text, options),
+ *       30000, // 30 second timeout
+ *       'TTS synthesis timed out'
+ *     );
+ *   }
+ *
+ *   isConfigured(): boolean {
+ *     return !!process.env.MY_TTS_API_KEY;
+ *   }
+ * }
+ * ```
+ */
+export type TTSHandler = {
+    /**
+     * Generate audio from text using provider-specific TTS API
+     *
+     * **IMPORTANT: Timeout Responsibility**
+     * Implementations MUST enforce their own timeouts (recommended: 30 seconds).
+     * Use the `withTimeout()` utility or provider-specific timeout mechanisms.
+     *
+     * @param text - Text to convert to speech (pre-validated, non-empty, within length limits)
+     * @param options - TTS configuration options (voice, format, speed, etc.)
+     * @returns Audio buffer with metadata
+     * @throws {TTSError} On synthesis failure, timeout, or configuration issues
+     */
+    synthesize(text: string, options: TTSOptions): Promise<TTSResult>;
+    /**
+     * Get available voices for the provider
+     *
+     * @param languageCode - Optional language filter (e.g., "en-US")
+     * @returns List of available voices
+     */
+    getVoices?(languageCode?: string): Promise<TTSVoice[]>;
+    /**
+     * Validate that the provider is properly configured
+     *
+     * @returns True if provider can generate TTS
+     */
+    isConfigured(): boolean;
+    /**
+     * Maximum text length supported by this provider (in bytes)
+     * Different providers have different limits
+     *
+     * @default 3000 if not specified
+     */
+    maxTextLength?: number;
+};
+/**
+ * Streaming capability information for an endpoint
+ */
+export type StreamingCapability = {
+    /** Whether streaming is supported */
+    supported: boolean;
+    /** Detected streaming protocol */
+    protocol: "sse" | "jsonl" | "chunked" | "none";
+    /** Detected model framework */
+    modelType: "huggingface" | "llama" | "pytorch" | "tensorflow" | "custom";
+    /** Test endpoint for streaming validation */
+    testEndpoint?: string;
+    /** Required parameters for streaming */
+    parameters?: Record<string, unknown>;
+    /** Confidence level of detection (0-1) */
+    confidence: number;
+    /** Additional metadata about the model */
+    metadata?: {
+        modelName?: string;
+        framework?: string;
+        version?: string;
+        tags?: string[];
+    };
+};
+/**
+ * Shared bracket counting state and utilities
+ * Used by both validateJSONCompleteness and StructuredOutputParser
+ */
+export type BracketCountingState = {
+    braceCount: number;
+    bracketCount: number;
+    inString: boolean;
+    escapeNext: boolean;
+};
+/**
+ * Base interface for streaming response parsers
+ */
+export type StreamingParser = {
+    /** Parse a chunk of streaming data */
+    parse(chunk: Uint8Array): SageMakerStreamChunk[];
+    /** Check if a chunk indicates completion */
+    isComplete(chunk: SageMakerStreamChunk): boolean;
+    /** Extract final usage information */
+    extractUsage(finalChunk: SageMakerStreamChunk): SageMakerUsage | undefined;
+    /** Get parser name for debugging */
+    getName(): string;
+    /** Reset parser state for new stream */
+    reset(): void;
+};
+export type HippocampusMemory = import("@juspay/hippocampus").HippocampusConfig & {
+    enabled?: boolean;
+};

package/dist/{types/configTypes.d.ts → lib/types/config.d.ts}

@@ -3,20 +3,17 @@
  * Centralized configuration type definitions following the established architecture pattern
  */
 import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
-import type { TaskManagerConfig } from "./taskTypes.js";
-import type { HITLConfig } from "../types/hitlTypes.js";
+import type { TaskManagerConfig } from "./task.js";
+import type { HITLConfig } from "../types/hitl.js";
 import type { ConversationMemoryConfig } from "./conversation.js";
 import type { ObservabilityConfig } from "./observability.js";
-import type { RoutingStrategy } from "../mcp/routing/index.js";
-import type { CacheStrategy } from "../mcp/caching/index.js";
-import type { ToolMiddleware } from "../mcp/toolIntegration.js";
-import type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./authTypes.js";
+import type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
 import type { NeurolinkCredentials } from "./providers.js";
 /**
  * Main NeuroLink configuration type
  */
 export type NeuroLinkConfig = {
-    providers?: Record<string, ProviderConfig>;
+    providers?: Record<string, ProviderRuntimeConfig>;
     performance?: PerformanceConfig;
     analytics?: AnalyticsConfig;
     tools?: ToolConfig;
@@ -33,7 +30,7 @@ export type NeurolinkConstructorConfig = {
     hitl?: HITLConfig;
     toolRegistry?: MCPToolRegistry;
     observability?: ObservabilityConfig;
-    modelAliasConfig?: import("./generateTypes.js").ModelAliasConfig;
+    modelAliasConfig?: ModelAliasConfig;
     /** MCP enhancement modules configuration (cache, router, batcher, annotations, middleware) */
     mcp?: MCPEnhancementsConfig;
     /** Authentication provider configuration */
@@ -176,7 +173,7 @@ export type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Authenti
 /**
  * Provider-specific configuration
  */
-export type ProviderConfig = {
+export type ProviderRuntimeConfig = {
     model?: string;
     available?: boolean;
     lastCheck?: number;
@@ -310,6 +307,8 @@ export type ConfigUpdateOptions = {
  */
 export declare const DEFAULT_CONFIG: NeuroLinkConfig;
 import { TOOL_TIMEOUTS, BACKOFF_CONFIG, PERFORMANCE_PROFILES, PROVIDER_OPERATION_CONFIGS, MCP_OPERATION_CONFIGS } from "../constants/index.js";
+import type { ToolMiddleware, CacheStrategy, RoutingStrategy } from "./index.js";
+import type { ModelAliasConfig } from "./generate.js";
 /** Timeout category keys from TOOL_TIMEOUTS. */
 export type TimeoutCategory = keyof typeof TOOL_TIMEOUTS;
 /** Retry strategy keys from BACKOFF_CONFIG. */

package/dist/lib/types/{configTypes.js → config.js}

@@ -51,4 +51,4 @@ export const DEFAULT_CONFIG = {
 // CONSTANTS-DERIVED TYPES (moved from constants/index.ts)
 // =============================================================================
 import { TOOL_TIMEOUTS, BACKOFF_CONFIG, PERFORMANCE_PROFILES, PROVIDER_OPERATION_CONFIGS, MCP_OPERATION_CONFIGS, } from "../constants/index.js";
-//# sourceMappingURL=configTypes.js.map
+//# sourceMappingURL=config.js.map

package/dist/lib/types/{contextTypes.js → context.js}

@@ -398,4 +398,4 @@ export class ContextConverter {
         return customData;
     }
 }
-//# sourceMappingURL=contextTypes.js.map
+//# sourceMappingURL=context.js.map

package/dist/lib/types/conversation.d.ts

@@ -32,8 +32,10 @@
  * - Current time (Unix ms): `Date.now()`
  * - Current time (ISO): `new Date().toISOString()`
  */
-import type { Memory, StorageConfig } from "../memory/hippocampusInitializer.js";
-export type { Memory, StorageConfig };
+import type { HippocampusMemory } from "./common.js";
+import type { ObservabilityConfig } from "./observability.js";
+export type StorageConfig = import("@juspay/hippocampus").StorageConfig;
+export type { HippocampusMemory };
 /**
  * Configuration for conversation memory feature
  */
@@ -51,7 +53,7 @@ export type ConversationMemoryConfig = {
     /** Model to use for summarization */
     summarizationModel?: string;
     /** Memory SDK config (condensed key-value memory per user). Set enabled: true to activate. */
-    memory?: Memory;
+    memory?: HippocampusMemory;
     /** Redis configuration (optional) - overrides environment variables */
     redisConfig?: RedisStorageConfig;
     /** Context compaction configuration */
@@ -338,7 +340,7 @@ export type NeurolinkOptions = {
     /** Session identifier for conversation context */
     sessionId?: string;
     /** Observability configuration */
-    observability?: import("./observability.js").ObservabilityConfig;
+    observability?: ObservabilityConfig;
 };
 /**
  * Session identifier for Redis storage operations

package/dist/lib/types/{domainTypes.js → domain.js}

@@ -3,4 +3,4 @@
  * Provides type-safe domain configuration and factory pattern support
  */
 export {};
-//# sourceMappingURL=domainTypes.js.map
+//# sourceMappingURL=domain.js.map

package/dist/lib/{mcp/elicitation/types.d.ts → types/elicitation.d.ts}

@@ -7,7 +7,7 @@
  * @module mcp/elicitation/types
  * @since 8.39.0
  */
-import type { JsonValue, JsonObject } from "../../types/common.js";
+import type { JsonValue, JsonObject } from "./common.js";
 /**
  * Elicitation request types
  */

package/dist/lib/{mcp/elicitation/types.js → types/elicitation.js}

@@ -8,4 +8,4 @@
  * @since 8.39.0
  */
 export {};
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=elicitation.js.map

package/dist/lib/types/enums.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runtime enums re-exported through the types barrel.
+ *
+ * `AIProviderName` is a runtime enum (used as both value and type) that lives
+ * in `../constants/enums.js` for non-type reasons. This file lets it flow
+ * through the types barrel via `export * from "./enums.js"`, satisfying
+ * Critical Rule 10 (the barrel must contain `export *` only).
+ */
+export { AIProviderName } from "../constants/enums.js";

package/dist/lib/types/enums.js

@@ -0,0 +1,10 @@
+/**
+ * Runtime enums re-exported through the types barrel.
+ *
+ * `AIProviderName` is a runtime enum (used as both value and type) that lives
+ * in `../constants/enums.js` for non-type reasons. This file lets it flow
+ * through the types barrel via `export * from "./enums.js"`, satisfying
+ * Critical Rule 10 (the barrel must contain `export *` only).
+ */
+export { AIProviderName } from "../constants/enums.js";
+//# sourceMappingURL=enums.js.map

package/dist/lib/types/evaluation.d.ts

@@ -1,7 +1,13 @@
 /**
- * Evaluation provider type definitions for NeuroLink
+ * Evaluation type definitions for NeuroLink
  * Provider performance tracking, evaluation configurations, and provider optimization types
  */
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type { TokenUsage } from "./analytics.js";
+import type { GenerateResult } from "./generate.js";
+import type { ToolExecution } from "./tools.js";
+import type { JsonObject } from "./common.js";
+import type { AggregatedScores, PipelineConfig, ScorerInput } from "./scorer.js";
 /**
  * Evaluation provider type as specified in core module refactoring
  */
@@ -119,3 +125,196 @@ export type EvaluationCriteria = {
     completeness: boolean;
     domainSpecific?: boolean;
 };
+/**
+ * Represents the analysis of the user's query intent.
+ * This provides a basic understanding of what the user is trying to achieve.
+ */
+export type QueryIntentAnalysis = {
+    /** The type of query, e.g., asking a question or giving a command. */
+    type: "question" | "command" | "greeting" | "unknown";
+    /** The estimated complexity of the query. */
+    complexity: "low" | "medium" | "high";
+    /** Whether the query likely required the use of tools to be answered correctly. */
+    shouldHaveUsedTools: boolean;
+};
+/**
+ * Represents a single turn in an enhanced conversation history,
+ * including tool executions and evaluations for richer context.
+ */
+export type EnhancedConversationTurn = {
+    /** The role of the speaker, either 'user' or 'assistant'. */
+    role: "user" | "assistant";
+    /** The content of the message. */
+    content: string;
+    /** The timestamp of the message. */
+    timestamp: string;
+    /** Any tools that were executed as part of this turn. */
+    toolExecutions?: ToolExecution[];
+    /** The evaluation result for this turn, if applicable. */
+    evaluation?: EvaluationResult;
+};
+/**
+ * Contains all the rich context needed for a thorough, RAGAS-style evaluation.
+ * This object is constructed by the `ContextBuilder` and used by the `RAGASEvaluator`.
+ */
+export type EnhancedEvaluationContext = {
+    /** The original user query. */
+    userQuery: string;
+    /** An analysis of the user's query intent. */
+    queryAnalysis: QueryIntentAnalysis;
+    /** The AI's response that is being evaluated. */
+    aiResponse: string;
+    /** The AI provider that generated the response. */
+    provider: string;
+    /** The specific model that generated the response. */
+    model: string;
+    /** The parameters used for the generation call. */
+    generationParams: {
+        temperature?: number;
+        maxTokens?: number;
+        systemPrompt?: string;
+    };
+    /** A list of tools that were executed. */
+    toolExecutions: ToolExecution[];
+    /** The history of the conversation leading up to this turn. */
+    conversationHistory: EnhancedConversationTurn[];
+    /** The response time of the AI in milliseconds. */
+    responseTime: number;
+    /** The token usage for the generation. */
+    tokenUsage: TokenUsage;
+    /** The results of any previous evaluation attempts for this response. */
+    previousEvaluations?: EvaluationResult[];
+    /** The current attempt number for this evaluation (1-based). */
+    attemptNumber: number;
+};
+/**
+ * Represents the result of a single evaluation attempt, based on RAGAS principles.
+ */
+export type EvaluationResult = {
+    /** The final, overall score for the response, typically from 1 to 10. */
+    finalScore: number;
+    /** How well the response addresses the user's query. */
+    relevanceScore: number;
+    /** The factual accuracy of the information in the response. */
+    accuracyScore: number;
+    /** How completely the response answers the user's query. */
+    completenessScore: number;
+    /** Whether the final score meets the passing threshold. */
+    isPassing: boolean;
+    /** Constructive response from the judge LLM on how to improve the response. */
+    reasoning: string;
+    /** Specific suggestions for improving the response. */
+    suggestedImprovements: string;
+    /** The raw, unparsed response from the judge LLM. */
+    rawEvaluationResponse: string;
+    /** The model used to perform the evaluation. */
+    evaluationModel: string;
+    /** The time taken for the evaluation in milliseconds. */
+    evaluationTime: number;
+    /** The attempt number for this evaluation. */
+    attemptNumber: number;
+};
+/**
+ * Provides detailed information when a response fails quality assurance checks.
+ */
+export type QualityErrorDetails = {
+    /** The history of all evaluation attempts for this response. */
+    evaluationHistory: EvaluationResult[];
+    /** The final score of the last attempt. */
+    finalScore: number;
+    /** The total number of evaluation attempts made. */
+    attempts: number;
+    /** A summary message of the failure. */
+    message: string;
+};
+/**
+ * Configuration for the main `Evaluator` class.
+ */
+export type EvaluationConfig = {
+    /** The minimum score (1-10) for a response to be considered passing. */
+    threshold?: number;
+    /** The evaluation strategy to use. Currently only 'ragas' is supported. */
+    evaluationStrategy?: "ragas" | "custom";
+    /** The model to use for the LLM-as-judge evaluation. */
+    evaluationModel?: string;
+    /** The maximum number of evaluation attempts before failing. */
+    maxAttempts?: number;
+    /** The provider to use for the evaluation model. */
+    provider?: string;
+    /** A custom evaluator function to override the default behavior. */
+    customEvaluator?: (options: LanguageModelV3CallOptions, result: GenerateResult) => Promise<{
+        evaluationResult: EvaluationResult;
+        evalContext: EnhancedEvaluationContext;
+    }>;
+    /** The score below which a response is considered off-topic. */
+    offTopicThreshold?: number;
+    /** The score below which a failing response is considered a high severity alert. */
+    highSeverityThreshold?: number;
+    /** An optional function to generate custom evaluation prompts. */
+    promptGenerator?: GetPromptFunction;
+};
+/**
+ * A function that generates the main body of an evaluation prompt.
+ */
+export type GetPromptFunction = (context: {
+    userQuery: string;
+    history: string;
+    tools: string;
+    retryInfo: string;
+    aiResponse: string;
+}) => string;
+/**
+ * Pipeline execution options
+ */
+export type PipelineExecutionOptions = {
+    /** Correlation ID for tracing */
+    correlationId?: string;
+    /** Custom timeout override */
+    timeout?: number;
+    /** Skip specific scorers. Mutually exclusive with onlyScorers. */
+    skipScorers?: string[];
+    /** Only run specific scorers. Mutually exclusive with skipScorers. */
+    onlyScorers?: string[];
+    /** Additional metadata to attach */
+    metadata?: JsonObject;
+};
+/**
+ * Pipeline execution result
+ */
+export type PipelineResult = AggregatedScores & {
+    /** Pipeline configuration used */
+    pipelineConfig: PipelineConfig;
+    /** Execution options used */
+    executionOptions?: PipelineExecutionOptions;
+    /** Errors that occurred during execution */
+    errors: Array<{
+        scorerId: string;
+        error: string;
+    }>;
+    /** Scorers that were skipped */
+    skippedScorers: string[];
+};
+/**
+ * Report data structure
+ */
+export type ReportData = {
+    /** Report title */
+    title: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Evaluation result */
+    result: PipelineResult | AggregatedScores;
+    /** Optional custom sections */
+    customSections?: Array<{
+        title: string;
+        content: string | JsonObject;
+    }>;
+};
+/**
+ * Function scorer - a simple function-based scorer
+ */
+export type ScorerFunction = (input: ScorerInput) => Promise<{
+    score: number;
+    reasoning: string;
+    metadata?: JsonObject;
+}>;

package/dist/lib/types/evaluation.js

@@ -1,5 +1,5 @@
 /**
- * Evaluation provider type definitions for NeuroLink
+ * Evaluation type definitions for NeuroLink
  * Provider performance tracking, evaluation configurations, and provider optimization types
  */
 export {};

package/dist/lib/{observability/types/exporterTypes.js → types/exporter.js}

@@ -3,4 +3,4 @@
  * Following NeuroLink's type conventions
  */
 export {};
-//# sourceMappingURL=exporterTypes.js.map
+//# sourceMappingURL=exporter.js.map

package/dist/lib/types/externalMcp.d.ts

@@ -10,8 +10,8 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 /**
  * Supported MCP transport protocols - imported from mcpTypes.js (canonical definition)
  */
-import type { MCPTransportType } from "./mcpTypes.js";
-export type { MCPTransportType } from "./mcpTypes.js";
+import type { MCPTransportType, MCPServerInfo } from "./mcp.js";
+export type { MCPTransportType } from "./mcp.js";
 /**
  * External MCP server configuration for process spawning
  */
@@ -304,7 +304,7 @@ export type ExternalMCPManagerConfig = {
  * configuration fields from MCPServerInfo with runtime-only state needed for
  * active server management (process handles, clients, metrics, etc.)
  */
-export type RuntimeMCPServerInfo = import("./mcpTypes.js").MCPServerInfo & {
+export type RuntimeMCPServerInfo = MCPServerInfo & {
     /** Child process handle (for stdio transport, null for HTTP transports) */
     process: import("child_process").ChildProcess | null;
     /** MCP client instance for communication */
@@ -345,5 +345,5 @@ export type RuntimeMCPServerInfo = import("./mcpTypes.js").MCPServerInfo & {
         inputSchema?: object;
     }>;
     /** Compatibility field for existing code - stores MCPServerInfo config */
-    config: import("./mcpTypes.js").MCPServerInfo;
+    config: MCPServerInfo;
 };

package/dist/lib/types/{fileTypes.js → file.js}

@@ -2,4 +2,4 @@
  * File detection and processing types for unified file handling
  */
 export {};
-//# sourceMappingURL=fileTypes.js.map
+//# sourceMappingURL=file.js.map

package/dist/lib/types/{fileReferenceTypes.d.ts → fileReference.d.ts}

@@ -5,7 +5,7 @@
  * Files are registered as lightweight references with metadata and previews.
  * Full content is processed on-demand when the LLM requests it via tools.
  */
-import type { FileSource, FileType } from "./fileTypes.js";
+import type { FileSource, FileType } from "./file.js";
 /**
  * Size tier determines the processing strategy for a file.
  *
@@ -220,3 +220,15 @@ export type FileRegistryOptions = {
     /** Default preview length in characters (default: 2000) */
     defaultPreviewChars?: number;
 };
+export declare const SIZE_TIER_THRESHOLDS: {
+    /** < 10 KB: inline in prompt */
+    readonly TINY_MAX: number;
+    /** 10 KB – 100 KB: full load with truncation */
+    readonly SMALL_MAX: number;
+    /** 100 KB – 5 MB: outline + on-demand */
+    readonly MEDIUM_MAX: number;
+    /** 5 MB – 100 MB: streaming + chunked summarization */
+    readonly LARGE_MAX: number;
+    /** 100 MB – 2 GB: reference only */
+    readonly HUGE_MAX: number;
+};

package/dist/lib/{files/types.js → types/fileReference.js}

@@ -1,13 +1,11 @@
 /**
- * File Reference Architecture Types
+ * File Reference Architecture Types (canonical location)
  *
  * Types for the lazy on-demand file processing system.
  * Files are registered as lightweight references with metadata and previews.
  * Full content is processed on-demand when the LLM requests it via tools.
  */
-/**
- * Size tier thresholds in bytes
- */
+// Size tier thresholds in bytes
 export const SIZE_TIER_THRESHOLDS = {
     /** < 10 KB: inline in prompt */
     TINY_MAX: 10 * 1024,
@@ -21,4 +19,4 @@ export const SIZE_TIER_THRESHOLDS = {
     HUGE_MAX: 2 * 1024 * 1024 * 1024,
     // > 2 GB: oversized, rejected
 };
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=fileReference.js.map