@eggjs/langchain-plugin 0.0.0 → 4.0.2-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Alibaba Group Holding Limited and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js

@@ -0,0 +1,7 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+export { __decorateMetadata };

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateParam.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+export { __decorateParam };

package/dist/app.d.ts

@@ -0,0 +1,12 @@
+import { Application, IBoot } from "egg";
+
+//#region src/app.d.ts
+declare class ModuleLangChainHook implements IBoot {
+  #private;
+  constructor(app: Application);
+  configWillLoad(): void;
+  configDidLoad(): void;
+  beforeClose(): Promise<void>;
+}
+//#endregion
+export { ModuleLangChainHook as default };

package/dist/app.js

@@ -0,0 +1,42 @@
+import { BoundModelObjectHook } from "./lib/boundModel/BoundModelObjectHook.js";
+import { CompiledStateGraphProto } from "./lib/graph/CompiledStateGraphProto.js";
+import { CompiledStateGraphObject } from "./lib/graph/CompiledStateGraphObject.js";
+import { GraphBuildHook } from "./lib/graph/GraphBuildHook.js";
+import { GraphLoadUnitHook } from "./lib/graph/GraphLoadUnitHook.js";
+import { GraphObjectHook } from "./lib/graph/GraphObjectHook.js";
+import { GraphPrototypeHook } from "./lib/graph/GraphPrototypeHook.js";
+
+//#region src/app.ts
+var ModuleLangChainHook = class {
+	#app;
+	#graphObjectHook;
+	#graphLoadUnitHook;
+	#boundModelObjectHook;
+	#graphPrototypeHook;
+	constructor(app) {
+		this.#app = app;
+		this.#graphObjectHook = new GraphObjectHook();
+		this.#graphLoadUnitHook = new GraphLoadUnitHook(this.#app.eggPrototypeFactory);
+		this.#boundModelObjectHook = new BoundModelObjectHook();
+		this.#graphPrototypeHook = new GraphPrototypeHook();
+		this.#app.loadUnitLifecycleUtil.registerLifecycle(this.#graphLoadUnitHook);
+	}
+	configWillLoad() {
+		this.#app.eggObjectLifecycleUtil.registerLifecycle(this.#graphObjectHook);
+		this.#app.eggObjectLifecycleUtil.registerLifecycle(this.#boundModelObjectHook);
+		this.#app.eggObjectFactory.registerEggObjectCreateMethod(CompiledStateGraphProto, CompiledStateGraphObject.createObject);
+		this.#app.eggPrototypeLifecycleUtil.registerLifecycle(this.#graphPrototypeHook);
+	}
+	configDidLoad() {
+		this.#app.moduleHandler.registerGlobalGraphBuildHook(GraphBuildHook);
+	}
+	async beforeClose() {
+		this.#app.eggObjectLifecycleUtil.deleteLifecycle(this.#graphObjectHook);
+		this.#app.eggObjectLifecycleUtil.deleteLifecycle(this.#boundModelObjectHook);
+		this.#app.loadUnitLifecycleUtil.deleteLifecycle(this.#graphLoadUnitHook);
+		this.#app.eggPrototypeLifecycleUtil.deleteLifecycle(this.#graphPrototypeHook);
+	}
+};
+
+//#endregion
+export { ModuleLangChainHook as default };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ChatOpenAIModel } from "./lib/ChatOpenAI.js";
+import { BoundModelObjectHook } from "./lib/boundModel/BoundModelObjectHook.js";
+import { QualifierUtil } from "./lib/config/QualifierUtil.js";
+import { CompiledStateGraphProto } from "./lib/graph/CompiledStateGraphProto.js";
+import { CompiledStateGraphObject } from "./lib/graph/CompiledStateGraphObject.js";
+import { GraphBuildHook } from "./lib/graph/GraphBuildHook.js";
+import { GraphLoadUnitHook } from "./lib/graph/GraphLoadUnitHook.js";
+import { GraphObjectHook } from "./lib/graph/GraphObjectHook.js";
+import { GraphPrototypeHook } from "./lib/graph/GraphPrototypeHook.js";
+import { LangGraphTracer } from "./lib/tracing/LangGraphTracer.js";
+export { BoundModelObjectHook, ChatOpenAIModel, CompiledStateGraphObject, CompiledStateGraphProto, GraphBuildHook, GraphLoadUnitHook, GraphObjectHook, GraphPrototypeHook, LangGraphTracer, QualifierUtil };

package/dist/index.js

@@ -0,0 +1,12 @@
+import { BoundModelObjectHook } from "./lib/boundModel/BoundModelObjectHook.js";
+import { LangGraphTracer } from "./lib/tracing/LangGraphTracer.js";
+import { CompiledStateGraphProto } from "./lib/graph/CompiledStateGraphProto.js";
+import { CompiledStateGraphObject } from "./lib/graph/CompiledStateGraphObject.js";
+import { GraphBuildHook } from "./lib/graph/GraphBuildHook.js";
+import { GraphLoadUnitHook } from "./lib/graph/GraphLoadUnitHook.js";
+import { GraphObjectHook } from "./lib/graph/GraphObjectHook.js";
+import { GraphPrototypeHook } from "./lib/graph/GraphPrototypeHook.js";
+import { QualifierUtil } from "./lib/config/QualifierUtil.js";
+import { ChatOpenAIModel } from "./lib/ChatOpenAI.js";
+
+export { BoundModelObjectHook, ChatOpenAIModel, CompiledStateGraphObject, CompiledStateGraphProto, GraphBuildHook, GraphLoadUnitHook, GraphObjectHook, GraphPrototypeHook, LangGraphTracer, QualifierUtil };

package/dist/lib/ChatModelHelper.d.ts

@@ -0,0 +1,9 @@
+//#region src/lib/ChatModelHelper.d.ts
+declare class ChatModelHelper {
+  static getChatModelQualifier(clientName: string): Record<string, Array<{
+    attribute: symbol;
+    value: string;
+  }>>;
+}
+//#endregion
+export { ChatModelHelper };

package/dist/lib/ChatModelHelper.js

@@ -0,0 +1,14 @@
+import { ChatModelInjectName, ChatModelQualifierAttribute } from "@eggjs/langchain-decorator";
+
+//#region src/lib/ChatModelHelper.ts
+var ChatModelHelper = class {
+	static getChatModelQualifier(clientName) {
+		return { [ChatModelInjectName]: [{
+			attribute: ChatModelQualifierAttribute,
+			value: clientName
+		}] };
+	}
+};
+
+//#endregion
+export { ChatModelHelper };

package/dist/lib/ChatOpenAI.d.ts

@@ -0,0 +1,11 @@
+import { ObjectInfo } from "@eggjs/tegg";
+import { ModuleConfig as ModuleConfig$1 } from "@eggjs/tegg-common-util";
+import { ChatOpenAI } from "@langchain/openai";
+
+//#region src/lib/ChatOpenAI.d.ts
+declare class ChatOpenAIModel extends ChatOpenAI {
+  readonly moduleConfig: ModuleConfig$1;
+  constructor(moduleConfig: ModuleConfig$1, objInfo: ObjectInfo);
+}
+//#endregion
+export { ChatOpenAIModel };

