@jsonstudio/llms 0.6.203 → 0.6.230

package/dist/router/virtual-router/engine.js

@@ -5,6 +5,7 @@ import { RoutingClassifier } from './classifier.js';
 import { buildRoutingFeatures } from './features.js';
 import { ContextAdvisor } from './context-advisor.js';
 import { DEFAULT_MODEL_CONTEXT_TOKENS, DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { getStatsCenter } from '../../telemetry/stats-center.js';
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -16,6 +17,7 @@ export class VirtualRouterEngine {
     routeStats = new Map();
     debug = console; // thin hook; host may monkey-patch for colored logging
     healthConfig = null;
+    statsCenter = getStatsCenter();
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -40,21 +42,36 @@ export class VirtualRouterEngine {
         const target = this.providerRegistry.buildTarget(selection.providerKey);
         this.healthManager.recordSuccess(selection.providerKey);
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
+        try {
+            this.statsCenter.recordVirtualRouterHit({
+                requestId: metadata.requestId,
+                timestamp: Date.now(),
+                entryEndpoint: metadata.entryEndpoint || '/v1/chat/completions',
+                routeName: selection.routeUsed,
+                pool: selection.poolId || selection.routeUsed,
+                providerKey: selection.providerKey,
+                modelId: target.modelId || undefined
+            });
+        }
+        catch {
+            // stats must never break routing
+        }
         const hitReason = this.buildHitReason(selection.routeUsed, selection.providerKey, classification, features);
-        const formatted = this.formatVirtualRouterHit(selection.routeUsed, selection.providerKey, target.modelId || '', hitReason);
+        const formatted = this.formatVirtualRouterHit(selection.routeUsed, selection.poolId, selection.providerKey, target.modelId || '', hitReason);
         if (formatted) {
             this.debug?.log?.(formatted);
         }
         else {
             this.debug?.log?.('[virtual-router-hit]', selection.routeUsed, selection.providerKey, target.modelId || '', hitReason ? `reason=${hitReason}` : '');
         }
-        const didFallback = selection.routeUsed !== routeName || classification.fallback;
+        const didFallback = selection.routeUsed !== routeName;
         return {
             target,
             decision: {
                 routeName: selection.routeUsed,
                 providerKey: selection.providerKey,
                 pool: selection.pool,
+                poolId: selection.poolId,
                 confidence: classification.confidence,
                 reasoning: classification.reasoning,
                 fallback: didFallback
@@ -63,6 +80,7 @@ export class VirtualRouterEngine {
                 routeName: selection.routeUsed,
                 providerKey: selection.providerKey,
                 pool: selection.pool,
+                poolId: selection.poolId,
                 reasoning: classification.reasoning,
                 fallback: didFallback,
                 confidence: classification.confidence
@@ -92,10 +110,10 @@ export class VirtualRouterEngine {
     }
     getStatus() {
         const routes = {};
-        for (const [route, pool] of Object.entries(this.routing)) {
+        for (const [route, pools] of Object.entries(this.routing)) {
             const stats = this.routeStats.get(route) ?? { hits: 0 };
             routes[route] = {
-                providers: [...pool],
+                providers: this.flattenPoolTargets(pools),
                 hits: stats.hits,
                 lastUsedProvider: stats.lastProvider
             };
@@ -112,21 +130,29 @@ export class VirtualRouterEngine {
         if (!config.providers || Object.keys(config.providers).length === 0) {
             throw new VirtualRouterError('providers configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
         }
-        const defaultPool = config.routing[DEFAULT_ROUTE];
-        if (!Array.isArray(defaultPool) || defaultPool.length === 0) {
+        const defaultPools = config.routing[DEFAULT_ROUTE];
+        if (!this.routeHasTargets(defaultPools)) {
             throw new VirtualRouterError('default route must be configured with at least one provider', VirtualRouterErrorCode.CONFIG_ERROR);
         }
+        if (!this.hasPrimaryPool(defaultPools)) {
+            throw new VirtualRouterError('default route must define at least one non-backup pool', VirtualRouterErrorCode.CONFIG_ERROR);
+        }
         const providerKeys = new Set(Object.keys(config.providers));
-        for (const [routeName, pool] of Object.entries(config.routing)) {
-            if (!Array.isArray(pool) || !pool.length) {
+        for (const [routeName, pools] of Object.entries(config.routing)) {
+            if (!this.routeHasTargets(pools)) {
                 if (routeName === DEFAULT_ROUTE) {
                     throw new VirtualRouterError('default route cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
                 }
                 continue;
             }
-            for (const providerKey of pool) {
-                if (!providerKeys.has(providerKey)) {
-                    throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+            for (const pool of pools) {
+                if (!Array.isArray(pool.targets) || !pool.targets.length) {
+                    continue;
+                }
+                for (const providerKey of pool.targets) {
+                    if (!providerKeys.has(providerKey)) {
+                        throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
                 }
             }
         }
@@ -136,8 +162,7 @@ export class VirtualRouterEngine {
         const stickyKey = this.resolveStickyKey(metadata);
         const attempted = [];
         const visitedRoutes = new Set();
-        const fallbackRoute = this.resolveFallbackRoute();
-        const routeQueue = this.initializeRouteQueue(candidates, fallbackRoute);
+        const routeQueue = this.initializeRouteQueue(candidates);
         const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
             ? Math.max(0, features.estimatedTokens)
             : 0;
@@ -146,33 +171,51 @@ export class VirtualRouterEngine {
             if (visitedRoutes.has(routeName)) {
                 continue;
             }
-            const pool = this.routing[routeName];
-            if (!Array.isArray(pool) || pool.length === 0) {
+            const routePools = this.routing[routeName];
+            if (!this.routeHasTargets(routePools)) {
                 visitedRoutes.add(routeName);
-                attempted.push(routeName);
-                continue;
-            }
-            const contextResult = this.contextAdvisor.classify(pool, estimatedTokens, (key) => this.providerRegistry.get(key));
-            if (this.maybeDeferToFallback(routeName, contextResult, routeQueue, visitedRoutes, fallbackRoute)) {
+                attempted.push(`${routeName}:empty`);
                 continue;
             }
             visitedRoutes.add(routeName);
-            const prioritizedPools = this.buildContextCandidatePools(contextResult);
-            for (const candidatePool of prioritizedPools) {
-                const providerKey = this.loadBalancer.select({
-                    routeName,
-                    candidates: candidatePool,
-                    stickyKey,
-                    availabilityCheck: (key) => this.healthManager.isAvailable(key)
-                });
+            const orderedPools = this.sortRoutePools(routePools);
+            for (const poolTier of orderedPools) {
+                const { providerKey, poolTargets, tierId, failureHint } = this.trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens);
                 if (providerKey) {
-                    return { providerKey, routeUsed: routeName, pool };
+                    return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
+                }
+                if (failureHint) {
+                    attempted.push(failureHint);
                 }
             }
-            attempted.push(this.describeAttempt(routeName, contextResult));
         }
         throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
     }
+    trySelectFromTier(routeName, tier, stickyKey, estimatedTokens) {
+        const targets = Array.isArray(tier.targets) ? tier.targets : [];
+        if (!targets.length) {
+            return { providerKey: null, poolTargets: [], tierId: tier.id, failureHint: `${routeName}:${tier.id}:empty` };
+        }
+        const contextResult = this.contextAdvisor.classify(targets, estimatedTokens, (key) => this.providerRegistry.get(key));
+        const prioritizedPools = this.buildContextCandidatePools(contextResult);
+        for (const candidatePool of prioritizedPools) {
+            const providerKey = this.loadBalancer.select({
+                routeName: `${routeName}:${tier.id}`,
+                candidates: candidatePool,
+                stickyKey,
+                availabilityCheck: (key) => this.healthManager.isAvailable(key)
+            });
+            if (providerKey) {
+                return { providerKey, poolTargets: tier.targets, tierId: tier.id };
+            }
+        }
+        return {
+            providerKey: null,
+            poolTargets: tier.targets,
+            tierId: tier.id,
+            failureHint: this.describeAttempt(routeName, tier.id, contextResult)
+        };
+    }
     incrementRouteStat(routeName, providerKey) {
         if (!this.routeStats.has(routeName)) {
             this.routeStats.set(routeName, { hits: 0, lastProvider: providerKey });
@@ -185,63 +228,34 @@ export class VirtualRouterEngine {
     providerHealthConfig() {
         return this.healthManager.getConfig();
     }
-    initializeRouteQueue(candidates, fallbackRoute) {
-        const queue = Array.from(new Set(candidates));
-        if (fallbackRoute && !queue.includes(fallbackRoute)) {
-            queue.push(fallbackRoute);
-        }
-        return queue;
-    }
-    resolveFallbackRoute() {
-        const candidate = this.contextRouting?.fallbackRoute;
-        if (!candidate) {
-            return undefined;
-        }
-        const pool = this.routing[candidate];
-        if (!Array.isArray(pool) || pool.length === 0) {
-            return undefined;
-        }
-        return candidate;
-    }
-    maybeDeferToFallback(routeName, contextResult, queue, visited, fallbackRoute) {
-        if (!fallbackRoute || fallbackRoute === routeName || visited.has(fallbackRoute)) {
-            return false;
-        }
-        if (!this.contextAdvisor.prefersFallback(contextResult)) {
-            return false;
-        }
-        const fallbackPool = this.routing[fallbackRoute];
-        if (!Array.isArray(fallbackPool) || fallbackPool.length === 0) {
-            return false;
-        }
-        queue.unshift(routeName);
-        queue.unshift(fallbackRoute);
-        return true;
+    initializeRouteQueue(candidates) {
+        return Array.from(new Set(candidates));
     }
     buildContextCandidatePools(result) {
         const ordered = [];
         if (result.safe.length) {
             ordered.push(result.safe);
+            // 如果存在安全候选，直接放弃当前处于警戒阈值的模型
+            return ordered;
         }
         if (result.risky.length) {
             ordered.push(result.risky);
         }
-        if (result.overflow.length && this.contextAdvisor.allowsOverflow()) {
-            ordered.push(result.overflow);
-        }
+        // ratio >= 1 视为上下文溢出，直接标记为不可用
         return ordered;
     }
-    describeAttempt(routeName, result) {
+    describeAttempt(routeName, poolId, result) {
+        const prefix = poolId ? `${routeName}:${poolId}` : routeName;
         if (result.safe.length > 0) {
-            return `${routeName}:health`;
+            return `${prefix}:health`;
         }
         if (result.risky.length > 0) {
-            return `${routeName}:context_risky`;
+            return `${prefix}:context_risky`;
         }
         if (result.overflow.length > 0) {
-            return `${routeName}:context_overflow`;
+            return `${prefix}:max_context_window`;
         }
-        return routeName;
+        return prefix;
     }
     resolveStickyKey(metadata) {
         const resume = metadata.responsesResume;
@@ -347,13 +361,8 @@ export class VirtualRouterEngine {
         if (!deduped.includes(DEFAULT_ROUTE)) {
             deduped.push(DEFAULT_ROUTE);
         }
-        const filtered = deduped.filter((routeName) => {
-            const pool = this.routing[routeName];
-            return Array.isArray(pool) && pool.length > 0;
-        });
-        if (!filtered.includes(DEFAULT_ROUTE) &&
-            Array.isArray(this.routing[DEFAULT_ROUTE]) &&
-            this.routing[DEFAULT_ROUTE].length > 0) {
+        const filtered = deduped.filter((routeName) => this.routeHasTargets(this.routing[routeName]));
+        if (!filtered.includes(DEFAULT_ROUTE) && this.routeHasTargets(this.routing[DEFAULT_ROUTE])) {
             filtered.push(DEFAULT_ROUTE);
         }
         return filtered.length ? filtered : [DEFAULT_ROUTE];
@@ -365,6 +374,52 @@ export class VirtualRouterEngine {
         const idx = ROUTE_PRIORITY.indexOf(routeName);
         return idx >= 0 ? idx : ROUTE_PRIORITY.length;
     }
+    routeHasTargets(pools) {
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => Array.isArray(pool.targets) && pool.targets.length > 0);
+    }
+    hasPrimaryPool(pools) {
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => !pool.backup && Array.isArray(pool.targets) && pool.targets.length > 0);
+    }
+    sortRoutePools(pools) {
+        if (!Array.isArray(pools)) {
+            return [];
+        }
+        return pools
+            .filter((pool) => Array.isArray(pool.targets) && pool.targets.length > 0)
+            .sort((a, b) => {
+            if (a.backup && !b.backup)
+                return 1;
+            if (!a.backup && b.backup)
+                return -1;
+            if (a.priority !== b.priority) {
+                return b.priority - a.priority;
+            }
+            return a.id.localeCompare(b.id);
+        });
+    }
+    flattenPoolTargets(pools) {
+        const flattened = [];
+        if (!Array.isArray(pools)) {
+            return flattened;
+        }
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets)) {
+                continue;
+            }
+            for (const target of pool.targets) {
+                if (typeof target === 'string' && target && !flattened.includes(target)) {
+                    flattened.push(target);
+                }
+            }
+        }
+        return flattened;
+    }
     buildHitReason(routeUsed, providerKey, classification, features) {
         const reasoning = classification.reasoning || '';
         const primary = reasoning.split('|')[0] || '';
@@ -406,18 +461,31 @@ export class VirtualRouterEngine {
         }
         return `${baseLabel}(${normalizedDetail})`;
     }
-    formatVirtualRouterHit(routeName, providerKey, modelId, hitReason) {
+    formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason) {
         try {
+            // 生成本地时间戳
+            const now = new Date();
+            const hours = String(now.getHours()).padStart(2, '0');
+            const minutes = String(now.getMinutes()).padStart(2, '0');
+            const seconds = String(now.getSeconds()).padStart(2, '0');
+            const timestamp = `${hours}:${minutes}:${seconds}`;
             const prefixColor = '\x1b[38;5;208m';
             const reset = '\x1b[0m';
+            const timeColor = '\x1b[90m'; // 灰色
             const routeColor = this.resolveRouteColor(routeName);
             const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
-            const targetLabel = `${routeName} -> ${providerKey}${modelId ? '.' + modelId : ''}`;
+            const timeLabel = `${timeColor}${timestamp}${reset}`;
+            const { providerLabel, resolvedModel } = this.describeTargetProvider(providerKey, modelId);
+            const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+            const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
             const reasonLabel = hitReason ? ` reason=${hitReason}` : '';
-            return `${prefix} ${routeColor}${targetLabel}${reasonLabel}${reset}`;
+            return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${reasonLabel}${reset}`;
         }
         catch {
-            return `[virtual-router-hit] ${routeName} -> ${providerKey}${modelId ? '.' + modelId : ''}${hitReason ? ` reason=${hitReason}` : ''}`;
+            const now = new Date();
+            const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
+            const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+            return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${hitReason ? ` reason=${hitReason}` : ''}`;
         }
     }
     resolveRouteColor(routeName) {
@@ -457,4 +525,31 @@ export class VirtualRouterEngine {
         }
         return `${ratio.toFixed(2)}/${Math.round(limit)}`;
     }
+    describeTargetProvider(providerKey, fallbackModelId) {
+        const parsed = this.parseProviderKey(providerKey);
+        if (!parsed) {
+            return { providerLabel: providerKey, resolvedModel: fallbackModelId };
+        }
+        const aliasLabel = parsed.keyAlias ? `${parsed.providerId}[${parsed.keyAlias}]` : parsed.providerId;
+        const resolvedModel = parsed.modelId || fallbackModelId;
+        return { providerLabel: aliasLabel, resolvedModel };
+    }
+    parseProviderKey(providerKey) {
+        const trimmed = typeof providerKey === 'string' ? providerKey.trim() : '';
+        if (!trimmed) {
+            return null;
+        }
+        const parts = trimmed.split('.');
+        if (parts.length < 2) {
+            return { providerId: trimmed };
+        }
+        if (parts.length === 2) {
+            return { providerId: parts[0], modelId: parts[1] };
+        }
+        return {
+            providerId: parts[0],
+            keyAlias: parts[1],
+            modelId: parts.slice(2).join('.')
+        };
+    }
 }

package/dist/router/virtual-router/types.d.ts

@@ -5,7 +5,13 @@ import type { StandardizedRequest } from '../../conversion/hub/types/standardize
 export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
-export type RoutingPools = Record<string, string[]>;
+export interface RoutePoolTier {
+    id: string;
+    targets: string[];
+    priority: number;
+    backup?: boolean;
+}
+export type RoutingPools = Record<string, RoutePoolTier[]>;
 export type StreamingPreference = 'auto' | 'always' | 'never';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
@@ -72,6 +78,16 @@ export interface ProviderHealthConfig {
     cooldownMs: number;
     fatalCooldownMs?: number;
 }
+export interface VirtualRouterWebSearchEngineConfig {
+    id: string;
+    providerKey: string;
+    description?: string;
+    default?: boolean;
+}
+export interface VirtualRouterWebSearchConfig {
+    engines: VirtualRouterWebSearchEngineConfig[];
+    injectPolicy?: 'always' | 'selective';
+}
 export interface VirtualRouterConfig {
     routing: RoutingPools;
     providers: Record<string, ProviderProfile>;
@@ -79,11 +95,11 @@ export interface VirtualRouterConfig {
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
     contextRouting?: VirtualRouterContextRoutingConfig;
+    webSearch?: VirtualRouterWebSearchConfig;
 }
 export interface VirtualRouterContextRoutingConfig {
     warnRatio: number;
     hardLimit?: boolean;
-    fallbackRoute?: string;
 }
 export type VirtualRouterProviderDefinition = Record<string, unknown>;
 export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
@@ -94,6 +110,7 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
     contextRouting?: VirtualRouterContextRoutingConfig;
+    webSearch?: VirtualRouterWebSearchConfig | Record<string, unknown>;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -152,6 +169,7 @@ export interface RoutingDecision {
     reasoning: string;
     fallback: boolean;
     pool: string[];
+    poolId?: string;
 }
 export interface TargetMetadata {
     providerKey: string;
@@ -185,6 +203,7 @@ export interface RoutingDiagnostics {
     reasoning: string;
     fallback: boolean;
     pool: string[];
+    poolId?: string;
     confidence: number;
 }
 export interface RoutingStatusSnapshot {

package/dist/sse/json-to-sse/event-generators/responses.js

@@ -8,11 +8,22 @@ function cloneRegex(source) {
     return new RegExp(source.source, source.flags);
 }
 function getChunkSize(config) {
-    return Math.max(1, config.chunkSize || DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG.chunkSize);
+    const size = typeof config.chunkSize === 'number'
+        ? config.chunkSize
+        : DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG.chunkSize;
+    if (size !== undefined && size <= 0) {
+        return null;
+    }
+    return Math.max(1, size || 1);
 }
 function chunkText(text, config) {
+    const size = getChunkSize(config);
+    if (size === null) {
+        // chunking explicitly disabled
+        return [text];
+    }
     try {
-        return StringUtils.chunkString(text, getChunkSize(config), cloneRegex(TEXT_CHUNK_BOUNDARY));
+        return StringUtils.chunkString(text, size, cloneRegex(TEXT_CHUNK_BOUNDARY));
     }
     catch {
         return [text];
@@ -84,7 +95,8 @@ function normalizeUsage(usage) {
 }
 // 默认配置
 export const DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG = {
-    chunkSize: 12,
+    // 默认关闭文本切片，让上游模型的分块行为原样透传
+    chunkSize: 0,
     chunkDelayMs: 8,
     enableIdGeneration: true,
     enableTimestampGeneration: true,

package/dist/sse/sse-to-json/gemini-sse-to-json-converter.js

@@ -70,9 +70,35 @@ export class GeminiSseToJsonConverter {
         if (!accumulator.has(candidateIndex)) {
             accumulator.set(candidateIndex, { role, parts: [] });
         }
+        const candidate = accumulator.get(candidateIndex);
         const normalizedParts = this.normalizeReasoningPart(part, context);
         for (const normalizedPart of normalizedParts) {
-            accumulator.get(candidateIndex).parts.push(normalizedPart);
+            // For text parts, accumulate into the last text part instead of creating new ones
+            if ('text' in normalizedPart && typeof normalizedPart.text === 'string') {
+                const lastPart = candidate.parts[candidate.parts.length - 1];
+                if (lastPart && 'text' in lastPart && typeof lastPart.text === 'string') {
+                    // Append to existing text part
+                    lastPart.text += normalizedPart.text;
+                }
+                else {
+                    // Create new text part
+                    candidate.parts.push(normalizedPart);
+                }
+            }
+            else if ('reasoning' in normalizedPart && typeof normalizedPart.reasoning === 'string') {
+                // For reasoning parts, also accumulate
+                const lastPart = candidate.parts[candidate.parts.length - 1];
+                if (lastPart && 'reasoning' in lastPart && typeof lastPart.reasoning === 'string') {
+                    lastPart.reasoning += normalizedPart.reasoning;
+                }
+                else {
+                    candidate.parts.push(normalizedPart);
+                }
+            }
+            else {
+                // For other part types (functionCall, functionResponse, etc.), add as separate parts
+                candidate.parts.push(normalizedPart);
+            }
         }
     }
     buildResponse(accumulator, donePayload) {

package/dist/sse/types/gemini-types.d.ts

@@ -7,12 +7,14 @@ export interface GeminiContentFunctionCallPart {
     functionCall: {
         name: string;
         args?: Record<string, unknown>;
+        id?: string;
         [key: string]: unknown;
     };
 }
 export interface GeminiContentFunctionResponsePart {
     functionResponse: {
         name?: string;
+        id?: string;
         response?: unknown;
         [key: string]: unknown;
     };
@@ -23,7 +25,24 @@ export interface GeminiContentInlineDataPart {
         data: string;
     };
 }
-export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | Record<string, unknown>;
+export interface GeminiContentThoughtPart {
+    thought: string;
+}
+export interface GeminiContentExecutableCodePart {
+    executableCode: {
+        language?: string;
+        code?: string;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentCodeExecutionResultPart {
+    codeExecutionResult: {
+        outcome?: string;
+        output?: string;
+        [key: string]: unknown;
+    };
+}
+export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | GeminiContentThoughtPart | GeminiContentExecutableCodePart | GeminiContentCodeExecutionResultPart | Record<string, unknown>;
 export interface GeminiCandidate {
     content?: {
         role?: string;

package/dist/sse/types/responses-types.js

@@ -23,7 +23,7 @@ export const DEFAULT_RESPONSES_CONVERSION_CONFIG = {
     defaultChunkSize: 12,
     defaultDelayMs: 8,
     reasoningChunkSize: 24,
-    textChunkSize: 12,
+    textChunkSize: 128,
     functionCallChunkSize: 24,
     enableEventValidation: true,
     enableSequenceValidation: true,

package/dist/telemetry/stats-center.d.ts

@@ -0,0 +1,73 @@
+export interface VirtualRouterHitEvent {
+    requestId: string;
+    timestamp: number;
+    entryEndpoint: string;
+    routeName: string;
+    pool: string;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType?: string;
+    modelId?: string;
+}
+export interface ProviderUsageEvent {
+    requestId: string;
+    timestamp: number;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType: string;
+    modelId?: string;
+    routeName?: string;
+    entryEndpoint?: string;
+    success: boolean;
+    latencyMs: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface RouterStatsBucket {
+    requestCount: number;
+    poolHitCount: Record<string, number>;
+    routeHitCount: Record<string, number>;
+    providerHitCount: Record<string, number>;
+}
+export interface RouterStatsSnapshot {
+    global: RouterStatsBucket;
+    byEntryEndpoint: Record<string, RouterStatsBucket>;
+}
+export interface ProviderStatsBucket {
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    latencySumMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface ProviderStatsSnapshot {
+    global: ProviderStatsBucket;
+    byProviderKey: Record<string, ProviderStatsBucket>;
+    byRoute: Record<string, ProviderStatsBucket>;
+    byEntryEndpoint: Record<string, ProviderStatsBucket>;
+}
+export interface StatsSnapshot {
+    router: RouterStatsSnapshot;
+    providers: ProviderStatsSnapshot;
+}
+export interface StatsCenterOptions {
+    enable?: boolean;
+    autoPrintOnExit?: boolean;
+    persistPath?: string | null;
+}
+export interface StatsCenter {
+    recordVirtualRouterHit(ev: VirtualRouterHitEvent): void;
+    recordProviderUsage(ev: ProviderUsageEvent): void;
+    getSnapshot(): StatsSnapshot;
+    flushToDisk(): Promise<void>;
+    reset(): void;
+}
+export declare function initStatsCenter(options?: StatsCenterOptions): StatsCenter;
+export declare function getStatsCenter(): StatsCenter;