@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/logger/Logger.ts

@@ -1,186 +0,0 @@
-import pino from "pino";
-import "pino-pretty";
-import "pino-roll";
-import { AsyncLocalStorage } from "async_hooks";
-
-export interface LoggerContext {
-  "x-user-id"?: string;
-  "x-tenant-id"?: string;
-  "x-request-id"?: string;
-  "x-task-id"?: string;
-  "x-thread-id"?: string;
-}
-
-export interface LoggerOptions {
-  name?: string;
-  serviceName?: string;
-  context?: LoggerContext;
-}
-
-/**
- * 单例的Pino日志工厂类，管理底层pino实例
- */
-class PinoLoggerFactory {
-  private static instance: PinoLoggerFactory;
-  private pinoLogger: pino.Logger;
-
-  private constructor() {
-    const isProd = process.env.NODE_ENV === "production";
-
-    const loggerConfig: pino.LoggerOptions = {
-      // 自定义时间戳格式
-      timestamp: () => `,"@timestamp":"${new Date().toISOString()}"`,
-
-      // 关闭默认的时间戳键
-      base: {
-        "@version": "1",
-        app_name: "lattice",
-        service_name: "lattice/graph-server",
-        thread_name: "main",
-        logger_name: "lattice-graph-logger",
-      },
-
-      formatters: {
-        level: (label, number) => {
-          return {
-            level: label.toUpperCase(),
-            level_value: number * 1000,
-          };
-        },
-      },
-    };
-
-    // 生产环境使用文件日志
-    if (isProd) {
-      try {
-        this.pinoLogger = pino(
-          loggerConfig,
-          pino.transport({
-            target: "pino-roll",
-            options: {
-              file: "./logs/fin_ai_graph_server",
-              frequency: "daily",
-              mkdir: true,
-            },
-          })
-        );
-      } catch (error) {
-        console.error(
-          "无法初始化 pino-roll 日志记录器，回退到控制台日志",
-          error
-        );
-        // 回退到开发环境的配置
-        this.pinoLogger = pino({
-          ...loggerConfig,
-          transport: {
-            target: "pino-pretty",
-            options: {
-              colorize: true,
-            },
-          },
-        });
-      }
-    } else {
-      // 开发环境使用格式化输出
-      this.pinoLogger = pino({
-        ...loggerConfig,
-        transport: {
-          target: "pino-pretty",
-          options: {
-            colorize: true,
-          },
-        },
-      });
-    }
-  }
-
-  public static getInstance(): PinoLoggerFactory {
-    if (!PinoLoggerFactory.instance) {
-      PinoLoggerFactory.instance = new PinoLoggerFactory();
-    }
-    return PinoLoggerFactory.instance;
-  }
-
-  public getPinoLogger(): pino.Logger {
-    return this.pinoLogger;
-  }
-}
-
-/**
- * Logger类，可以创建多个实例，每个实例有自己的上下文
- */
-export class Logger {
-  private context: LoggerContext;
-  private name: string;
-  private serviceName: string;
-
-  constructor(options?: LoggerOptions) {
-    this.context = options?.context || {};
-    this.name = options?.name || "lattice-graph-logger";
-    this.serviceName = options?.serviceName || "lattice/graph-server";
-  }
-
-  /**
-   * 获取合并了上下文的日志对象
-   * @param additionalContext 额外的上下文数据
-   * @returns 带有上下文的pino日志对象
-   */
-  private getContextualLogger(additionalContext?: object): pino.Logger {
-    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
-
-    // 合并Logger实例的上下文和额外上下文
-    const contextObj = {
-      "x-user-id": this.context["x-user-id"] || "",
-      "x-tenant-id": this.context["x-tenant-id"] || "",
-      "x-request-id": this.context["x-request-id"] || "",
-      "x-task-id": this.context["x-task-id"] || "",
-      "x-thread-id": this.context["x-thread-id"] || "",
-      service_name: this.serviceName,
-      logger_name: this.name,
-      ...additionalContext,
-    };
-
-    // 创建带有上下文的子日志记录器
-    return pinoLogger.child(contextObj);
-  }
-
-  info(msg: string, obj?: object): void {
-    this.getContextualLogger(obj).info(msg);
-  }
-
-  error(msg: string, obj?: object | Error): void {
-    this.getContextualLogger(obj).error(msg);
-  }
-
-  warn(msg: string, obj?: object): void {
-    this.getContextualLogger(obj).warn(msg);
-  }
-
-  debug(msg: string, obj?: object): void {
-    this.getContextualLogger(obj).debug(msg);
-  }
-
-  /**
-   * 更新Logger实例的上下文
-   */
-  updateContext(context: Partial<LoggerContext>): void {
-    this.context = {
-      ...this.context,
-      ...context,
-    };
-  }
-
-  /**
-   * 创建一个新的Logger实例，继承当前Logger的上下文
-   */
-  child(options: Partial<LoggerOptions>): Logger {
-    return new Logger({
-      name: options.name || this.name,
-      serviceName: options.serviceName || this.serviceName,
-      context: {
-        ...this.context,
-        ...options.context,
-      },
-    });
-  }
-}