package/dist/lib/ChatOpenAI.js

@@ -0,0 +1,47 @@
+import { __decorateMetadata } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import { ChatModelHelper } from "./ChatModelHelper.js";
+import { QualifierUtil } from "./config/QualifierUtil.js";
+import { getChatModelConfig, getClientNames } from "./util.js";
+import { __decorateParam } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateParam.js";
+import { ChatModelInjectName, ChatModelQualifierAttribute } from "@eggjs/langchain-decorator";
+import { AccessLevel, Inject, MultiInstanceInfo, MultiInstanceProto, ObjectInitType } from "@eggjs/tegg";
+import { ModuleConfigUtil } from "@eggjs/tegg-common-util";
+import { ChatOpenAI } from "@langchain/openai";
+import { Agent, FetchFactory, fetch } from "urllib";
+
+//#region src/lib/ChatOpenAI.ts
+let ChatOpenAIModel = class ChatOpenAIModel$1 extends ChatOpenAI {
+	constructor(moduleConfig, objInfo) {
+		const chatConfig = getChatModelConfig(moduleConfig, objInfo);
+		chatConfig.configuration = chatConfig.configuration || {};
+		FetchFactory.setDispatcher(new Agent({ allowH2: true }));
+		chatConfig.configuration.fetch = fetch;
+		super(chatConfig);
+	}
+};
+ChatOpenAIModel = __decorate([
+	MultiInstanceProto({
+		accessLevel: AccessLevel.PUBLIC,
+		initType: ObjectInitType.SINGLETON,
+		getObjects(ctx) {
+			const config = ModuleConfigUtil.loadModuleConfigSync(ctx.unitPath);
+			const moduleName = ModuleConfigUtil.readModuleNameSync(ctx.unitPath);
+			return getClientNames(config, "ChatModel").filter((name) => {
+				return config.ChatModel.clients[name].type === "openai";
+			}).map((name) => {
+				return {
+					name: ChatModelInjectName,
+					qualifiers: ChatModelHelper.getChatModelQualifier(name)[ChatModelInjectName],
+					properQualifiers: { ...QualifierUtil.getModuleConfigQualifier(moduleName) }
+				};
+			});
+		}
+	}),
+	__decorateParam(0, Inject()),
+	__decorateParam(1, MultiInstanceInfo([ChatModelQualifierAttribute])),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], ChatOpenAIModel);
+
+//#endregion
+export { ChatOpenAIModel };

package/dist/lib/boundModel/BoundModelObjectHook.d.ts

@@ -0,0 +1,9 @@
+import { LifecycleHook } from "@eggjs/tegg";
+import { EggObject, EggObjectLifeCycleContext } from "@eggjs/tegg-runtime";
+
+//#region src/lib/boundModel/BoundModelObjectHook.d.ts
+declare class BoundModelObjectHook implements LifecycleHook<EggObjectLifeCycleContext, EggObject> {
+  postCreate(_: EggObjectLifeCycleContext, eggObject: EggObject): Promise<void>;
+}
+//#endregion
+export { BoundModelObjectHook };

package/dist/lib/boundModel/BoundModelObjectHook.js

@@ -0,0 +1,76 @@
+import { BOUND_MODEL_METADATA, ChatModelInjectName, ChatModelQualifierAttribute, GraphToolInfoUtil } from "@eggjs/langchain-decorator";
+import { MCPClientInjectName, MCPClientQualifierAttribute } from "@eggjs/mcp-client";
+import { MCPInfoUtil } from "@eggjs/tegg";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import { loadMcpTools } from "@langchain/mcp-adapters";
+import { DynamicStructuredTool } from "langchain";
+import "langchain/chat_models/universal";
+import * as z from "zod/v4";
+
+//#region src/lib/boundModel/BoundModelObjectHook.ts
+var BoundModelHandler = class {
+	boundModelMetadata;
+	eggObject;
+	constructor(nodeMetadata, eggObject) {
+		this.boundModelMetadata = nodeMetadata;
+		this.eggObject = eggObject;
+	}
+	async findGraphTools() {
+		const tools = this.boundModelMetadata.tools ?? [];
+		let dTools = [];
+		for (let i = 0; i < tools.length; i++) {
+			const toolsObj = await EggContainerFactory.getOrCreateEggObjectFromClazz(tools[i]);
+			const toolMetadata = GraphToolInfoUtil.getGraphToolMetadata(toolsObj.proto.clazz);
+			const ToolDetail = MCPInfoUtil.getMCPToolArgsIndex(toolsObj.proto.clazz, "execute");
+			if (toolMetadata && ToolDetail) {
+				const tool = new DynamicStructuredTool({
+					description: toolMetadata.description,
+					name: toolMetadata.toolName,
+					func: toolsObj.obj.execute.bind(toolsObj.obj),
+					schema: z.object(ToolDetail.argsSchema)
+				});
+				dTools = dTools.concat(tool);
+			}
+		}
+		return dTools;
+	}
+	async findMcpServerTools() {
+		const mcpServers = this.boundModelMetadata.mcpServers ?? [];
+		let sTools = [];
+		for (let i = 0; i < mcpServers.length; i++) {
+			const mcpClientObj = await EggContainerFactory.getOrCreateEggObjectFromName(MCPClientInjectName, [{
+				attribute: MCPClientQualifierAttribute,
+				value: mcpServers[i]
+			}]);
+			const tool = await loadMcpTools(mcpServers[i], mcpClientObj.obj, {
+				throwOnLoadError: true,
+				prefixToolNameWithServerName: false,
+				additionalToolNamePrefix: ""
+			});
+			sTools = sTools.concat(tool);
+		}
+		return sTools;
+	}
+	async boundTools() {
+		const nodeObj = this.eggObject.obj;
+		const dTools = await this.findGraphTools();
+		const sTools = await this.findMcpServerTools();
+		const boundChatModel = (await EggContainerFactory.getOrCreateEggObjectFromName(ChatModelInjectName, [{
+			attribute: ChatModelQualifierAttribute,
+			value: this.boundModelMetadata.modelName
+		}])).obj.bindTools([...dTools, ...sTools]);
+		Object.setPrototypeOf(Object.getPrototypeOf(nodeObj), boundChatModel);
+	}
+};
+var BoundModelObjectHook = class {
+	async postCreate(_, eggObject) {
+		const BoundModelMetadata = eggObject.proto.getMetaData(BOUND_MODEL_METADATA);
+		if (BoundModelMetadata) {
+			await new BoundModelHandler(BoundModelMetadata, eggObject).boundTools();
+			return;
+		}
+	}
+};
+
+//#endregion
+export { BoundModelObjectHook };

