@longzai-intelligence-model-gateway/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,685 @@
+import { z } from "zod";
+import { DomainError } from "@longzai-intelligence/error";
+import { ApplicationMapper, DomainEvent, Entity, OrmMapper, Result } from "@longzai-intelligence/shared-kernel";
+
+//#region src/types/error.d.ts
+/**
+ * 统一错误类型定义
+ * 包含错误分类、错误码、重试建议和降级建议
+ */
+/** 错误分类 */
+type ErrorCategory = 'client' | 'server' | 'provider';
+/** 错误码 */
+declare enum ErrorCode {
+  INVALID_REQUEST = "invalid_request",
+  AUTHENTICATION_FAILED = "authentication_failed",
+  PERMISSION_DENIED = "permission_denied",
+  MODEL_NOT_FOUND = "model_not_found",
+  BUDGET_EXCEEDED = "budget_exceeded",
+  RATE_LIMIT_EXCEEDED = "rate_limit_exceeded",
+  INVALID_API_KEY = "invalid_api_key",
+  INTERNAL_ERROR = "internal_error",
+  ROUTING_ERROR = "routing_error",
+  DATABASE_ERROR = "database_error",
+  CACHE_ERROR = "cache_error",
+  PROVIDER_UNAVAILABLE = "provider_unavailable",
+  PROVIDER_RATE_LIMITED = "provider_rate_limited",
+  PROVIDER_TIMEOUT = "provider_timeout",
+  PROVIDER_ERROR = "provider_error",
+  MODEL_OVERLOADED = "model_overloaded",
+  CONTEXT_LENGTH_EXCEEDED = "context_length_exceeded"
+}
+/** 重试建议 */
+type RetrySuggestion = {
+  /** 是否可重试 */retryable: boolean; /** 建议重试次数 */
+  maxRetries: number; /** 建议重试间隔（毫秒） */
+  retryAfter: number; /** 可重试的错误码 */
+  retryableCodes: ErrorCode[];
+};
+/** 降级建议 */
+type FallbackSuggestion = {
+  /** 是否可降级 */fallbackable: boolean; /** 备用模型 */
+  fallbackModel?: string; /** 备用供应商 */
+  fallbackProvider?: string; /** 是否可返回缓存 */
+  cacheAvailable: boolean;
+};
+/** 网关错误详情 */
+type GatewayErrorDetail = {
+  /** 错误码 */code: ErrorCode; /** 错误分类 */
+  category: ErrorCategory; /** 错误消息 */
+  message: string; /** 详细错误信息 */
+  detail?: string; /** 重试建议 */
+  retry: RetrySuggestion; /** 降级建议 */
+  fallback: FallbackSuggestion; /** 供应商原始错误 */
+  providerError?: {
+    provider: string;
+    code?: string;
+    message?: string;
+  };
+};
+/** 网关错误（兼容 OpenAI 错误格式） */
+type GatewayError = {
+  error: {
+    message: string;
+    type: string;
+    code: ErrorCode;
+    param?: string; /** 网关扩展字段 */
+    gateway?: GatewayErrorDetail;
+  };
+};
+/** HTTP 状态码映射 */
+declare const ERROR_STATUS_MAP: Record<ErrorCategory, number>;
+//#endregion
+//#region src/types/request.d.ts
+/**
+ * 统一请求类型定义
+ * 完全兼容 OpenAI API 格式，并扩展路由策略、优先级、预算限制等参数
+ */
+/** 消息角色 */
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+/** 消息内容类型 */
+type MessageContentType = 'text' | 'image_url';
+/** 消息内容项 */
+type MessageContentPart = {
+  type: MessageContentType;
+  text?: string;
+  image_url?: {
+    url: string;
+    detail?: 'auto' | 'low' | 'high';
+  };
+};
+/** 工具调用函数 */
+type ToolCallFunction = {
+  /** 调用名称 */name: string; /** 调用参数（JSON字符串） */
+  arguments: string;
+};
+/** 工具调用 */
+type ToolCall = {
+  /** 工具调用ID */id: string; /** 调用类型，固定为 function */
+  type: 'function'; /** 调用的函数 */
+  function: ToolCallFunction;
+};
+/** 聊天消息 */
+type ChatMessage = {
+  /** 消息角色 */role: MessageRole; /** 消息文本内容（与content二选一） */
+  content?: string | MessageContentPart[]; /** 工具调用列表（assistant角色） */
+  tool_calls?: ToolCall[]; /** 工具调用ID（tool角色） */
+  tool_call_id?: string; /** 消息名称 */
+  name?: string;
+};
+/** 函数定义 */
+type FunctionDefinition = {
+  /** 函数名称 */name: string; /** 函数描述 */
+  description?: string; /** 函数参数 JSON Schema */
+  parameters?: Record<string, unknown>;
+};
+/** 工具定义 */
+type ToolDefinition = {
+  /** 工具类型 */type: 'function'; /** 函数定义 */
+  function: FunctionDefinition;
+};
+/** 响应格式 */
+type ResponseFormat = {
+  type: 'text' | 'json_object' | 'json_schema';
+  json_schema?: Record<string, unknown>;
+};
+/** 路由策略扩展参数 */
+type RoutingExtension = {
+  /** 路由策略 */routingStrategy?: 'model-name' | 'cost-first' | 'performance-first' | 'quality-first'; /** 请求优先级 */
+  priority?: 'low' | 'normal' | 'high'; /** 预算限制（美元） */
+  budgetLimit?: number; /** 请求超时时间（毫秒） */
+  timeout?: number; /** 是否禁用缓存 */
+  noCache?: boolean; /** 调用者标签（用于成本归因） */
+  tags?: Record<string, string>;
+};
+/** 聊天补全请求（兼容 OpenAI ChatCompletion） */
+type ChatCompletionRequest = RoutingExtension & {
+  /** 模型名称或别名 */model: string; /** 消息列表 */
+  messages: ChatMessage[]; /** 生成温度 (0-2) */
+  temperature?: number; /** 核采样概率 */
+  top_p?: number; /** 生成数量 */
+  n?: number; /** 是否流式输出 */
+  stream?: boolean; /** 停止词 */
+  stop?: string | string[]; /** 最大输出 Token 数 */
+  max_tokens?: number; /** 存在惩罚 (-2 到 2) */
+  presence_penalty?: number; /** 频率惩罚 (-2 到 2) */
+  frequency_penalty?: number; /** 随机种子 */
+  seed?: number; /** 工具定义列表 */
+  tools?: ToolDefinition[]; /** 工具选择策略 */
+  tool_choice?: 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+      name: string;
+    };
+  }; /** 响应格式 */
+  response_format?: ResponseFormat; /** 用户标识 */
+  user?: string;
+};
+/** 文本补全请求（兼容 OpenAI Completion） */
+type CompletionRequest = RoutingExtension & {
+  model: string;
+  prompt: string | string[];
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  n?: number;
+  stream?: boolean;
+  stop?: string | string[];
+  presence_penalty?: number;
+  frequency_penalty?: number;
+  seed?: number;
+  user?: string;
+};
+/** 嵌入请求（兼容 OpenAI Embedding） */
+type EmbeddingRequest = RoutingExtension & {
+  model: string;
+  input: string | string[];
+  encoding_format?: 'float' | 'base64';
+  dimensions?: number;
+  user?: string;
+};
+//#endregion
+//#region src/types/response.d.ts
+/** 响应消息 */
+type ResponseMessage = {
+  role: 'assistant';
+  content: string | null;
+  tool_calls?: ToolCall[];
+};
+/** 补全选择项 */
+type ChatChoice = {
+  /** 选择项索引 */index: number; /** 消息内容 */
+  message: ResponseMessage; /** 结束原因 */
+  finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+};
+/** 流式补全增量 */
+type ChatChunkDelta = {
+  role?: 'assistant';
+  content?: string | null;
+  tool_calls?: Array<{
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+      name?: string;
+      arguments?: string;
+    };
+  }>;
+};
+/** 流式选择项 */
+type ChatStreamChoice = {
+  index: number;
+  delta: ChatChunkDelta;
+  finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+};
+/** Token 使用量 */
+type TokenUsage = {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+};
+/** 网关扩展响应字段 */
+type GatewayExtension = {
+  /** 实际使用的模型ID */gateway_model?: string; /** 实际使用的供应商 */
+  gateway_provider?: string; /** 请求延迟（毫秒） */
+  gateway_latency_ms?: number; /** 请求成本（美元） */
+  gateway_cost?: number; /** 是否命中缓存 */
+  gateway_cache_hit?: boolean; /** 路由决策信息 */
+  gateway_routing?: {
+    strategy: string;
+    original_model?: string;
+    routed_model: string;
+    routed_provider: string;
+  };
+};
+/** 聊天补全响应（兼容 OpenAI ChatCompletion） */
+type ChatCompletionResponse = GatewayExtension & {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: ChatChoice[];
+  usage: TokenUsage;
+  system_fingerprint?: string;
+};
+/** 流式聊天补全块 */
+type ChatCompletionChunk = GatewayExtension & {
+  id: string;
+  object: 'chat.completion.chunk';
+  created: number;
+  model: string;
+  choices: ChatStreamChoice[];
+};
+/** 文本补全选择项 */
+type CompletionChoice = {
+  index: number;
+  text: string;
+  finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+};
+/** 文本补全响应（兼容 OpenAI Completion） */
+type CompletionResponse = GatewayExtension & {
+  id: string;
+  object: 'text_completion';
+  created: number;
+  model: string;
+  choices: CompletionChoice[];
+  usage: TokenUsage;
+};
+/** 嵌入数据项 */
+type EmbeddingData = {
+  object: 'embedding';
+  index: number;
+  embedding: number[] | string;
+};
+/** 嵌入响应（兼容 OpenAI Embedding） */
+type EmbeddingResponse = GatewayExtension & {
+  id: string;
+  object: 'list';
+  created: number;
+  model: string;
+  data: EmbeddingData[];
+  usage: TokenUsage;
+};
+/** 模型信息（兼容 OpenAI Model） */
+type ModelInfo = {
+  id: string;
+  object: 'model';
+  created: number;
+  owned_by: string;
+};
+/** 模型列表响应 */
+type ModelListResponse = {
+  object: 'list';
+  data: ModelInfo[];
+};
+//#endregion
+//#region src/types/strategy.d.ts
+/**
+ * 执行策略类型定义
+ * 包含重试策略、超时策略、降级策略
+ */
+/** 重试策略 */
+type RetryStrategy = {
+  /** 最大重试次数（默认3次） */maxRetries: number; /** 初始重试间隔（毫秒，默认1000） */
+  initialInterval: number; /** 最大重试间隔（毫秒，默认30000） */
+  maxInterval: number; /** 退避乘数（默认2） */
+  multiplier: number; /** 可重试的HTTP状态码 */
+  retryableStatusCodes: number[]; /** 可重试的错误码 */
+  retryableErrorCodes: string[];
+};
+/** 超时策略 */
+type TimeoutStrategy = {
+  /** 连接超时（毫秒，默认10000） */connectTimeout: number; /** 读取超时（毫秒，默认60000） */
+  readTimeout: number; /** 写入超时（毫秒，默认10000） */
+  writeTimeout: number; /** 总请求超时（毫秒，默认120000） */
+  requestTimeout: number;
+};
+/** 降级动作类型 */
+type FallbackAction = 'fallback_model' | 'cache_result' | 'default_response' | 'reject';
+/** 降级策略 */
+type FallbackStrategy = {
+  /** 降级动作列表（按优先级排序） */actions: FallbackAction[]; /** 备用模型列表 */
+  fallbackModels: string[]; /** 是否允许返回缓存 */
+  allowCache: boolean; /** 默认响应内容 */
+  defaultResponse?: string; /** 最大降级次数 */
+  maxFallbacks: number;
+};
+/** 执行策略（组合重试、超时、降级） */
+type ExecutionStrategy = {
+  /** 重试策略 */retry: RetryStrategy; /** 超时策略 */
+  timeout: TimeoutStrategy; /** 降级策略 */
+  fallback: FallbackStrategy;
+};
+/** 默认重试策略 */
+declare const DEFAULT_RETRY_STRATEGY: RetryStrategy;
+/** 默认超时策略 */
+declare const DEFAULT_TIMEOUT_STRATEGY: TimeoutStrategy;
+/** 默认降级策略 */
+declare const DEFAULT_FALLBACK_STRATEGY: FallbackStrategy;
+/** 默认执行策略 */
+declare const DEFAULT_EXECUTION_STRATEGY: ExecutionStrategy;
+//#endregion
+//#region src/utils/cost.d.ts
+/**
+ * 成本计算工具函数
+ */
+/** 模型定价信息 */
+type ModelPricing = {
+  /** 输入 Token 价格（美元/千Token） */inputPrice: number; /** 输出 Token 价格（美元/千Token） */
+  outputPrice: number;
+};
+/** 计算单次请求成本 */
+declare function calculateCost(pricing: ModelPricing, inputTokens: number, outputTokens: number): number;
+/** 格式化成本显示 */
+declare function formatCost(cost: number): string;
+/** 计算预算使用百分比 */
+declare function budgetUsagePercent(used: number, limit: number): number;
+//#endregion
+//#region src/utils/crypto.d.ts
+/**
+ * 加密解密工具函数
+ * 使用 AES-256-GCM 算法加密 API 密钥等敏感数据
+ */
+/** 加密文本 */
+declare function encrypt(plaintext: string, secret: string): Promise<string>;
+/** 解密文本 */
+declare function decrypt(ciphertext: string, secret: string): Promise<string>;
+//#endregion
+//#region src/utils/token.d.ts
+/**
+ * Token 计数工具函数
+ * 提供基于字符数的粗略 Token 估算
+ */
+/** 粗略估算文本的 Token 数（中文约1.5字/Token，英文约4字符/Token） */
+declare function estimateTokens(text: string): number;
+/** 估算消息列表的 Token 数 */
+declare function estimateMessagesTokens(messages: Array<{
+  role: string;
+  content?: string | unknown[];
+}>): number;
+//#endregion
+//#region src/cache/cache.dto.d.ts
+/** 缓存条目响应 DTO */
+type CacheEntryResponseDTO = {
+  id: string;
+  requestHash: string;
+  requestVector: string | null;
+  responseData: string;
+  modelId: string;
+  similarityThreshold: number;
+  hitCount: number;
+  expiresAt: string;
+  createdAt: string;
+};
+/** 创建缓存条目请求 DTO */
+type CreateCacheEntryRequestDTO = {
+  requestHash: string;
+  requestVector?: string | null;
+  responseData: string;
+  modelId: string;
+  similarityThreshold?: number;
+  ttlSeconds?: number;
+};
+//#endregion
+//#region src/cache/cache.port.d.ts
+/** 缓存端口接口 */
+type CachePort = {
+  /** 根据请求哈希获取缓存条目 */getByHash(requestHash: string): Promise<Result<CacheEntryResponseDTO | null, DomainError>>; /** 创建缓存条目 */
+  create(input: CreateCacheEntryRequestDTO): Promise<Result<CacheEntryResponseDTO, DomainError>>; /** 记录缓存命中 */
+  recordHit(id: string): Promise<Result<CacheEntryResponseDTO, DomainError>>; /** 删除缓存条目 */
+  delete(id: string): Promise<Result<boolean, DomainError>>; /** 清理过期缓存 */
+  deleteExpired(): Promise<Result<number, DomainError>>;
+};
+/** 缓存端口令牌 */
+declare const CACHE_PORT_TOKEN: unique symbol;
+//#endregion
+//#region src/cache/cache.schema.d.ts
+/** 创建缓存条目的校验 Schema */
+declare const createCacheEntrySchema: z.ZodObject<{
+  requestHash: z.ZodString;
+  requestVector: z.ZodOptional<z.ZodString>;
+  responseData: z.ZodString;
+  modelId: z.ZodString;
+  similarityThreshold: z.ZodOptional<z.ZodNumber>;
+  ttlSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** 创建缓存条目的输入类型 */
+type CreateCacheEntryInput = z.infer<typeof createCacheEntrySchema>;
+//#endregion
+//#region src/cache/cache.types.d.ts
+/** 缓存策略配置 */
+type CachePolicy = {
+  enabled: boolean;
+  ttlSeconds: number;
+  similarityThreshold: number;
+};
+//#endregion
+//#region src/cache/cache.error.d.ts
+/** 缓存领域错误 */
+declare class CacheError extends DomainError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/cache/cache.event.d.ts
+/** 缓存命中事件 */
+declare class CacheHitEvent extends DomainEvent {
+  readonly cacheEntryId: string;
+  readonly modelId: string;
+  static readonly TYPE = "cache:hit";
+  readonly type = "cache:hit";
+  constructor(eventId: string, cacheEntryId: string, modelId: string);
+}
+//#endregion
+//#region src/cache/cache-entry.entity.d.ts
+type CacheEntryProps = {
+  requestHash: string;
+  requestVector: string | null;
+  responseData: string;
+  modelId: string;
+  similarityThreshold: number;
+  hitCount: number;
+  expiresAt: string;
+  createdAt: string;
+};
+/**
+ * 缓存条目实体
+ */
+declare class CacheEntryEntity extends Entity<CacheEntryProps> {
+  get requestHash(): string;
+  get requestVector(): string | null;
+  get responseData(): string;
+  get modelId(): string;
+  get similarityThreshold(): number;
+  get hitCount(): number;
+  get expiresAt(): string;
+  get createdAt(): string;
+  private constructor();
+  static create(id: string, props: Omit<CacheEntryProps, 'hitCount' | 'createdAt'> & {
+    ttlSeconds?: number;
+  }): CacheEntryEntity;
+  static reconstitute(id: string, props: CacheEntryProps): CacheEntryEntity;
+  /** 记录缓存命中 */
+  recordHit(): void;
+  /** 检查是否过期 */
+  isExpired(): boolean;
+}
+//#endregion
+//#region src/cache/cache-entry.mapper.d.ts
+/**
+ * 缓存条目应用层映射器
+ */
+declare const CacheEntryMapper: ApplicationMapper<CacheEntryEntity, CacheEntryResponseDTO>;
+//#endregion
+//#region src/cache/cache.repository.d.ts
+/**
+ * 缓存条目仓储接口
+ */
+type CacheRepository = {
+  /** 根据请求哈希获取缓存条目 */getByHash(requestHash: string): Promise<Result<CacheEntryEntity | null, DomainError>>; /** 创建缓存条目 */
+  create(entity: CacheEntryEntity): Promise<Result<CacheEntryEntity, DomainError>>; /** 记录缓存命中 */
+  recordHit(id: string): Promise<Result<CacheEntryEntity, DomainError>>; /** 删除缓存条目 */
+  delete(id: string): Promise<Result<boolean, DomainError>>; /** 清理过期缓存 */
+  deleteExpired(): Promise<Result<number, DomainError>>;
+};
+//#endregion
+//#region src/cache/cache.orm-entity.d.ts
+/**
+ * 缓存条目数据库行类型
+ */
+type CacheEntryRow = {
+  id: string;
+  requestHash: string;
+  requestVector: string | null;
+  responseData: string;
+  modelId: string;
+  similarityThreshold: number;
+  hitCount: number;
+  expiresAt: string;
+  createdAt: string;
+};
+//#endregion
+//#region src/cache/cache.orm-mapper.d.ts
+/**
+ * 缓存条目 ORM 映射器
+ */
+declare const CacheEntryOrmMapper: OrmMapper<CacheEntryEntity, CacheEntryRow>;
+//#endregion
+//#region src/cache/cache.orm-repository.d.ts
+/**
+ * 基于 Drizzle 的缓存条目仓储实现
+ */
+declare class DrizzleCacheRepository implements CacheRepository {
+  private readonly db;
+  private readonly schema;
+  constructor(db: any, schema: any);
+  /** 根据请求哈希获取缓存条目 */
+  getByHash(requestHash: string): Promise<Result<CacheEntryEntity | null, DomainError>>;
+  /** 创建缓存条目 */
+  create(entity: CacheEntryEntity): Promise<Result<CacheEntryEntity, DomainError>>;
+  /** 记录缓存命中 */
+  recordHit(id: string): Promise<Result<CacheEntryEntity, DomainError>>;
+  /** 删除缓存条目 */
+  delete(id: string): Promise<Result<boolean, DomainError>>;
+  /** 清理过期缓存 */
+  deleteExpired(): Promise<Result<number, DomainError>>;
+}
+//#endregion
+//#region src/cache/usecases/get-cache-entry.usecase.d.ts
+/**
+ * 获取缓存条目用例
+ *
+ * 根据请求哈希查询缓存条目，若条目已过期则自动删除并返回 null，
+ * 若条目有效则记录命中并返回实体
+ */
+declare class GetCacheEntryUseCase {
+  private readonly repository;
+  constructor(repository: CacheRepository);
+  execute(requestHash: string): Promise<Result<CacheEntryEntity | null, DomainError>>;
+}
+//#endregion
+//#region src/cache/usecases/create-cache-entry.usecase.d.ts
+/**
+ * 创建缓存条目用例
+ *
+ * 接收创建请求 DTO，构造实体并持久化到仓储
+ */
+declare class CreateCacheEntryUseCase {
+  private readonly repository;
+  constructor(repository: CacheRepository);
+  execute(input: CreateCacheEntryRequestDTO): Promise<Result<CacheEntryEntity, DomainError>>;
+}
+//#endregion
+//#region src/cache/usecases/record-cache-hit.usecase.d.ts
+/**
+ * 记录缓存命中用例
+ *
+ * 对指定缓存条目增加命中计数
+ */
+declare class RecordCacheHitUseCase {
+  private readonly repository;
+  constructor(repository: CacheRepository);
+  execute(id: string): Promise<Result<CacheEntryEntity, DomainError>>;
+}
+//#endregion
+//#region src/cache/usecases/delete-cache-entry.usecase.d.ts
+/**
+ * 删除缓存条目用例
+ *
+ * 根据条目 ID 从仓储中删除指定缓存条目
+ */
+declare class DeleteCacheEntryUseCase {
+  private readonly repository;
+  constructor(repository: CacheRepository);
+  execute(id: string): Promise<Result<boolean, DomainError>>;
+}
+//#endregion
+//#region src/cache/usecases/cleanup-cache-entries.usecase.d.ts
+/**
+ * 清理过期缓存条目用例
+ *
+ * 删除仓储中所有已过期的缓存条目，返回清理数量
+ */
+declare class CleanupCacheEntriesUseCase {
+  private readonly repository;
+  constructor(repository: CacheRepository);
+  execute(): Promise<Result<number, DomainError>>;
+}
+//#endregion
+//#region src/cache/cache.memory-adapter.d.ts
+/**
+ * 内存缓存适配器（Strategy M）
+ *
+ * 使用 Map 存储缓存条目，无外部依赖，适用于轻量级场景
+ */
+declare class CacheMemoryAdapter implements CachePort {
+  /** 内存存储 */
+  private readonly store;
+  /** 构造函数 */
+  constructor();
+  /** 根据请求哈希获取缓存条目 */
+  getByHash(requestHash: string): Promise<Result<CacheEntryResponseDTO | null, DomainError>>;
+  /** 创建缓存条目 */
+  create(input: CreateCacheEntryRequestDTO): Promise<Result<CacheEntryResponseDTO, DomainError>>;
+  /** 记录缓存命中 */
+  recordHit(id: string): Promise<Result<CacheEntryResponseDTO, DomainError>>;
+  /** 删除缓存条目 */
+  delete(id: string): Promise<Result<boolean, DomainError>>;
+  /** 清理过期缓存 */
+  deleteExpired(): Promise<Result<number, DomainError>>;
+}
+//#endregion
+//#region src/cache/cache.sqlite-adapter.d.ts
+/**
+ * 创建 SQLite 缓存端口适配器（Strategy L）
+ *
+ * 封装 DrizzleCacheRepository → UseCase 组合 → CachePortAdapter 链路
+ *
+ * @param db - Drizzle 数据库实例
+ * @param schema - 数据库 Schema 对象（需包含 cacheEntries 表）
+ * @returns CachePort 实例
+ */
+declare function createCacheSqliteAdapter(db: any, schema: any): CachePort;
+//#endregion
+//#region src/ports/event-publisher.port.d.ts
+/**
+ * 事件订阅者类型
+ *
+ * 接收领域事件的回调函数。
+ *
+ * @param event - 领域事件
+ */
+type EventSubscriber = (event: DomainEvent) => void;
+/**
+ * 事件发布端口接口
+ *
+ * 所有领域事件发布的统一入口，
+ * 支持发布/订阅/取消订阅操作。
+ */
+type EventPublisherPort = {
+  /**
+   * 发布领域事件
+   *
+   * @param event - 要发布的领域事件
+   */
+  publish(event: DomainEvent): void;
+  /**
+   * 订阅领域事件
+   *
+   * @param eventType - 事件类型标识
+   * @param subscriber - 事件订阅者回调
+   */
+  subscribe(eventType: string, subscriber: EventSubscriber): void;
+  /**
+   * 取消订阅领域事件
+   *
+   * @param eventType - 事件类型标识
+   * @param subscriber - 要移除的订阅者回调
+   */
+  unsubscribe(eventType: string, subscriber: EventSubscriber): void;
+};
+/**
+ * 事件发布端口 DI 令牌
+ */
+declare const EVENT_PUBLISHER_PORT_TOKEN: unique symbol;
+//#endregion
+export { CACHE_PORT_TOKEN, CacheEntryEntity, CacheEntryMapper, CacheEntryOrmMapper, type CacheEntryResponseDTO, type CacheEntryRow, CacheError, CacheHitEvent, CacheMemoryAdapter, type CachePolicy, type CachePort, type CacheRepository, type ChatChoice, type ChatChunkDelta, type ChatCompletionChunk, type ChatCompletionRequest, type ChatCompletionResponse, type ChatMessage, type ChatStreamChoice, CleanupCacheEntriesUseCase, type CompletionChoice, type CompletionRequest, type CompletionResponse, type CreateCacheEntryInput, type CreateCacheEntryRequestDTO, CreateCacheEntryUseCase, DEFAULT_EXECUTION_STRATEGY, DEFAULT_FALLBACK_STRATEGY, DEFAULT_RETRY_STRATEGY, DEFAULT_TIMEOUT_STRATEGY, DeleteCacheEntryUseCase, DrizzleCacheRepository, ERROR_STATUS_MAP, EVENT_PUBLISHER_PORT_TOKEN, type EmbeddingData, type EmbeddingRequest, type EmbeddingResponse, type ErrorCategory, ErrorCode, type EventPublisherPort, type EventSubscriber, type ExecutionStrategy, type FallbackAction, type FallbackStrategy, type FunctionDefinition, type GatewayError, type GatewayErrorDetail, type GatewayExtension, GetCacheEntryUseCase, type MessageContentPart, type MessageContentType, type MessageRole, type ModelInfo, type ModelListResponse, type ModelPricing, RecordCacheHitUseCase, type ResponseFormat, type ResponseMessage, type RetryStrategy, type RoutingExtension, type TimeoutStrategy, type TokenUsage, type ToolCall, type ToolCallFunction, type ToolDefinition, budgetUsagePercent, calculateCost, createCacheEntrySchema, createCacheSqliteAdapter, decrypt, encrypt, estimateMessagesTokens, estimateTokens, formatCost };

package/dist/index.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{DomainError as t}from"@longzai-intelligence/error";import{DomainEvent as n,Entity as r,failure as i,success as a}from"@longzai-intelligence/shared-kernel";import{eq as o,lt as s}from"drizzle-orm";let c=function(e){return e.INVALID_REQUEST=`invalid_request`,e.AUTHENTICATION_FAILED=`authentication_failed`,e.PERMISSION_DENIED=`permission_denied`,e.MODEL_NOT_FOUND=`model_not_found`,e.BUDGET_EXCEEDED=`budget_exceeded`,e.RATE_LIMIT_EXCEEDED=`rate_limit_exceeded`,e.INVALID_API_KEY=`invalid_api_key`,e.INTERNAL_ERROR=`internal_error`,e.ROUTING_ERROR=`routing_error`,e.DATABASE_ERROR=`database_error`,e.CACHE_ERROR=`cache_error`,e.PROVIDER_UNAVAILABLE=`provider_unavailable`,e.PROVIDER_RATE_LIMITED=`provider_rate_limited`,e.PROVIDER_TIMEOUT=`provider_timeout`,e.PROVIDER_ERROR=`provider_error`,e.MODEL_OVERLOADED=`model_overloaded`,e.CONTEXT_LENGTH_EXCEEDED=`context_length_exceeded`,e}({});const l={client:400,server:500,provider:502},u={maxRetries:3,initialInterval:1e3,maxInterval:3e4,multiplier:2,retryableStatusCodes:[429,500,502,503,504],retryableErrorCodes:[`provider_timeout`,`provider_unavailable`,`model_overloaded`]},d={connectTimeout:1e4,readTimeout:6e4,writeTimeout:1e4,requestTimeout:12e4},f={actions:[`fallback_model`,`cache_result`,`reject`],fallbackModels:[],allowCache:!0,maxFallbacks:2},p={retry:u,timeout:d,fallback:f};function m(e,t,n){let r=t/1e3*e.inputPrice,i=n/1e3*e.outputPrice;return Number((r+i).toFixed(8))}function h(e){return e<.01?`$${e.toFixed(6)}`:e<1?`$${e.toFixed(4)}`:`$${e.toFixed(2)}`}function g(e,t){return t<=0?0:Math.min(100,Number((e/t*100).toFixed(2)))}const _=`AES-GCM`;function v(e){let t=``;for(let n=0;n<e.length;n++)t+=String.fromCharCode(e[n]);return btoa(t)}function y(e){let t=atob(e),n=new Uint8Array(t.length);for(let e=0;e<t.length;e++)n[e]=t.charCodeAt(e);return n}async function b(e){let t=new TextEncoder,n=await crypto.subtle.importKey(`raw`,t.encode(e),{name:`PBKDF2`},!1,[`deriveKey`]);return crypto.subtle.deriveKey({name:`PBKDF2`,salt:t.encode(`model-gateway-salt`),iterations:1e5,hash:`SHA-256`},n,{name:_,length:256},!1,[`encrypt`,`decrypt`])}async function x(e,t){let n=await b(t),r=new TextEncoder,i=crypto.getRandomValues(new Uint8Array(12)),a=await crypto.subtle.encrypt({name:_,iv:i,tagLength:128},n,r.encode(e)),o=new Uint8Array(i.length+new Uint8Array(a).length);return o.set(i),o.set(new Uint8Array(a),i.length),v(o)}async function S(e,t){let n=await b(t),r=y(e),i=r.slice(0,12),a=r.slice(12),o=await crypto.subtle.decrypt({name:_,iv:i,tagLength:128},n,a);return new TextDecoder().decode(o)}function C(e){if(!e)return 0;let t=0,n=0;for(let r of e)/[\u4e00-\u9fff\u3400-\u4dbf]/.test(r)?t++:n++;return Math.ceil(t/1.5+n/4)}function w(e){let t=0;for(let n of e)if(t+=4,typeof n.content==`string`)t+=C(n.content);else if(Array.isArray(n.content))for(let e of n.content)e&&typeof e==`object`&&`text`in e&&typeof e.text==`string`&&(t+=C(e.text));return t}const T=Symbol(`CachePort`),E=e.object({requestHash:e.string().min(1),requestVector:e.string().optional(),responseData:e.string().min(1),modelId:e.string().min(1),similarityThreshold:e.number().min(0).max(1).optional(),ttlSeconds:e.number().min(0).optional()});var D=class extends t{constructor(e){super(e,`CACHE_ERROR`),this.name=`CacheError`}},O=class e extends n{cacheEntryId;modelId;static TYPE=`cache:hit`;type=e.TYPE;constructor(e,t,n){super(e),this.cacheEntryId=t,this.modelId=n}},k=class e extends r{get requestHash(){return this._props.requestHash}get requestVector(){return this._props.requestVector}get responseData(){return this._props.responseData}get modelId(){return this._props.modelId}get similarityThreshold(){return this._props.similarityThreshold}get hitCount(){return this._props.hitCount}get expiresAt(){return this._props.expiresAt}get createdAt(){return this._props.createdAt}constructor(e,t){super(e,t)}static create(t,n){let r=new Date,i=(n.ttlSeconds??3600)*1e3,a=n.expiresAt??new Date(r.getTime()+i).toISOString();return new e(t,{requestHash:n.requestHash,requestVector:n.requestVector,responseData:n.responseData,modelId:n.modelId,similarityThreshold:n.similarityThreshold,hitCount:0,expiresAt:a,createdAt:r.toISOString()})}static reconstitute(t,n){return new e(t,n)}recordHit(){this.updateProps(`hitCount`,this._props.hitCount+1)}isExpired(){return new Date(this._props.expiresAt)<new Date}};const A={toDTO(e){return{id:e.id,requestHash:e.requestHash,requestVector:e.requestVector,responseData:e.responseData,modelId:e.modelId,similarityThreshold:e.similarityThreshold,hitCount:e.hitCount,expiresAt:e.expiresAt,createdAt:e.createdAt}},toDTOList(e){return e.map(e=>this.toDTO(e))}},j={toDomain(e){return k.reconstitute(e.id,{requestHash:e.requestHash,requestVector:e.requestVector,responseData:e.responseData,modelId:e.modelId,similarityThreshold:e.similarityThreshold,hitCount:e.hitCount,expiresAt:e.expiresAt,createdAt:e.createdAt})},toOrm(e){return{id:e.id,requestHash:e.requestHash,requestVector:e.requestVector,responseData:e.responseData,modelId:e.modelId,similarityThreshold:e.similarityThreshold,hitCount:e.hitCount,expiresAt:e.expiresAt,createdAt:e.createdAt}}};var M=class{db;schema;constructor(e,t){this.db=e,this.schema=t}async getByHash(e){try{let t=(await this.db.select().from(this.schema.cacheEntries).where(o(this.schema.cacheEntries.requestHash,e)))[0]??null;return a(t?j.toDomain(t):null)}catch(e){return i(new D(`查询缓存条目失败: ${e.message}`))}}async create(e){try{let t=j.toOrm(e);return await this.db.insert(this.schema.cacheEntries).values(t),a(e)}catch(e){return i(new D(`创建缓存条目失败: ${e.message}`))}}async recordHit(e){try{let t=(await this.db.select().from(this.schema.cacheEntries).where(o(this.schema.cacheEntries.id,e)))[0];if(!t)return i(new D(`缓存条目不存在: ${e}`));let n=j.toDomain(t);return n.recordHit(),await this.db.update(this.schema.cacheEntries).set({hitCount:n.hitCount}).where(o(this.schema.cacheEntries.id,e)),a(n)}catch(e){return i(new D(`记录缓存命中失败: ${e.message}`))}}async delete(e){try{return await this.db.delete(this.schema.cacheEntries).where(o(this.schema.cacheEntries.id,e)),a(!0)}catch(e){return i(new D(`删除缓存条目失败: ${e.message}`))}}async deleteExpired(){try{let e=new Date().toISOString();return a((await this.db.delete(this.schema.cacheEntries).where(s(this.schema.cacheEntries.expiresAt,e)))?.changes??0)}catch(e){return i(new D(`清理过期缓存失败: ${e.message}`))}}},N=class{repository;constructor(e){this.repository=e}async execute(e){let t=await this.repository.getByHash(e);if(t.isFailure)return t;let n=t.value;if(!n)return a(null);if(n.isExpired())return await this.repository.delete(n.id),a(null);let r=await this.repository.recordHit(n.id);return r.isFailure?r:a(r.value)}},P=class{repository;constructor(e){this.repository=e}async execute(e){try{let t=`cache_${Date.now()}_${Math.random().toString(36).substring(2,9)}`,n=k.create(t,{requestHash:e.requestHash,requestVector:e.requestVector??null,responseData:e.responseData,modelId:e.modelId,similarityThreshold:e.similarityThreshold??.95,ttlSeconds:e.ttlSeconds,expiresAt:new Date(Date.now()+(e.ttlSeconds??3600)*1e3).toISOString()});return this.repository.create(n)}catch(e){return i(new D(`创建缓存条目失败: ${e.message}`))}}},F=class{repository;constructor(e){this.repository=e}async execute(e){return this.repository.recordHit(e)}},I=class{repository;constructor(e){this.repository=e}async execute(e){return this.repository.delete(e)}},L=class{repository;constructor(e){this.repository=e}async execute(){return this.repository.deleteExpired()}},R=class{store=new Map;constructor(){}async getByHash(e){try{for(let t of this.store.values())if(t.requestHash===e)return t.isExpired()?(this.store.delete(t.id),a(null)):(t.recordHit(),a(A.toDTO(t)));return a(null)}catch(e){return i(new D(`内存缓存查询失败: ${e.message}`))}}async create(e){try{let t=`cache_${Date.now()}_${Math.random().toString(36).substring(2,9)}`,n=k.create(t,{requestHash:e.requestHash,requestVector:e.requestVector??null,responseData:e.responseData,modelId:e.modelId,similarityThreshold:e.similarityThreshold??.95,ttlSeconds:e.ttlSeconds,expiresAt:new Date(Date.now()+(e.ttlSeconds??3600)*1e3).toISOString()});return this.store.set(t,n),a(A.toDTO(n))}catch(e){return i(new D(`内存缓存创建失败: ${e.message}`))}}async recordHit(e){try{let t=this.store.get(e);return t?(t.recordHit(),a(A.toDTO(t))):i(new D(`缓存条目不存在: ${e}`))}catch(e){return i(new D(`内存缓存命中记录失败: ${e.message}`))}}async delete(e){try{return a(this.store.delete(e))}catch(e){return i(new D(`内存缓存删除失败: ${e.message}`))}}async deleteExpired(){try{let e=0;for(let[t,n]of this.store.entries())n.isExpired()&&(this.store.delete(t),e++);return a(e)}catch(e){return i(new D(`内存缓存清理失败: ${e.message}`))}}},z=class{getCacheEntry;createCacheEntry;recordCacheHit;deleteCacheEntry;cleanupCacheEntries;constructor(e){this.getCacheEntry=new N(e),this.createCacheEntry=new P(e),this.recordCacheHit=new F(e),this.deleteCacheEntry=new I(e),this.cleanupCacheEntries=new L(e)}async getByHash(e){let t=await this.getCacheEntry.execute(e);if(t.isFailure)return t;let n=t.value;return a(n?A.toDTO(n):null)}async create(e){let t=await this.createCacheEntry.execute(e);return t.isFailure?t:a(A.toDTO(t.value))}async recordHit(e){let t=await this.recordCacheHit.execute(e);return t.isFailure?t:a(A.toDTO(t.value))}async delete(e){return this.deleteCacheEntry.execute(e)}async deleteExpired(){return this.cleanupCacheEntries.execute()}};function B(e,t){return new z(new M(e,t))}const V=Symbol(`EVENT_PUBLISHER_PORT_TOKEN`);export{T as CACHE_PORT_TOKEN,k as CacheEntryEntity,A as CacheEntryMapper,j as CacheEntryOrmMapper,D as CacheError,O as CacheHitEvent,R as CacheMemoryAdapter,L as CleanupCacheEntriesUseCase,P as CreateCacheEntryUseCase,p as DEFAULT_EXECUTION_STRATEGY,f as DEFAULT_FALLBACK_STRATEGY,u as DEFAULT_RETRY_STRATEGY,d as DEFAULT_TIMEOUT_STRATEGY,I as DeleteCacheEntryUseCase,M as DrizzleCacheRepository,l as ERROR_STATUS_MAP,V as EVENT_PUBLISHER_PORT_TOKEN,c as ErrorCode,N as GetCacheEntryUseCase,F as RecordCacheHitUseCase,g as budgetUsagePercent,m as calculateCost,E as createCacheEntrySchema,B as createCacheSqliteAdapter,S as decrypt,x as encrypt,w as estimateMessagesTokens,C as estimateTokens,h as formatCost};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@longzai-intelligence-model-gateway/core",
+  "version": "0.0.1",
+  "description": "Core types and utilities for Model Gateway - AI model routing, rate limiting, and observability",
+  "private": false,
+  "license": "UNLICENSED",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsgo --build tsconfig/build.json && resolve-aliases -p tsconfig/build.json",
+    "build:prod": "NODE_ENV=production tsdown",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "tsgo --noEmit -p tsconfig/app.json",
+    "typecheck:node": "tsgo --noEmit -p tsconfig/node.json",
+    "typecheck:test": "tsgo --noEmit -p tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@longzai-intelligence/shared-kernel": "^0.1.4",
+    "@longzai-intelligence/error": "^0.0.5",
+    "drizzle-orm": "^0.38.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {}
+}