package/src/router/MessageContext.ts

@@ -1,14 +0,0 @@
-import type { InboundMessage, Binding } from "@axiom-lattice/protocols";
-
-export interface MessageContext {
-  inboundMessage: InboundMessage;
-  binding?: Binding;
-  result?: string;
-  error?: Error;
-  metadata: Record<string, unknown>;
-}
-
-export type MessageMiddleware = (
-  ctx: MessageContext,
-  next: () => Promise<void>,
-) => Promise<void>;

package/src/router/MessageRouter.ts

@@ -1,490 +0,0 @@
-import {
-  getStoreLattice,
-  agentInstanceManager,
-} from "@axiom-lattice/core";
-import type {
-  InboundMessage,
-  DispatchResult,
-  BindingRegistry,
-  Binding,
-  ChannelInstallationStore,
-} from "@axiom-lattice/protocols";
-import { ChannelAdapterRegistry } from "../channels/registry";
-import type { MessageContext, MessageMiddleware } from "./MessageContext";
-import { randomUUID } from "crypto";
-
-export class BindingNotFoundError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "BindingNotFoundError";
-  }
-}
-
-/**
- * Configuration for {@link MessageRouter}.
- *
- * @param middlewares - Ordered middleware chain executed before dispatch
- * @param bindingRegistry - Resolves sender-to-agent bindings
- * @param adapterRegistry - Registry of {@link ChannelAdapter} implementations
- * @param installationStore - Persisted channel installation configs
- */
-export interface MessageRouterConfig {
-  middlewares: MessageMiddleware[];
-  bindingRegistry: BindingRegistry;
-  adapterRegistry: ChannelAdapterRegistry;
-  installationStore: ChannelInstallationStore;
-}
-
-/**
- * Core message router for external channel integration.
- *
- * Receives normalized {@link InboundMessage} objects from channel adapters,
- * resolves the target agent via {@link BindingRegistry}, manages thread
- * lifecycle, and sends AI responses back to the channel via
- * `ChannelAdapter.sendReply`.
- *
- * ## Reply flow
- *
- * The router uses a counter-based deduplication scheme on the internal
- * {@link Agent.reply:ready} event:
- *
- * 1. Before `agent.addMessage()`, it subscribes to `reply:ready` on the agent.
- * 2. Multiple concurrent dispatches on the same thread increment a counter;
- *    only the first registers the `EventEmitter.once` listener.
- * 3. When `reply:ready` fires, the callback extracts the last AI message from
- *    the LangGraph state and sends it via `ChannelAdapter.sendReply`.
- * 4. The counter is decremented; the subscription is only removed when the
- *    counter reaches 0.
- * 5. Stale subscriptions are cleaned up after a 1-hour timeout.
- *
- * The `replyTarget` is carried through by injecting `_replyTarget` into
- * `custom_run_config` on {@link Agent.addMessage}, and retrieved from the
- * `reply:ready` event payload.
- *
- * @see {@link ChannelAdapter.sendReply}
- * @see {@link InboundMessage.replyTarget}
- */
-export class MessageRouter {
-  private middlewares: MessageMiddleware[];
-  private bindingRegistry: BindingRegistry;
-  private adapterRegistry: ChannelAdapterRegistry;
-  private installationStore: ChannelInstallationStore;
-
-  /**
-   * Tracks reply subscriptions per thread+channel to avoid duplicate
-   * `subscribeOnce` registrations and ensure proper cleanup.
-   *
-   * Key format: `{threadId}:{adapterChannel}:reply`
-   */
-  private _replySubs: Map<string, { count: number; timer: NodeJS.Timeout }> = new Map();
-
-  constructor(config: MessageRouterConfig) {
-    this.middlewares = [...config.middlewares];
-    this.bindingRegistry = config.bindingRegistry;
-    this.adapterRegistry = config.adapterRegistry;
-    this.installationStore = config.installationStore;
-  }
-
-  /**
-   * Register an additional middleware at the end of the chain.
-   *
-   * @param middleware - A {@link MessageMiddleware} function
-   */
-  use(middleware: MessageMiddleware): void {
-    this.middlewares.push(middleware);
-  }
-
-  /**
-   * Dispatch an inbound channel message to the bound agent.
-   *
-   * Full pipeline: middleware chain → binding resolution → thread lifecycle
-   * → agent.addMessage() → (async) reply via {@link ChannelAdapter.sendReply}.
-   *
-   * If the message has a {@link InboundMessage.replyTarget}, the router subscribes
-   * to the agent's `reply:ready` event before enqueuing the message, and sends
-   * the AI response back to the channel when it arrives.
-   *
-   * @param message - Normalized inbound message from a channel adapter
-   * @returns {@link DispatchResult} with success status, bindingId, and threadId
-   */
-  async dispatch(message: InboundMessage): Promise<DispatchResult> {
-    const ctx: MessageContext = {
-      inboundMessage: message,
-      metadata: {},
-    };
-
-    let binding: Binding | null = null;
-    let threadId: string | undefined;
-    let agentId: string | undefined;
-
-    try {
-      await this.runMiddlewares(ctx, async () => {
-        // Resolve tenantId from installation if not provided
-        const tenantId = message.tenantId
-          || (await this.installationStore.getInstallationById(message.channelInstallationId))?.tenantId;
-
-        if (!tenantId) {
-          console.error({
-            event: "dispatch:error",
-            error: "tenantId missing",
-            channel: message.channel,
-            channelInstallationId: message.channelInstallationId,
-            senderId: message.sender.id,
-          }, "tenantId is required");
-          throw new Error(
-            "tenantId is required: provide it in the message or ensure the channelInstallation has a tenantId"
-          );
-        }
-
-        console.log({ event: "dispatch:start", channel: message.channel, senderId: message.sender.id, tenantId }, "Message dispatch started");
-
-        // 检查 adapter 是否支持自定义 thread 策略
-        const adapter = this.adapterRegistry.get(message.channel);
-        const hasAdapterThreadStrategy = !!adapter?.resolveThreadId;
-
-        binding = await this.bindingRegistry.resolve({
-          channel: message.channel,
-          senderId: message.sender.id,
-          channelInstallationId: message.channelInstallationId,
-          tenantId,
-        });
-
-        const installation = await this.installationStore.getInstallationById(
-          message.channelInstallationId,
-        );
-
-        if (!binding) {
-          if (installation?.rejectWhenNoBinding) {
-            console.warn({
-              event: "dispatch:no_binding",
-              channel: message.channel,
-              senderId: message.sender.id,
-              tenantId,
-              channelInstallationId: message.channelInstallationId,
-            }, "No binding found and rejectWhenNoBinding is enabled");
-            throw new BindingNotFoundError(
-              `No binding for sender "${message.sender.id}" on channel "${message.channel}"`,
-            );
-          }
-
-          if (installation?.fallbackAgentId) {
-            console.warn({
-              event: "dispatch:fallback",
-              channel: message.channel,
-              senderId: message.sender.id,
-              fallbackAgentId: installation.fallbackAgentId,
-            }, "No binding found, falling back to fallbackAgentId");
-            binding = {
-              id: "fallback",
-              channel: message.channel,
-              channelInstallationId: message.channelInstallationId,
-              tenantId,
-              senderId: message.sender.id,
-              agentId: installation.fallbackAgentId,
-              threadId: undefined,
-              threadMode: "fixed" as const,
-              enabled: true,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            };
-          } else if (!hasAdapterThreadStrategy) {
-            // 只有当 adapter 没有自定义 thread 策略且没有 fallback 时才报错
-            console.error({
-              event: "dispatch:no_fallback",
-              channel: message.channel,
-              senderId: message.sender.id,
-              tenantId,
-            }, "No binding found and no fallbackAgentId configured");
-            throw new BindingNotFoundError(
-              `No binding for sender "${message.sender.id}" and no fallback configured`,
-            );
-          }
-        }
-
-        ctx.binding = binding ?? undefined;
-
-        if (binding) {
-          console.log({
-            event: "dispatch:binding",
-            bindingId: binding.id,
-            agentId: binding.agentId,
-            threadId: binding.threadId,
-            threadMode: binding.threadMode,
-            workspaceId: binding.workspaceId,
-            projectId: binding.projectId,
-          }, "Binding resolved");
-
-          if (!binding.enabled) {
-            console.warn({
-              event: "dispatch:binding_disabled",
-              bindingId: binding.id,
-              agentId: binding.agentId,
-              senderId: message.sender.id,
-            }, "Binding is disabled, rejecting message");
-            throw new BindingNotFoundError(
-              `Binding for sender "${message.sender.id}" is disabled`,
-            );
-          }
-        }
-
-        // 确定 agentId
-        agentId = binding?.agentId ?? installation?.fallbackAgentId;
-        if (!agentId) {
-          throw new BindingNotFoundError(
-            `No agent configured for sender "${message.sender.id}"`,
-          );
-        }
-
-        // 优先使用 adapter 的自定义 thread 策略
-        if (hasAdapterThreadStrategy) {
-          const resolvedThreadId = await adapter!.resolveThreadId!(message, binding);
-          threadId = resolvedThreadId;
-          console.log({
-            event: "dispatch:thread:adapter",
-            threadId,
-            channel: message.channel,
-            adapterChannel: adapter!.channel,
-          }, "Thread resolved by adapter strategy");
-
-          // 确保 thread 存在（adapter 的策略可能有重复，例如同一天）
-          const threadStore = getStoreLattice("default", "thread").store;
-          try {
-            await threadStore.createThread(
-              tenantId!,
-              agentId,
-              threadId,
-              {
-                metadata: {
-                  channel: message.channel,
-                  channelInstallationId: message.channelInstallationId,
-                  senderId: message.sender.id,
-                  bindingId: binding?.id,
-                  ...(message.conversation ? {
-                    conversationId: message.conversation.id,
-                    conversationType: message.conversation.type,
-                  } : {}),
-                },
-              },
-            );
-            console.log({
-              event: "dispatch:thread:adapter:created",
-              threadId,
-            }, "Thread created by adapter strategy");
-          } catch {
-            // Thread already exists from a previous message — 复用
-            console.log({
-              event: "dispatch:thread:adapter:reuse",
-              threadId,
-            }, "Thread already exists, reusing");
-          }
-        } else if (binding) {
-          // 默认策略：per_conversation 总是创建新线程，fixed 复用已有线程
-          if (binding.threadMode === "per_conversation") {
-            threadId = undefined; // 创建新线程
-          } else {
-            threadId = binding.threadId; // 复用 fixed 线程
-          }
-        }
-
-        if (!threadId) {
-          const threadStore = getStoreLattice("default", "thread").store;
-          const newThreadId = randomUUID();
-          console.log({
-            event: "dispatch:thread:create",
-            agentId,
-            newThreadId,
-            tenantId: tenantId!,
-          }, "Creating new thread for binding");
-          const newThread = await threadStore.createThread(
-            tenantId!,
-            agentId,
-            newThreadId,
-            {
-              metadata: {
-                channel: message.channel,
-                channelInstallationId: message.channelInstallationId,
-                senderId: message.sender.id,
-                bindingId: binding?.id,
-                ...(message.conversation ? {
-                  conversationId: message.conversation.id,
-                  conversationType: message.conversation.type,
-                } : {}),
-              },
-            },
-          );
-          threadId = newThread.id;
-          if (binding && binding.id !== "fallback") {
-            await this.bindingRegistry.update(binding.id, { threadId });
-            binding.threadId = threadId;
-          } else if (binding) {
-            binding.threadId = threadId;
-          }
-        }
-
-        console.log({
-          event: "dispatch:agent",
-          agentId,
-          threadId,
-          senderId: message.sender.id,
-          contentLength: message.content.text.length,
-        }, "Dispatching to agent");
-
-        const agent = agentInstanceManager.getAgent({
-          tenant_id: tenantId!,
-          assistant_id: agentId,
-          thread_id: threadId,
-          workspace_id: binding?.workspaceId || "",
-          project_id: binding?.projectId || "",
-        });
-
-        /**
-         * Subscribe to reply:ready before addMessage to avoid a race with
-         * an already-running queue processor.
-         *
-         * The `_replySubs` map uses a counter (not a boolean) so that multiple
-         * concurrent dispatches on the same thread each get a callback invocation.
-         * The `subscribeOnce` listener is only registered when the counter goes
-         * from 0 → 1, and removed when it goes back to 0. A 1-hour timeout
-         * protects against leaked subscriptions due to agent errors/aborts.
-         */
-        if (message.replyTarget) {
-          const replySubKey = `${threadId}:${message.replyTarget.adapterChannel}:reply`;
-          const adapter = this.adapterRegistry.get(message.replyTarget.adapterChannel);
-          if (adapter) {
-            const installation = await this.installationStore.getInstallationById(
-              message.channelInstallationId,
-            );
-            if (installation) {
-              const existing = this._replySubs.get(replySubKey);
-              if (!existing || existing.count === 0) {
-                // First subscriber for this thread+channel — register the event listener
-                const timer = setTimeout(() => {
-                  // Cleanup if reply never fires (agent aborted, errored, etc.)
-                  const entry = this._replySubs.get(replySubKey);
-                  if (entry) {
-                    this._replySubs.delete(replySubKey);
-                    console.warn({
-                      event: "dispatch:reply:timeout",
-                      threadId,
-                      channel: message.replyTarget!.adapterChannel,
-                    }, "Reply subscription timed out — no reply:ready fired within 1h");
-                  }
-                }, 3_600_000);
-
-                this._replySubs.set(replySubKey, { count: 1, timer });
-
-                console.log({
-                  event: "dispatch:reply:subscribed",
-                  threadId,
-                  channel: message.replyTarget.adapterChannel,
-                  senderId: message.sender.id,
-                }, "Subscribed to reply:ready for thread");
-
-                agent.subscribeOnce('reply:ready', (data: any) => {
-                  const messages = data.state?.values?.messages;
-                  const lastAI = messages
-                    ?.filter((m: any) => m.type === 'ai' || m.getType?.() === 'ai')
-                    .pop();
-                  const replyText = lastAI?.content ?? '';
-
-                  // Decrement counter; unsubscribe only when count reaches 0
-                  const entry = this._replySubs.get(replySubKey);
-                  if (entry) {
-                    entry.count--;
-                    if (entry.count <= 0) {
-                      clearTimeout(entry.timer);
-                      this._replySubs.delete(replySubKey);
-                    }
-                  }
-
-                  if (replyText) {
-                    console.log({
-                      event: "dispatch:reply:sending",
-                      threadId,
-                      channel: message.replyTarget!.adapterChannel,
-                      replyLength: replyText.length,
-                    }, "Sending channel reply");
-                    adapter.sendReply(message.replyTarget!, { text: replyText }, installation)
-                      .then(() => {
-                        console.log({
-                          event: "dispatch:reply:sent",
-                          threadId,
-                          channel: message.replyTarget!.adapterChannel,
-                        }, "Channel reply sent successfully");
-                      })
-                      .catch((err) => console.error({
-                        event: "dispatch:reply:failed",
-                        threadId,
-                        channel: message.replyTarget!.adapterChannel,
-                        error: err instanceof Error ? err.message : String(err),
-                      }, "Failed to send channel reply"));
-                  } else {
-                    console.warn({
-                      event: "dispatch:reply:empty",
-                      threadId,
-                      channel: message.replyTarget!.adapterChannel,
-                    }, "Agent produced no text output — skipping reply");
-                  }
-                });
-              } else {
-                // Another dispatch already subscribed — increment counter
-                existing.count++;
-                console.log({
-                  event: "dispatch:reply:incremented",
-                  threadId,
-                  channel: message.replyTarget.adapterChannel,
-                  count: existing.count,
-                }, "Incremented reply counter for thread (already subscribed)");
-              }
-            }
-          }
-        }
-
-        const addResult = await agent.addMessage({
-          input: { message: message.content.text },
-          custom_run_config: message.replyTarget
-            ? { ...(message.content.metadata || {}), _replyTarget: message.replyTarget }
-            : (message.content.metadata || {}),
-        });
-
-        console.log({
-          event: "dispatch:complete",
-          agentId,
-          threadId,
-          messageId: (addResult as Record<string, unknown>)?.messageId,
-          result: JSON.stringify(addResult),
-        }, "Agent dispatch complete — messageId = " + ((addResult as Record<string, unknown>)?.messageId || "N/A"));
-      });
-
-      return {
-        success: true,
-        bindingId: ctx.binding?.id,
-        threadId,
-        result: ctx.result,
-      };
-    } catch (error) {
-      ctx.error = error instanceof Error ? error : new Error(String(error));
-      console.error({ event: "dispatch:error", error: ctx.error.message, channel: message.channel, senderId: message.sender.id }, "Message dispatch failed");
-      return {
-        success: false,
-        bindingId: ctx.binding?.id,
-        threadId: ctx.binding?.threadId,
-        error: ctx.error,
-      };
-    }
-  }
-
-  private async runMiddlewares(
-    ctx: MessageContext,
-    finalHandler: () => Promise<void>,
-  ): Promise<void> {
-    const dispatch = (index: number): Promise<void> => {
-      if (index >= this.middlewares.length) {
-        return finalHandler();
-      }
-      const middleware = this.middlewares[index];
-      return middleware(ctx, () => dispatch(index + 1));
-    };
-    return dispatch(0);
-  }
-}