package/dist/lib/config/QualifierUtil.d.ts

@@ -0,0 +1,8 @@
+import { QualifierInfo } from "@eggjs/tegg";
+
+//#region src/lib/config/QualifierUtil.d.ts
+declare class QualifierUtil {
+  static getModuleConfigQualifier(moduleName: string): Record<string, QualifierInfo[]>;
+}
+//#endregion
+export { QualifierUtil };

package/dist/lib/config/QualifierUtil.js

@@ -0,0 +1,14 @@
+import { ConfigSourceQualifierAttribute } from "@eggjs/tegg";
+
+//#region src/lib/config/QualifierUtil.ts
+var QualifierUtil = class {
+	static getModuleConfigQualifier(moduleName) {
+		return { moduleConfig: [{
+			attribute: ConfigSourceQualifierAttribute,
+			value: moduleName
+		}] };
+	}
+};
+
+//#endregion
+export { QualifierUtil };

package/dist/lib/graph/CompiledStateGraphObject.d.ts

@@ -0,0 +1,34 @@
+import { CompiledStateGraphProto } from "./CompiledStateGraphProto.js";
+import { GraphMetadata } from "@eggjs/langchain-decorator";
+import { EggObjectName, EggPrototypeName, Id } from "@eggjs/tegg";
+import { EggContext, EggObject } from "@eggjs/tegg-runtime";
+import { EggPrototype } from "@eggjs/metadata";
+
+//#region src/lib/graph/CompiledStateGraphObject.d.ts
+declare class CompiledStateGraphObject implements EggObject {
+  private status;
+  id: Id;
+  readonly name: EggPrototypeName;
+  readonly proto: CompiledStateGraphProto;
+  readonly ctx: EggContext;
+  readonly daoName: string;
+  private _obj;
+  readonly graphMetadata: GraphMetadata;
+  readonly graphName: string;
+  constructor(name: EggObjectName, proto: CompiledStateGraphProto);
+  init(): Promise<void>;
+  build(): Promise<any>;
+  boundNodes(stateGraph: EggObject): Promise<void>;
+  boundEdges(stateGraph: EggObject): Promise<void>;
+  /**
+  * 包装 graph 方法，添加 tracing
+  */
+  wrapGraphMethod(originalMethod: (input: any, config?: any) => Promise<any>, input: any, config?: any): Promise<any>;
+  getTracer(): Promise<any>;
+  injectProperty(): never;
+  get isReady(): boolean;
+  get obj(): object;
+  static createObject(name: EggObjectName, proto: EggPrototype): Promise<CompiledStateGraphObject>;
+}
+//#endregion
+export { CompiledStateGraphObject };

package/dist/lib/graph/CompiledStateGraphObject.js

@@ -0,0 +1,109 @@
+import { LangGraphTracer } from "../tracing/LangGraphTracer.js";
+import "./CompiledStateGraphProto.js";
+import { ChatCheckpointSaverInjectName, ChatCheckpointSaverQualifierAttribute, GRAPH_EDGE_METADATA, GRAPH_NODE_METADATA, TeggToolNode } from "@eggjs/langchain-decorator";
+import { IdenticalUtil } from "@eggjs/tegg";
+import { ContextHandler, EggContainerFactory, EggObjectStatus } from "@eggjs/tegg-runtime";
+import { EGG_CONTEXT } from "@eggjs/module-common";
+import { BaseCheckpointSaver } from "@langchain/langgraph";
+
+//#region src/lib/graph/CompiledStateGraphObject.ts
+var CompiledStateGraphObject = class CompiledStateGraphObject {
+	status = EggObjectStatus.PENDING;
+	id;
+	name;
+	proto;
+	ctx;
+	daoName;
+	_obj;
+	graphMetadata;
+	graphName;
+	constructor(name, proto) {
+		this.name = name;
+		this.proto = proto;
+		this.ctx = ContextHandler.getContext();
+		this.id = IdenticalUtil.createObjectId(this.proto.id, this.ctx?.id);
+		this.graphMetadata = proto.graphMetadata;
+		this.graphName = proto.graphName;
+	}
+	async init() {
+		this._obj = await this.build();
+		const graph = this._obj;
+		const originalStream = graph.stream;
+		(await EggContainerFactory.getOrCreateEggObjectFromName("langGraphTracer")).obj.setName(this.graphName);
+		graph.stream = (input, config) => this.wrapGraphMethod(originalStream.bind(graph), input, config);
+		this.status = EggObjectStatus.READY;
+	}
+	async build() {
+		const stateGraph = await EggContainerFactory.getOrCreateEggObjectFromName(this.graphName);
+		await this.boundNodes(stateGraph);
+		await this.boundEdges(stateGraph);
+		const graphObj = stateGraph.obj;
+		const checkpoint = this.graphMetadata.checkpoint;
+		let compileGraph;
+		if (checkpoint) {
+			let checkpointObj;
+			if (typeof checkpoint !== "string") checkpointObj = await EggContainerFactory.getOrCreateEggObjectFromClazz(checkpoint);
+			else checkpointObj = await EggContainerFactory.getOrCreateEggObjectFromName(ChatCheckpointSaverInjectName, [{
+				attribute: ChatCheckpointSaverQualifierAttribute,
+				value: checkpoint
+			}]);
+			compileGraph = graphObj.compile({ checkpointer: checkpointObj.obj });
+		} else compileGraph = graphObj.compile();
+		return compileGraph;
+	}
+	async boundNodes(stateGraph) {
+		const graphObj = stateGraph.obj;
+		const nodes = this.graphMetadata.nodes ?? [];
+		for (let i = 0; i < nodes.length; i++) {
+			const node = await EggContainerFactory.getOrCreateEggObjectFromClazz(nodes[i]);
+			const nodeObj = node.obj;
+			const nodeMetadata = node.proto.getMetaData(GRAPH_NODE_METADATA);
+			if (nodeMetadata) if (TeggToolNode.prototype.isPrototypeOf(nodeObj)) graphObj.addNode(nodeMetadata.nodeName, nodeObj.toolNode);
+			else graphObj.addNode(nodeMetadata.nodeName, nodeObj.execute.bind(nodeObj), nodeObj.options);
+		}
+	}
+	async boundEdges(stateGraph) {
+		const graphObj = stateGraph.obj;
+		const edges = this.graphMetadata.edges ?? [];
+		for (let i = 0; i < edges.length; i++) {
+			const edge = await EggContainerFactory.getOrCreateEggObjectFromClazz(edges[i]);
+			const edgeObj = edge.obj;
+			const edgeMetadata = edge.proto.getMetaData(GRAPH_EDGE_METADATA);
+			if (edgeMetadata) if (edgeObj.execute) graphObj.addConditionalEdges(edgeMetadata.fromNodeName, edgeObj.execute.bind(edgeObj), edgeMetadata.toNodeNames);
+			else graphObj.addEdge(edgeMetadata.fromNodeName, edgeMetadata.toNodeNames[0]);
+		}
+	}
+	/**
+	* 包装 graph 方法，添加 tracing
+	*/
+	async wrapGraphMethod(originalMethod, input, config) {
+		const finalConfig = config || {};
+		if (finalConfig.tags?.includes("trace-log")) {
+			const tracer = (await EggContainerFactory.getOrCreateEggObjectFromClazz(LangGraphTracer)).obj;
+			tracer.setName(this.graphName);
+			finalConfig.callbacks = [tracer, ...finalConfig.callbacks || []];
+		}
+		if (!finalConfig.runId) finalConfig.runId = (await this.getTracer())?.traceId;
+		return await originalMethod(input, finalConfig);
+	}
+	async getTracer() {
+		return ContextHandler.getContext().get(EGG_CONTEXT).tracer;
+	}
+	injectProperty() {
+		throw new Error("never call GraphObject#injectProperty");
+	}
+	get isReady() {
+		return this.status === EggObjectStatus.READY;
+	}
+	get obj() {
+		return this._obj;
+	}
+	static async createObject(name, proto) {
+		const compiledStateGraphObject = new CompiledStateGraphObject(name, proto);
+		await compiledStateGraphObject.init();
+		return compiledStateGraphObject;
+	}
+};
+
+//#endregion
+export { CompiledStateGraphObject };

