@umituz/web-ai 1.0.6 → 1.0.8

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
-export { C as ChatMessage, F as FinishReason, G as GenerationResult, P as ProviderHealth, S as StreamCallbacks, a as StructuredGeneration, b as StructuredTextRequest, T as TextRequest, c as TextTier, d as TokenUsage } from '../index-fXjxTR5W.js';
-import { A as AIError, b as AIErrorType, a as AIErrorMetadata } from '../index-DIHz8_OJ.js';
-export { T as TEXT_TIERS, c as TierModelMap, U as USER_FRIENDLY_ERROR_MESSAGES, i as isTextTier, m as mergeTierOverrides, r as resolveModel } from '../index-DIHz8_OJ.js';
+import { c as TokenUsage, C as ChatMessage } from '../index-DDzvTDg0.js';
+export { F as FinishReason, G as GenerationResult, P as ProviderHealth, S as StructuredGeneration, a as StructuredTextRequest, T as TextRequest, b as TextTier } from '../index-DDzvTDg0.js';
+import { A as AIError, b as AIErrorType, a as AIErrorMetadata } from '../index-Ca5o4gBK.js';
+export { T as TEXT_TIERS, c as TierModelMap, U as USER_FRIENDLY_ERROR_MESSAGES, i as isTextTier, m as mergeTierOverrides, r as resolveModel } from '../index-Ca5o4gBK.js';
 import { b as RetryManager, c as RetryOptions, a as RequestQueue, R as RequestDeduplicator } from '../request-deduplicator.util-NDo0_n1y.js';
 export { Q as QueueOptions, r as requestDeduplicator, d as requestQueue, e as retryManager, w as withRetry } from '../request-deduplicator.util-NDo0_n1y.js';
 export { C as CacheManager, a as CacheOptions, b as CacheStats, c as cacheManager } from '../cache-manager-Df9LLYGA.js';
@@ -54,6 +55,22 @@ declare function buildHttpStatusFallback(status: number, statusText: string): st
 declare function extractErrorMessageFromResponse(response: Response): Promise<string>;
 declare function describeAIErrorType(type: AIErrorType): string;
 
+type AiErrorCode = 'invalid_key' | 'missing_key' | 'rate_limited' | 'capacity' | 'timeout' | 'invalid_request' | 'model_unavailable' | 'upstream_error' | 'network' | 'cancelled';
+declare const STATUS_TO_CODE: Readonly<Record<number, AiErrorCode>>;
+declare const CODE_MESSAGES: Readonly<Record<AiErrorCode, string>>;
+declare class AiError extends Error {
+    readonly code: AiErrorCode;
+    constructor(code: AiErrorCode, message?: string);
+    get userMessage(): string;
+}
+declare function aiErrorMessage(code: AiErrorCode): string;
+interface ProviderErrorShape {
+    readonly type?: string;
+    readonly code?: string;
+}
+declare function errorFromStatus(status: number, detail?: string, provider?: ProviderErrorShape): AiError;
+declare function errorFromUnknown(err: unknown): AiError;
+
 interface IRequestExecutor<TArgs extends unknown[], TResult> {
     execute(fn: (...args: TArgs) => Promise<TResult>, ...args: TArgs): Promise<TResult>;
 }
@@ -140,6 +157,27 @@ declare function asTrimmedOptionalString(value: unknown): string | undefined;
 declare function clampScore(value: unknown, min: number, max: number): number | null;
 declare function oneOfCatalog<T extends readonly string[]>(catalog: T, value: unknown): T[number] | null;
 