package/dist/lib/graph/CompiledStateGraphProto.d.ts

@@ -0,0 +1,26 @@
+import { GraphMetadata } from "@eggjs/langchain-decorator";
+import { AccessLevel, EggPrototypeName, Id, ObjectInitType, QualifierAttribute, QualifierInfo, QualifierValue } from "@eggjs/tegg";
+import { EggPrototype, LoadUnit } from "@eggjs/metadata";
+import { InjectObjectProto } from "@eggjs/tegg-types";
+
+//#region src/lib/graph/CompiledStateGraphProto.d.ts
+declare class CompiledStateGraphProto implements EggPrototype {
+  [key: symbol]: PropertyDescriptor;
+  private readonly qualifiers;
+  readonly accessLevel: AccessLevel;
+  id: Id;
+  readonly initType: ObjectInitType;
+  readonly injectObjects: InjectObjectProto[];
+  loadUnitId: string;
+  readonly name: EggPrototypeName;
+  readonly graphMetadata: GraphMetadata;
+  readonly graphName: string;
+  constructor(loadUnit: LoadUnit, protoName: string, graphName: string, graphMetadata: GraphMetadata);
+  constructEggObject(): object;
+  getMetaData<T>(_metadataKey?: any): T | undefined;
+  verifyQualifier(qualifier: QualifierInfo): boolean;
+  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
+  getQualifier(attribute: QualifierAttribute): QualifierValue | undefined;
+}
+//#endregion
+export { CompiledStateGraphProto };

package/dist/lib/graph/CompiledStateGraphProto.js

@@ -0,0 +1,39 @@
+import { AccessLevel, IdenticalUtil, ObjectInitType } from "@eggjs/tegg";
+
+//#region src/lib/graph/CompiledStateGraphProto.ts
+var CompiledStateGraphProto = class {
+	qualifiers;
+	accessLevel = AccessLevel.PUBLIC;
+	id;
+	initType = ObjectInitType.SINGLETON;
+	injectObjects = [];
+	loadUnitId;
+	name;
+	graphMetadata;
+	graphName;
+	constructor(loadUnit, protoName, graphName, graphMetadata) {
+		this.loadUnitId = loadUnit.id;
+		this.qualifiers = [];
+		this.name = protoName;
+		this.graphMetadata = graphMetadata;
+		this.graphName = graphName;
+		this.id = IdenticalUtil.createProtoId(loadUnit.id, protoName);
+	}
+	constructEggObject() {
+		return {};
+	}
+	getMetaData(_metadataKey) {}
+	verifyQualifier(qualifier) {
+		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+	}
+	verifyQualifiers(qualifiers) {
+		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
+		return true;
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+};
+
+//#endregion
+export { CompiledStateGraphProto };

package/dist/lib/graph/GraphBuildHook.d.ts

@@ -0,0 +1,6 @@
+import { GlobalGraph } from "@eggjs/metadata";
+
+//#region src/lib/graph/GraphBuildHook.d.ts
+declare function GraphBuildHook(globalGraph: GlobalGraph): void;
+//#endregion
+export { GraphBuildHook };

package/dist/lib/graph/GraphBuildHook.js

@@ -0,0 +1,13 @@
+import { LangGraphTracer } from "../tracing/LangGraphTracer.js";
+import { AbstractStateGraph } from "@eggjs/langchain-decorator";
+import { GlobalGraph } from "@eggjs/metadata";
+
+//#region src/lib/graph/GraphBuildHook.ts
+function GraphBuildHook(globalGraph) {
+	let langchainGraphTracerProtoNode;
+	for (const moduleNode of globalGraph.moduleGraph.nodes.values()) for (const protoNode of moduleNode.val.protos) if (protoNode.val.proto?.clazz && (LangGraphTracer.isPrototypeOf(protoNode.val.proto.clazz) || protoNode.val.proto.clazz === LangGraphTracer)) langchainGraphTracerProtoNode = protoNode;
+	for (const moduleNode of globalGraph.moduleGraph.nodes.values()) for (const protoNode of moduleNode.val.protos) if (protoNode.val.proto?.clazz && AbstractStateGraph.isPrototypeOf(protoNode.val.proto.clazz)) globalGraph.addInject(moduleNode, protoNode, langchainGraphTracerProtoNode, langchainGraphTracerProtoNode.val.proto.name);
+}
+
+//#endregion
+export { GraphBuildHook };

package/dist/lib/graph/GraphLoadUnitHook.d.ts

@@ -0,0 +1,18 @@
+import { CompiledStateGraphProto } from "./CompiledStateGraphProto.js";
+import { IGraphMetadata, IGraphToolMetadata } from "@eggjs/langchain-decorator";
+import { EggProtoImplClass, LifecycleHook } from "@eggjs/tegg";
+import { EggPrototypeFactory, LoadUnit, LoadUnitLifecycleContext } from "@eggjs/metadata";
+
+//#region src/lib/graph/GraphLoadUnitHook.d.ts
+declare class GraphLoadUnitHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  private readonly eggPrototypeFactory;
+  clazzMap: Map<EggProtoImplClass, IGraphMetadata>;
+  graphCompiledNameMap: Map<string, CompiledStateGraphProto>;
+  tools: Map<EggProtoImplClass, IGraphToolMetadata>;
+  constructor(eggPrototypeFactory: EggPrototypeFactory);
+  preCreate(ctx: LoadUnitLifecycleContext, loadUnit: LoadUnit): Promise<void>;
+  createStructuredTool(clazz: EggProtoImplClass, toolMeta: IGraphToolMetadata): EggProtoImplClass;
+  postCreate(_ctx: LoadUnitLifecycleContext, obj: LoadUnit): Promise<void>;
+}
+//#endregion
+export { GraphLoadUnitHook };