+declare const TRANSIENT_ERROR_CODES: ReadonlySet<string>;
+interface FailoverErrorLike {
+    readonly code?: string;
+    readonly type?: string;
+    readonly status?: number;
+}
+declare function isTransientError(err: unknown): boolean;
+declare function canFailover(err: unknown, streamedChars: number): boolean;
+interface ModelWithProvider {
+    readonly model: {
+        readonly id: string;
+        readonly capabilities?: {
+            readonly streaming?: boolean;
+        };
+    };
+    readonly provider: {
+        readonly id: string;
+    };
+}
+declare function failoverCandidate<T extends ModelWithProvider>(primary: T, fallback: T | null): T | null;
+
 declare function isSseDataLine(line: string): boolean;
 declare function extractSseDataPayload(line: string): string;
 declare function isSseDoneMarker(payload: string): boolean;
@@ -186,6 +224,101 @@ declare class StructuredPromptBuilder {
     build(): string;
 }
 
+declare const CHUNK_MAX_CHARS = 1200;
+declare const CHUNK_OVERLAP_CHARS = 160;
+declare const CHUNK_TEXT_LIMIT = 200000;
+interface ChunkOptions {
+    maxChars?: number;
+    overlapChars?: number;
+}
+declare function chunkText(text: string, options?: ChunkOptions): string[];
+
+interface AccessTimestamped {
+    readonly lastAccess: number;
+}
+declare function selectLeastRecentlyUsedKey<K, V extends AccessTimestamped>(entries: ReadonlyMap<K, V>): K | null;
+
+interface ExponentialBackoffParams {
+    readonly attempt: number;
+    readonly initialDelay: number;
+    readonly maxDelay: number;
+    readonly backoffMultiplier: number;
+    readonly jitterFactor: number;
+    readonly random?: () => number;
+}
+declare function calculateExponentialBackoff(params: ExponentialBackoffParams): number;
+
+declare function generateRandomBase36Suffix(length: number, random?: () => number): string;
+
+interface AccessCounted {
+    readonly accessCount: number;
+}
+declare function calculateCacheHitRate(entries: ReadonlyArray<AccessCounted>): number;
+
+interface LeadingEdgeParams {
+    readonly now: number;
+    readonly lastCallTime: number;
+    readonly interval: number;
+    readonly leadingEnabled: boolean;
+    readonly isThrottled: boolean;
+}
+declare function shouldCallOnLeadingEdge(params: LeadingEdgeParams): boolean;
+interface TrailingDelayParams {
+    readonly interval: number;
+    readonly timeSinceLastCall: number;
+}
+declare function calculateTrailingDelay(params: TrailingDelayParams): number;
+declare function isWithinWindow(now: number, lastCallTime: number, interval: number): boolean;
+
+declare const MICROS_PER_UNIT = 1000000;
+interface ModelPricing {
+    readonly inputPerMTok: number;
+    readonly outputPerMTok: number;
+    readonly currency: 'USD';
+}
+declare function computeCostMicros(pricing: ModelPricing, usage: Pick<TokenUsage, 'inputTokens' | 'outputTokens'>): number;
+interface UsageRecordInput {
+    readonly usage: TokenUsage & {
+        readonly reasoningTokens?: number;
+    };
+    readonly pricing: ModelPricing;
+    readonly durationMs: number;
+}
+interface UsageRecordData {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly reasoningTokens: number;
+    readonly costMicros: number;
+    readonly durationMs: number;
+}
+declare function buildUsageData(input: UsageRecordInput): UsageRecordData;
+declare function formatCost(costMicros: number): string;
+
+interface TaskPolicy {
+    readonly maxAttempts: number;
+    readonly backoffBaseMs: number;
+}
+declare const DEFAULT_TASK_POLICIES: Record<string, TaskPolicy>;
+declare function nextAttemptDelayMs(attempt: number, baseMs: number): number;
+interface TaskState {
+    readonly status: string;
+    readonly nextAttemptAt?: string | null;
+}
+declare function canStartTask(task: TaskState, now?: Date): boolean;
+interface TaskPlan {
+    readonly status: 'queued' | 'failed';
+    readonly nextAttemptAt: string | null;
+    readonly log: {
+        readonly at: string;
+        readonly level: 'info' | 'warn' | 'error';
+        readonly message: string;
+    };
+}
+declare function planTaskFailure(task: {
+    attempts: number;
+    maxAttempts: number;
+}, errorDetail: string, backoffBaseMs: number, now?: Date): TaskPlan;
+
 declare const SSE_BRIDGE_EVENTS: {
     readonly delta: "delta";
     readonly done: "done";
@@ -201,6 +334,287 @@ interface SseResponseOptions {
 declare function defaultSseDeltaExtractor(payload: string): string | null;
 declare function createSseResponse(openUpstream: () => Promise<ReadableStream<Uint8Array>>, options: SseResponseOptions): Response;
 
+interface WireToolCallDelta {
+    readonly index?: number;
+    readonly id?: string;
+    readonly function?: {
+        readonly name?: string;
+        readonly arguments?: string;
+    };
+}
+interface AssistantToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+declare class ToolCallAccumulator {
+    private readonly slots;
+    push(delta: WireToolCallDelta): void;
+    finish(): AssistantToolCall[];
+}
+
+type ContextRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ContextMessage {
+    readonly role: ContextRole;
+    readonly content: string;
+    readonly toolCalls?: ReadonlyArray<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    readonly toolCallId?: string;
+}
+interface ContextBudget {
+    readonly contextWindow: number;
+    readonly maxOutputTokens: number;
+}
+declare function estimateTokens(text: string): number;
+declare function estimateMessageTokens(message: ContextMessage): number;
+declare function buildContext<T extends ContextMessage = ContextMessage>(history: ReadonlyArray<T>, systemPrompt: string, budget: ContextBudget): T[];
+
+declare const SYSTEM_PROMPT_VERSION = 2;
+declare const DEFAULT_AI_IDENTITY: string;
+interface ProjectContext {
+    name: string;
+    instructions: string;
+}
+interface AgentContext {
+    name: string;
+    instructions: string;
+}
+interface SystemPromptInput {
+    identity?: string;
+    settings?: {
+        systemExtra?: string;
+    };
+    project?: ProjectContext | null;
+    agent?: AgentContext | null;
+    attachments?: readonly {
+        name: string;
+        text: string;
+    }[];
+    memories?: readonly string[];
+    now?: Date;
+}
+declare function buildSystemPrompt(input?: SystemPromptInput): string;
+
+type SearchTopic = 'general' | 'news';
+interface WebSearchResult {
+    readonly title: string;
+    readonly url: string;
+    readonly content: string;
+    readonly score: number | null;
+}
+interface WebSearchResponse {
+    readonly query: string;
+    readonly answer: string | null;
+    readonly results: ReadonlyArray<WebSearchResult>;
+    readonly responseTime: number | null;
+}
+interface WebSearchInput {
+    readonly query: string;
+    readonly maxResults?: number;
+    readonly topic?: SearchTopic;
+    readonly includeAnswer?: boolean;
+}
+type FetchLike = (input: string, init: Record<string, unknown>) => Promise<Response>;
+declare const SEARCH_MAX_RESULTS = 5;
+declare function searchWeb(env: {
+    readonly TAVILY_API_KEY?: string;
+    readonly TAVILY_BASE_URL?: string;
+}, input: WebSearchInput, fetchImpl?: FetchLike): Promise<WebSearchResponse>;
+
+type StreamEvent<TToolCall = unknown> = {
+    readonly type: 'delta';
+    readonly channel: 'answer' | 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'usage';
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly reasoningTokens?: number;
+    };
+} | {
+    readonly type: 'tool_call';
+    readonly toolCall: TToolCall;
+} | {
+    readonly type: 'done';
+    readonly messageId: string;
+} | {
+    readonly type: 'error';
+    readonly code: string;
+    readonly message: string;
+};
+declare function formatSseEvent(event: StreamEvent): string;
+declare function sseStreamResponse(events: AsyncIterable<StreamEvent>): Response;
+declare function replayFirst<T>(first: T, rest: AsyncIterable<T>): AsyncIterable<T>;
+
+interface MarkdownSegment {
+    readonly kind: 'text' | 'code';
+    readonly text: string;
+    readonly language?: string;
+}
+declare function splitMarkdown(source: string): MarkdownSegment[];
+declare function deriveSnippetTitle(code: string): string;
+
+interface DiffLine {
+    readonly type: 'same' | 'add' | 'remove';
+    readonly text: string;
+}
+interface DiffChangeCount {
+    readonly added: number;
+    readonly removed: number;
+}
+declare function diffLines(before: string, after: string): DiffLine[];
+declare function countChanges(lines: readonly DiffLine[]): DiffChangeCount;
+
+declare const MEMORY_MAX_ITEMS = 20;
+declare const MEMORY_TOTAL_LIMIT = 4000;
+interface MemoryLike {
+    readonly content: string;
+    readonly pinned: boolean;
+    readonly updatedAt: Date | string | number;
+}
+declare function selectMemories(rows: readonly MemoryLike[], maxItems?: number, totalLimit?: number): string[];
+
+declare const RESEARCH_QUERY_MIN = 4;
+declare const RESEARCH_QUERY_MAX = 400;
+declare const RESEARCH_MAX_OUTPUT_TOKENS = 2048;
+declare const RESEARCH_TEMPERATURE = 0.2;
+declare const RESEARCH_REPORT_MIN_CHARS = 40;
+declare const RESEARCH_SNIPPET_MAX_CHARS = 1000;
+interface ResearchSource {
+    readonly title: string;
+    readonly url: string;
+    readonly snippet: string;
+}
+interface ResearchStreamEvent {
+    readonly type: string;
+    readonly channel?: 'answer' | 'reasoning' | string;
+    readonly text?: string;
+    readonly usage?: TokenUsage;
+}
+declare function normalizeSources(results: readonly WebSearchResult[], maxSnippetChars?: number): ResearchSource[];
+declare function buildResearchMessages(query: string, sources: readonly ResearchSource[], systemPersona?: string): ChatMessage[];
+declare function accumulateReport(stream: AsyncIterable<ResearchStreamEvent>): Promise<{
+    report: string;
+    usage: TokenUsage | null;
+}>;
+
+interface EmbeddingsBatchAdapter {
+    embed(req: {
+        externalModelId: string;
+        input: string[];
+    }): Promise<{
+        vectors: number[][];
+        inputTokens: number | null;
+    }>;
+}
+declare const DEFAULT_EMBED_BATCH_SIZE = 32;
+declare function batchEmbed(adapter: EmbeddingsBatchAdapter, externalModelId: string, texts: readonly string[], batchSize?: number): Promise<{
+    vectors: number[][];
+    inputTokens: number | null;
+}>;
+declare function dotProduct(a: readonly number[], b: readonly number[]): number;
+declare function magnitude(v: readonly number[]): number;
+declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
+interface VectorCandidate<T = unknown> {
+    readonly id: string;
+    readonly vector: readonly number[];
+    readonly data?: T;
+}
+interface VectorMatch<T = unknown> {
+    readonly id: string;
+    readonly similarity: number;
+    readonly data?: T;
+}
+declare function findTopKSimilar<T = unknown>(queryVector: readonly number[], candidates: readonly VectorCandidate<T>[], k?: number): VectorMatch<T>[];
+
+interface GenerationSettings {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+}
+declare const GENERATION_BOUNDS: {
+    readonly temperature: {
+        readonly min: 0;
+        readonly max: 2;
+    };
+    readonly topP: {
+        readonly min: 0;
+        readonly max: 1;
+    };
+};
+declare const DEFAULT_GENERATION: Required<GenerationSettings>;
+declare function normalizeGenerationSettings(requested: GenerationSettings | undefined, maxModelTokens?: number): Required<GenerationSettings>;
+
+interface StreamCallbacks<TToolCall = unknown> {
+    onDelta(channel: 'answer' | 'reasoning', text: string): void;
+    onUsage?(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens?: number;
+    }): void;
+    onToolCall?(toolCall: TToolCall): void;
+    onDone?(messageId: string): void;
+    onError?(code: string, message: string): void;
+}
+type ParsedSseEvent<TToolCall = unknown> = {
+    readonly type: 'delta';
+    readonly channel: 'answer' | 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'usage';
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly reasoningTokens?: number;
+    };
+} | {
+    readonly type: 'tool_call';
+    readonly toolCall: TToolCall;
+} | {
+    readonly type: 'done';
+    readonly messageId: string;
+} | {
+    readonly type: 'error';
+    readonly code: string;
+    readonly message: string;
+};
+declare function parseSseEvent<TToolCall = unknown>(rawEvent: string): ParsedSseEvent<TToolCall> | null;
+declare function readSseResponse<TToolCall = unknown>(response: Response, callbacks: StreamCallbacks<TToolCall>): Promise<void>;
+
+type ToolValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+type ToolValidatorFunction = (args: Record<string, unknown>) => {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+interface ZodLikeIssue {
+    readonly path: readonly (string | number)[];
+    readonly message: string;
+}
+interface ZodLikeSchema {
+    safeParse(data: unknown): {
+        readonly success: true;
+        readonly data?: unknown;
+    } | {
+        readonly success: false;
+        readonly error: {
+            readonly issues: readonly ZodLikeIssue[];
+        };
+    };
+}
+type ToolSchema = ToolValidatorFunction | ZodLikeSchema;
+declare function validateToolArgs(toolKey: string, args: Record<string, unknown>, schemas: Record<string, ToolSchema>): ToolValidationResult;
+
 declare const SSE_PREFIX: "data: ";
 declare const SSE_DONE_MARKER: "[DONE]";
 declare const JSON_CODE_BLOCK_PATTERN: RegExp;
@@ -212,4 +626,4 @@ declare const DEFAULT_RETRY_MAX_DELAY_MS = 10000;
 declare const DEFAULT_RETRY_BACKOFF_MULTIPLIER = 2;
 declare const DEFAULT_RETRY_JITTER_FACTOR = 0.1;
 
-export { AIError, type AIErrorBody, AIErrorMetadata, AIErrorType, type ApiKeyValidationRule, CompositeExecutor, DEFAULT_API_KEY_RULE, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_HTTP_STATUS_RULE, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, type DebounceOptions, DedupeExecutor, type DedupeExecutorOptions, type ErrorClassificationRule, GroqError, type GroqErrorMetadata, AIErrorType as GroqErrorType, type HttpStatusClassificationRule, type IRequestExecutor, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, type LoggedError, type NormalizedSseChunk, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, RetryOptions, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, type SseDeltaExtractor, type SseResponseOptions, type StreamingParserCallbacks, StreamingResponseParser, StructuredPromptBuilder, ThrottleManager, type ThrottleOptions, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildHttpStatusFallback, clampScore, classifyHttpStatus, createSseResponse, debounce, debounceManager, defaultSseDeltaExtractor, describeAIErrorType, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, formatErrorForLogging, isAuthErrorType, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isValidApiKey, normalizeSseChunk, oneOfCatalog, repairCommonJsonDefects, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, splitSseLines, throttle, throttleManager, validateApiKey };
+export { AIError, type AIErrorBody, AIErrorMetadata, AIErrorType, type AccessCounted, type AccessTimestamped, type AgentContext, AiError, type AiErrorCode, type ApiKeyValidationRule, type AssistantToolCall, CHUNK_MAX_CHARS, CHUNK_OVERLAP_CHARS, CHUNK_TEXT_LIMIT, CODE_MESSAGES, ChatMessage, type ChunkOptions, CompositeExecutor, type ContextBudget, type ContextMessage, type ContextRole, DEFAULT_AI_IDENTITY, DEFAULT_API_KEY_RULE, DEFAULT_EMBED_BATCH_SIZE, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_GENERATION, DEFAULT_HTTP_STATUS_RULE, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_TASK_POLICIES, DebounceManager, type DebounceOptions, DedupeExecutor, type DedupeExecutorOptions, type DiffChangeCount, type DiffLine, type EmbeddingsBatchAdapter, type ErrorClassificationRule, type ExponentialBackoffParams, type FailoverErrorLike, type FetchLike, GENERATION_BOUNDS, type GenerationSettings, GroqError, type GroqErrorMetadata, AIErrorType as GroqErrorType, type HttpStatusClassificationRule, type IRequestExecutor, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, type LeadingEdgeParams, type LoggedError, MEMORY_MAX_ITEMS, MEMORY_TOTAL_LIMIT, MICROS_PER_UNIT, type MarkdownSegment, type MemoryLike, type ModelPricing, type ModelWithProvider, type NormalizedSseChunk, type ParsedSseEvent, type ProjectContext, type ProviderErrorShape, QueueExecutor, RESEARCH_MAX_OUTPUT_TOKENS, RESEARCH_QUERY_MAX, RESEARCH_QUERY_MIN, RESEARCH_REPORT_MIN_CHARS, RESEARCH_SNIPPET_MAX_CHARS, RESEARCH_TEMPERATURE, RequestDeduplicator, RequestQueue, type ResearchSource, type ResearchStreamEvent, RetryExecutor, RetryManager, RetryOptions, SEARCH_MAX_RESULTS, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, STATUS_TO_CODE, SYSTEM_PROMPT_VERSION, type SearchTopic, type SseDeltaExtractor, type SseResponseOptions, type StreamCallbacks, type StreamEvent, type StreamingParserCallbacks, StreamingResponseParser, StructuredPromptBuilder, type SystemPromptInput, TRANSIENT_ERROR_CODES, type TaskPlan, type TaskPolicy, type TaskState, ThrottleManager, type ThrottleOptions, TokenUsage, ToolCallAccumulator, type ToolSchema, type ToolValidationResult, type ToolValidatorFunction, type TrailingDelayParams, type UsageRecordData, type UsageRecordInput, type VectorCandidate, type VectorMatch, type WebSearchInput, type WebSearchResponse, type WebSearchResult, type WireToolCallDelta, type ZodLikeIssue, type ZodLikeSchema, accumulateReport, aiErrorMessage, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, batchEmbed, buildCacheKey, buildContext, buildHttpStatusFallback, buildResearchMessages, buildSystemPrompt, buildUsageData, calculateCacheHitRate, calculateExponentialBackoff, calculateTrailingDelay, canFailover, canStartTask, chunkText, clampScore, classifyHttpStatus, computeCostMicros, cosineSimilarity, countChanges, createSseResponse, debounce, debounceManager, defaultSseDeltaExtractor, deriveSnippetTitle, describeAIErrorType, diffLines, dotProduct, errorFromStatus, errorFromUnknown, estimateMessageTokens, estimateTokens, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, failoverCandidate, findTopKSimilar, formatCost, formatErrorForLogging, formatSseEvent, generateRandomBase36Suffix, isAuthErrorType, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTransientError, isValidApiKey, isWithinWindow, magnitude, nextAttemptDelayMs, normalizeGenerationSettings, normalizeSources, normalizeSseChunk, oneOfCatalog, parseSseEvent, planTaskFailure, readSseResponse, repairCommonJsonDefects, replayFirst, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, searchWeb, selectLeastRecentlyUsedKey, selectMemories, shouldCallOnLeadingEdge, splitMarkdown, splitSseLines, sseStreamResponse, throttle, throttleManager, validateApiKey, validateToolArgs };