package/dist/lib/graph/GraphLoadUnitHook.js

@@ -0,0 +1,92 @@
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import { CompiledStateGraphProto } from "./CompiledStateGraphProto.js";
+import { GraphInfoUtil, GraphToolInfoUtil } from "@eggjs/langchain-decorator";
+import { AccessLevel, LifecyclePostInject, MCPInfoUtil, SingletonProto } from "@eggjs/tegg";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import { DynamicStructuredTool } from "langchain";
+import * as z from "zod/v4";
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, ProtoDescriptorHelper } from "@eggjs/metadata";
+import assert from "node:assert";
+
+//#region src/lib/graph/GraphLoadUnitHook.ts
+var GraphLoadUnitHook = class {
+	eggPrototypeFactory;
+	clazzMap;
+	graphCompiledNameMap = /* @__PURE__ */ new Map();
+	tools;
+	constructor(eggPrototypeFactory) {
+		this.eggPrototypeFactory = eggPrototypeFactory;
+		this.clazzMap = GraphInfoUtil.getAllGraphMetadata();
+		this.tools = GraphToolInfoUtil.getAllGraphToolMetadata();
+	}
+	async preCreate(ctx, loadUnit) {
+		const clazzList = await ctx.loader.load();
+		for (const clazz of clazzList) {
+			if (this.clazzMap.get(clazz)) {
+				const protoName = clazz.name[0].toLowerCase() + clazz.name.substring(1);
+				const graphMetadata = GraphInfoUtil.getGraphMetadata(clazz);
+				assert(graphMetadata, `${clazz.name} graphMetadata should not be null`);
+				const proto = new CompiledStateGraphProto(loadUnit, `compiled${protoName.replace(protoName[0], protoName[0].toUpperCase())}`, protoName, graphMetadata);
+				this.eggPrototypeFactory.registerPrototype(proto, loadUnit);
+				this.graphCompiledNameMap.set(protoName, proto);
+			}
+			const toolMeta = this.tools.get(clazz);
+			if (toolMeta) {
+				const StructuredTool = this.createStructuredTool(clazz, toolMeta);
+				const protoDescriptor = ProtoDescriptorHelper.createByInstanceClazz(StructuredTool, {
+					moduleName: loadUnit.name,
+					unitPath: loadUnit.unitPath
+				});
+				const proto = await EggPrototypeCreatorFactory.createProtoByDescriptor(protoDescriptor, loadUnit);
+				this.eggPrototypeFactory.registerPrototype(proto, loadUnit);
+			}
+		}
+	}
+	createStructuredTool(clazz, toolMeta) {
+		class StructuredTool {
+			async init() {
+				const toolsObj = await EggContainerFactory.getOrCreateEggObjectFromClazz(clazz);
+				const toolMetadata = GraphToolInfoUtil.getGraphToolMetadata(toolsObj.proto.clazz);
+				const ToolDetail = MCPInfoUtil.getMCPToolArgsIndex(toolsObj.proto.clazz, "execute");
+				if (toolMetadata && ToolDetail) {
+					const tool = new DynamicStructuredTool({
+						description: toolMetadata.description,
+						name: toolMetadata.toolName,
+						func: toolsObj.obj.execute.bind(toolsObj.obj),
+						schema: z.object(ToolDetail.argsSchema)
+					});
+					Object.setPrototypeOf(this, tool);
+				} else throw new Error(`graph tool ${toolMeta.name ?? clazz.name} not found`);
+			}
+		}
+		__decorate([
+			LifecyclePostInject(),
+			__decorateMetadata("design:type", Function),
+			__decorateMetadata("design:paramtypes", []),
+			__decorateMetadata("design:returntype", Promise)
+		], StructuredTool.prototype, "init", null);
+		SingletonProto({
+			name: `structured${toolMeta.name ?? clazz.name}`,
+			accessLevel: AccessLevel.PUBLIC
+		})(StructuredTool);
+		return StructuredTool;
+	}
+	async postCreate(_ctx, obj) {
+		for (const graphName of this.graphCompiledNameMap.keys()) {
+			const graphProto = obj.getEggPrototype(graphName, [])[0];
+			if (graphProto) {
+				const compiledGraphProto = this.graphCompiledNameMap.get(graphName);
+				if (!compiledGraphProto.injectObjects.find((injectObject) => injectObject.objName === graphProto.name)) compiledGraphProto.injectObjects.push({
+					refName: "stateGraph",
+					objName: graphProto.name,
+					qualifiers: [],
+					proto: graphProto
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+export { GraphLoadUnitHook };

package/dist/lib/graph/GraphObjectHook.d.ts

@@ -0,0 +1,9 @@
+import { LifecycleHook } from "@eggjs/tegg";
+import { EggObject, EggObjectLifeCycleContext } from "@eggjs/tegg/helper";
+
+//#region src/lib/graph/GraphObjectHook.d.ts
+declare class GraphObjectHook implements LifecycleHook<EggObjectLifeCycleContext, EggObject> {
+  postCreate(_: EggObjectLifeCycleContext, eggObject: EggObject): Promise<void>;
+}
+//#endregion
+export { GraphObjectHook };

package/dist/lib/graph/GraphObjectHook.js

@@ -0,0 +1,95 @@
+import { ChatModelInjectName, ChatModelQualifierAttribute, GRAPH_NODE_METADATA, GraphToolInfoUtil, TeggToolNode } from "@eggjs/langchain-decorator";
+import { MCPClientInjectName, MCPClientQualifierAttribute } from "@eggjs/mcp-client";
+import { MCPInfoUtil } from "@eggjs/tegg";
+import { loadMcpTools } from "@langchain/mcp-adapters";
+import { DynamicStructuredTool } from "langchain";
+import "langchain/chat_models/universal";
+import * as z from "zod/v4";
+import { EggContainerFactory } from "@eggjs/tegg/helper";
+import { ToolNode } from "@langchain/langgraph/prebuilt";
+
+//#region src/lib/graph/GraphObjectHook.ts
+var GraphNodeHandler = class {
+	nodeMetadata;
+	eggObject;
+	constructor(nodeMetadata, eggObject) {
+		this.nodeMetadata = nodeMetadata;
+		this.eggObject = eggObject;
+	}
+	async findGraphTools() {
+		const tools = this.nodeMetadata.tools ?? [];
+		let dTools = [];
+		for (let i = 0; i < tools.length; i++) {
+			const toolsObj = await EggContainerFactory.getOrCreateEggObjectFromClazz(tools[i]);
+			const toolMetadata = GraphToolInfoUtil.getGraphToolMetadata(toolsObj.proto.clazz);
+			const ToolDetail = MCPInfoUtil.getMCPToolArgsIndex(toolsObj.proto.clazz, "execute");
+			if (toolMetadata && ToolDetail) {
+				const tool = new DynamicStructuredTool({
+					description: toolMetadata.description,
+					name: toolMetadata.toolName,
+					func: toolsObj.obj.execute.bind(toolsObj.obj),
+					schema: z.object(ToolDetail.argsSchema)
+				});
+				dTools = dTools.concat(tool);
+			}
+		}
+		return dTools;
+	}
+	async findMcpServerTools() {
+		const mcpServers = this.nodeMetadata.mcpServers ?? [];
+		let sTools = [];
+		for (let i = 0; i < mcpServers.length; i++) {
+			const mcpClientObj = await EggContainerFactory.getOrCreateEggObjectFromName(MCPClientInjectName, [{
+				attribute: MCPClientQualifierAttribute,
+				value: mcpServers[i]
+			}]);
+			const tool = await loadMcpTools(mcpServers[i], mcpClientObj.obj, {
+				throwOnLoadError: true,
+				prefixToolNameWithServerName: false,
+				additionalToolNamePrefix: ""
+			});
+			sTools = sTools.concat(tool);
+		}
+		return sTools;
+	}
+	async boundTools() {
+		const nodeObj = this.eggObject.obj;
+		const dTools = await this.findGraphTools();
+		const sTools = await this.findMcpServerTools();
+		if (TeggToolNode.prototype.isPrototypeOf(nodeObj)) {
+			const toolNode = new ToolNode([...dTools, ...sTools]);
+			Object.defineProperty(nodeObj, "toolNode", { get: () => toolNode });
+			return;
+		}
+		if (nodeObj.build) nodeObj.build([...dTools, ...sTools]);
+		else {
+			const injectObjects = this.eggObject.proto.injectObjects;
+			for (let i = 0; i < injectObjects.length; i++) {
+				const injectObject = injectObjects[i];
+				const qualifiers = injectObject.qualifiers;
+				for (let j = 0; j < qualifiers.length; j++) {
+					const qualifier = qualifiers[j];
+					if (qualifier.attribute === ChatModelQualifierAttribute) {
+						const boundChatModel = (await EggContainerFactory.getOrCreateEggObjectFromName(ChatModelInjectName, [{
+							attribute: ChatModelQualifierAttribute,
+							value: qualifier.value
+						}])).obj.bindTools([...dTools, ...sTools]);
+						Object.defineProperty(nodeObj, injectObject.objName, { get: () => boundChatModel });
+					}
+				}
+			}
+		}
+	}
+};
+var GraphObjectHook = class {
+	async postCreate(_, eggObject) {
+		const nodeMetadata = eggObject.proto.getMetaData(GRAPH_NODE_METADATA);
+		if (nodeMetadata) {
+			await new GraphNodeHandler(nodeMetadata, eggObject).boundTools();
+			return;
+		}
+	}
+};
+
+//#endregion
+export { GraphObjectHook };

package/dist/lib/graph/GraphPrototypeHook.d.ts

@@ -0,0 +1,24 @@
+import { EggProtoImplClass, LifecycleHook } from "@eggjs/tegg";
+import { EggPrototype, EggPrototypeLifecycleContext } from "@eggjs/metadata";
+
+//#region src/lib/graph/GraphPrototypeHook.d.ts
+declare class GraphPrototypeHook implements LifecycleHook<EggPrototypeLifecycleContext, EggPrototype> {
+  toolProtoMap: Map<EggProtoImplClass, EggPrototype>;
+  nodeProtoMap: Map<EggPrototype, EggProtoImplClass[]>;
+  nodeMcpServerProtoMap: Map<EggPrototype, string[]>;
+  mcpServerProto: EggPrototype;
+  checkPointProto: EggPrototype;
+  checkPointList: EggProtoImplClass[];
+  checkPointProtoMap: Map<EggProtoImplClass, EggPrototype>;
+  checkPointGraphMap: Map<EggProtoImplClass, EggPrototype[]>;
+  graphCheckpointProtoMap: Map<EggPrototype, string>;
+  graphNodeProtoMap: Map<EggPrototype, EggProtoImplClass[]>;
+  nodeProto: Map<EggProtoImplClass, EggPrototype>;
+  graphEdgeProtoMap: Map<EggPrototype, EggProtoImplClass[]>;
+  edgeProto: Map<EggProtoImplClass, EggPrototype>;
+  postCreate(ctx: EggPrototypeLifecycleContext, proto: EggPrototype): Promise<void>;
+  makeNodeDependencies(ctx: EggPrototypeLifecycleContext, proto: EggPrototype): Promise<void>;
+  makeGraphDependencies(ctx: EggPrototypeLifecycleContext, proto: EggPrototype): Promise<void>;
+}
+//#endregion
+export { GraphPrototypeHook };

package/dist/lib/graph/GraphPrototypeHook.js

@@ -0,0 +1,175 @@
+import { ChatCheckpointSaverInjectName, ChatCheckpointSaverQualifierAttribute, GraphEdgeInfoUtil, GraphInfoUtil, GraphNodeInfoUtil, GraphToolInfoUtil } from "@eggjs/langchain-decorator";
+import { MCPClientInjectName, MCPClientQualifierAttribute } from "@eggjs/mcp-client";
+import { BaseCheckpointSaver } from "@langchain/langgraph";
+
+//#region src/lib/graph/GraphPrototypeHook.ts
+var GraphPrototypeHook = class {
+	toolProtoMap = /* @__PURE__ */ new Map();
+	nodeProtoMap = /* @__PURE__ */ new Map();
+	nodeMcpServerProtoMap = /* @__PURE__ */ new Map();
+	mcpServerProto;
+	checkPointProto;
+	checkPointList = [];
+	checkPointProtoMap = /* @__PURE__ */ new Map();
+	checkPointGraphMap = /* @__PURE__ */ new Map();
+	graphCheckpointProtoMap = /* @__PURE__ */ new Map();
+	graphNodeProtoMap = /* @__PURE__ */ new Map();
+	nodeProto = /* @__PURE__ */ new Map();
+	graphEdgeProtoMap = /* @__PURE__ */ new Map();
+	edgeProto = /* @__PURE__ */ new Map();
+	async postCreate(ctx, proto) {
+		await this.makeNodeDependencies(ctx, proto);
+		await this.makeGraphDependencies(ctx, proto);
+	}
+	async makeNodeDependencies(ctx, proto) {
+		const nodeMetadata = GraphNodeInfoUtil.getGraphNodeMetadata(ctx.clazz);
+		if (nodeMetadata) {
+			const tools = nodeMetadata.tools ?? [];
+			for (let i = 0; i < tools.length; i++) if (this.toolProtoMap.has(tools[i])) {
+				const toolProto = this.toolProtoMap.get(tools[i]);
+				proto.injectObjects.push({
+					refName: `__GRAPH_TOOL_${String(toolProto.name)}__`,
+					objName: toolProto.name,
+					qualifiers: [],
+					proto: toolProto
+				});
+			}
+			const mcpServers = nodeMetadata.mcpServers ?? [];
+			if (this.mcpServerProto) for (let i = 0; i < mcpServers.length; i++) proto.injectObjects.push({
+				refName: `__GRAPH_MCPSERVER_${String(mcpServers[i])}__`,
+				objName: MCPClientInjectName,
+				qualifiers: [{
+					attribute: MCPClientQualifierAttribute,
+					value: mcpServers[i]
+				}],
+				proto: this.mcpServerProto
+			});
+			this.nodeProtoMap.set(proto, tools);
+			this.nodeMcpServerProtoMap.set(proto, mcpServers);
+		}
+		if (GraphToolInfoUtil.getGraphToolMetadata(ctx.clazz)) {
+			for (const [nodeProto, toolClazzList] of this.nodeProtoMap.entries()) if (toolClazzList.includes(ctx.clazz)) nodeProto.injectObjects.push({
+				refName: `__GRAPH_TOOL_${String(proto.name)}__`,
+				objName: proto.name,
+				qualifiers: [],
+				proto
+			});
+			this.toolProtoMap.set(ctx.clazz, proto);
+		}
+		if (proto.name === MCPClientInjectName) {
+			this.mcpServerProto = proto;
+			for (const [nodeProto, mcpServers] of this.nodeMcpServerProtoMap.entries()) for (let i = 0; i < mcpServers.length; i++) nodeProto.injectObjects.push({
+				refName: `__GRAPH_MCPSERVER_${String(mcpServers[i])}__`,
+				objName: MCPClientInjectName,
+				qualifiers: [{
+					attribute: MCPClientQualifierAttribute,
+					value: mcpServers[i]
+				}],
+				proto
+			});
+		}
+	}
+	async makeGraphDependencies(ctx, proto) {
+		const graphMetadata = GraphInfoUtil.getGraphMetadata(ctx.clazz);
+		if (graphMetadata) {
+			if (graphMetadata.checkpoint) {
+				if (typeof graphMetadata.checkpoint === "string") {
+					if (this.checkPointProto) proto.injectObjects.push({
+						refName: "checkpoint",
+						objName: ChatCheckpointSaverInjectName,
+						qualifiers: [{
+							attribute: ChatCheckpointSaverQualifierAttribute,
+							value: graphMetadata.checkpoint
+						}],
+						proto: this.checkPointProto
+					});
+					this.graphCheckpointProtoMap.set(proto, graphMetadata.checkpoint);
+				} else {
+					if (this.checkPointProtoMap.has(graphMetadata.checkpoint)) {
+						const checkPointProto = this.checkPointProtoMap.get(graphMetadata.checkpoint);
+						proto.injectObjects.push({
+							refName: "checkpoint",
+							objName: checkPointProto.name,
+							qualifiers: [],
+							proto: checkPointProto
+						});
+					}
+					this.checkPointList.push(graphMetadata.checkpoint);
+					if (this.checkPointGraphMap.has(graphMetadata.checkpoint)) this.checkPointGraphMap.get(graphMetadata.checkpoint).push(proto);
+					else this.checkPointGraphMap.set(graphMetadata.checkpoint, [proto]);
+				}
+				this.graphNodeProtoMap.set(proto, []);
+				this.graphEdgeProtoMap.set(proto, []);
+				for (const nodeProto of graphMetadata.nodes ?? []) if (this.nodeProto.has(nodeProto)) proto.injectObjects.push({
+					refName: `__GRAPH_NODE_${String(nodeProto)}__`,
+					objName: nodeProto.name,
+					qualifiers: [],
+					proto: this.nodeProto.get(nodeProto)
+				});
+				else this.graphNodeProtoMap.get(proto).push(nodeProto);
+				for (const edgeProto of graphMetadata.edges ?? []) if (this.edgeProto.has(edgeProto)) proto.injectObjects.push({
+					refName: `__GRAPH_EDGE_${String(edgeProto)}__`,
+					objName: edgeProto.name,
+					qualifiers: [],
+					proto: this.edgeProto.get(edgeProto)
+				});
+				else this.graphEdgeProtoMap.get(proto).push(edgeProto);
+			}
+		}
+		if (proto.name === ChatCheckpointSaverInjectName) {
+			this.checkPointProto = proto;
+			for (const [graphProto, checkpoint] of this.graphCheckpointProtoMap.entries()) if (checkpoint === graphMetadata?.checkpoint) {
+				if (!graphProto.injectObjects.find((injectObject) => injectObject.refName === "checkpoint")) continue;
+				graphProto.injectObjects.push({
+					refName: "checkpoint",
+					objName: ChatCheckpointSaverInjectName,
+					qualifiers: [{
+						attribute: ChatCheckpointSaverQualifierAttribute,
+						value: checkpoint
+					}],
+					proto
+				});
+			}
+		}
+		if (BaseCheckpointSaver.isPrototypeOf(ctx.clazz)) {
+			const graphProto = this.checkPointGraphMap.get(ctx.clazz) ?? [];
+			for (let i = 0; i < graphProto.length; i++) {
+				if (!graphProto[i].injectObjects.find((injectObject) => injectObject.refName === "checkpoint")) continue;
+				graphProto[i].injectObjects.push({
+					refName: "checkpoint",
+					objName: proto.name,
+					qualifiers: [],
+					proto
+				});
+			}
+			this.checkPointProtoMap.set(ctx.clazz, proto);
+		}
+		if (GraphNodeInfoUtil.getGraphNodeMetadata(ctx.clazz)) {
+			this.nodeProto.set(ctx.clazz, proto);
+			for (const [graphProto, nodeProtos] of this.graphNodeProtoMap.entries()) if (nodeProtos.includes(ctx.clazz)) {
+				if (graphProto.injectObjects.find((injectObject) => injectObject.refName === `__GRAPH_NODE_${String(ctx.clazz)}__`)) continue;
+				graphProto.injectObjects.push({
+					refName: `__GRAPH_NODE_${String(ctx.clazz)}__`,
+					objName: proto.name,
+					qualifiers: [],
+					proto
+				});
+			}
+		}
+		if (GraphEdgeInfoUtil.getGraphEdgeMetadata(ctx.clazz)) {
+			this.edgeProto.set(ctx.clazz, proto);
+			for (const [graphProto, edgeProtos] of this.graphEdgeProtoMap.entries()) if (edgeProtos.includes(ctx.clazz)) {
+				if (graphProto.injectObjects.find((injectObject) => injectObject.refName === `__GRAPH_EDGE_${String(ctx.clazz)}__`)) continue;
+				graphProto.injectObjects.push({
+					refName: `__GRAPH_EDGE_${String(ctx.clazz)}__`,
+					objName: proto.name,
+					qualifiers: [],
+					proto
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+export { GraphPrototypeHook };

package/dist/lib/tracing/LangGraphTracer.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from "@eggjs/tegg";
+import { BaseTracer, Run } from "@langchain/core/tracers/base";
+
+//#region src/lib/tracing/LangGraphTracer.d.ts
+declare class LangGraphTracer extends BaseTracer {
+  logger: Logger;
+  name: string;
+  setName(name: string): void;
+  protected persistRun(run: Run): Promise<void>;
+}
+//#endregion
+export { LangGraphTracer };

package/dist/lib/tracing/LangGraphTracer.js

@@ -0,0 +1,22 @@
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import { AccessLevel, Inject, SingletonProto } from "@eggjs/tegg";
+import { BaseTracer, Run } from "@langchain/core/tracers/base";
+
+//#region src/lib/tracing/LangGraphTracer.ts
+let LangGraphTracer = class LangGraphTracer$1 extends BaseTracer {
+	logger;
+	name = "LangGraphTracer";
+	setName(name) {
+		this.name = name;
+	}
+	persistRun(run) {
+		this.logger.info(`[agent_run][${this.name}]:traceId=${run.trace_id},run=${JSON.stringify(run)}`);
+		return Promise.resolve(void 0);
+	}
+};
+__decorate([Inject(), __decorateMetadata("design:type", Object)], LangGraphTracer.prototype, "logger", void 0);
+LangGraphTracer = __decorate([SingletonProto({ accessLevel: AccessLevel.PUBLIC })], LangGraphTracer);
+
+//#endregion
+export { LangGraphTracer };

package/dist/lib/util.d.ts

@@ -0,0 +1,8 @@
+import { ModuleConfig, ObjectInfo } from "@eggjs/tegg";
+
+//#region src/lib/util.d.ts
+type ConfigTypeHelper = any;
+declare function getClientNames(config: ModuleConfig | undefined, key: string): string[];
+declare function getChatModelConfig(config: ModuleConfig, objectInfo: ObjectInfo): any;
+//#endregion
+export { ConfigTypeHelper, getChatModelConfig, getClientNames };

package/dist/lib/util.js

@@ -0,0 +1,19 @@
+import { ChatModelQualifierAttribute } from "@eggjs/langchain-decorator";
+import assert from "node:assert";
+
+//#region src/lib/util.ts
+function getClientNames(config, key) {
+	const clients = config?.[key]?.clients;
+	if (!clients) return [];
+	return Object.keys(clients);
+}
+function getChatModelConfig(config, objectInfo) {
+	const chatModelName = objectInfo.qualifiers.find((t) => t.attribute === ChatModelQualifierAttribute)?.value;
+	assert(chatModelName, "not found ChatModel name");
+	const chatModelConfig = config.ChatModel?.clients[chatModelName];
+	if (!chatModelConfig) throw new Error(`not found ChatModel config for ${chatModelName}`);
+	return chatModelConfig;
+}
+
+//#endregion
+export { getChatModelConfig, getClientNames };

package/package.json

@@ -1,31 +1,99 @@
 {
   "name": "@eggjs/langchain-plugin",
-  "version": "0.0.0",
-  "description": "egg logger",
+  "version": "4.0.2-beta.0",
+  "description": "langchain for egg",
   "keywords": [
     "egg",
-    "logger"
+    "langchain",
+    "module",
+    "plugin",
+    "tegg",
+    "typescript"
   ],
-  "homepage": "https://github.com/eggjs/egg/tree/next/packages/logger",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/plugin/langchain",
   "bugs": {
     "url": "https://github.com/eggjs/egg/issues"
   },
-  "license": "MIT",
-  "author": "fengmk2 <fengmk2@gmail.com> (https://github.com/fengmk2)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eggjs/egg.git",
-    "directory": "packages/logger"
+    "directory": "tegg/plugin/langchain"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./app": "./dist/app.js",
+    "./lib/boundModel/BoundModelObjectHook": "./dist/lib/boundModel/BoundModelObjectHook.js",
+    "./lib/ChatModelHelper": "./dist/lib/ChatModelHelper.js",
+    "./lib/ChatOpenAI": "./dist/lib/ChatOpenAI.js",
+    "./lib/config/QualifierUtil": "./dist/lib/config/QualifierUtil.js",
+    "./lib/graph/CompiledStateGraphObject": "./dist/lib/graph/CompiledStateGraphObject.js",
+    "./lib/graph/CompiledStateGraphProto": "./dist/lib/graph/CompiledStateGraphProto.js",
+    "./lib/graph/GraphBuildHook": "./dist/lib/graph/GraphBuildHook.js",
+    "./lib/graph/GraphLoadUnitHook": "./dist/lib/graph/GraphLoadUnitHook.js",
+    "./lib/graph/GraphObjectHook": "./dist/lib/graph/GraphObjectHook.js",
+    "./lib/graph/GraphPrototypeHook": "./dist/lib/graph/GraphPrototypeHook.js",
+    "./lib/tracing/LangGraphTracer": "./dist/lib/tracing/LangGraphTracer.js",
+    "./lib/util": "./dist/lib/util.js",
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@langchain/core": "^1.1.1",
+    "@langchain/langgraph": "^1.0.2",
+    "@langchain/mcp-adapters": "^1.0.0",
+    "@langchain/openai": "^1.0.0",
+    "langchain": "^1.1.2",
+    "urllib": "^4.8.2",
+    "zod": "^4.0.0",
+    "@eggjs/langchain-decorator": "4.0.2-beta.0",
+    "@eggjs/mcp-client": "4.0.2-beta.0",
+    "@eggjs/metadata": "4.0.2-beta.0",
+    "@eggjs/module-common": "4.0.2-beta.0",
+    "@eggjs/tegg-common-util": "4.0.2-beta.0",
+    "@eggjs/tegg-types": "4.0.2-beta.0",
+    "@eggjs/tegg": "4.0.2-beta.0",
+    "@eggjs/tegg-runtime": "4.0.2-beta.0"
   },
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@types/node": "^24.10.2",
+    "typescript": "^5.9.3",
+    "@eggjs/controller-plugin": "4.0.2-beta.0",
+    "@eggjs/mock": "7.0.2-beta.0",
+    "@eggjs/module-test-util": "4.0.0-beta.29",
+    "@eggjs/router": "4.0.2-beta.0",
+    "@eggjs/tegg-config": "4.0.2-beta.0",
+    "@eggjs/mcp-client-plugin": "4.0.2-beta.0",
+    "@eggjs/tegg-plugin": "4.0.2-beta.0",
+    "egg": "4.1.2-beta.0",
+    "@eggjs/tracer": "4.0.2-beta.0"
+  },
+  "peerDependencies": {
+    "@eggjs/tegg-plugin": "4.0.2-beta.0",
+    "egg": "4.1.2-beta.0"
   },
   "engines": {
-    "node": ">= 22.18.0"
+    "node": ">=22.18.0"
+  },
+  "eggModule": {
+    "name": "teggLangChain"
+  },
+  "eggPlugin": {
+    "name": "teggLangChain",
+    "dependencies": [
+      "tegg"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
   }
-}
-
+}