nestjs-langchain 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Martin-Bruel
+
+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/README.md

@@ -0,0 +1,254 @@
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="200" alt="Nest Logo" /></a>
+</p>
+
+<p align="center">
+  A <a href="https://nestjs.com/">Nest</a> module wrapper for building AI agent with <a href="https://www.langchain.com/">LangChain</a>.
+</p>
+
+<p align="center">
+  <a href="https://github.com/Martin-Bruel/nestjs-langchain/pulse"><img src="https://img.shields.io/github/commit-activity/m/Martin-Bruel/nestjs-langchain" alt="GitHub commit activity"></a>
+  <a href="https://github.com/Martin-Bruel/nestjs-langchain/graphs/contributors"><img src="https://img.shields.io/github/contributors/Martin-Bruel/nestjs-langchain" alt="Contributors"></a>
+</p>
+
+<p align="center">
+  <img alt="GitHub last commit" src="https://img.shields.io/github/last-commit/Martin-Bruel/nestjs-langchain">
+  <a href="https://github.com/Martin-Bruel/nestjs-langchain/issues"><img alt="GitHub issues" src="https://img.shields.io/github/issues/Martin-Bruel/nestjs-langchain.svg"></a>
+  <a href="https://github.com/Martin-Bruel/nestjs-langchain/pulls"><img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/Martin-Bruel/nestjs-langchain"></a>
+</p>
+</p>
+
+**Table of Contents**
+
+- [Description](#description)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Defining tools](#defining-tools)
+- [Multi-agent support](#multi-agent-support)
+- [Async configuration](#async-configuration)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Description
+
+**nestjs-langchain** is a powerful, decorator-driven wrapper that integrates LangChain agents seamlessly into the NestJS ecosystem. It allows you to transform standard NestJS services into AI tools and manage multiple isolated agents with distinct roles and configurations.
+
+## Installation
+
+```bash
+npm install --save nestjs-langchain langchain @langchain/<ai-provider>
+```
+
+Having troubles configuring `nestjs-langchain`? Clone this repository and `cd` in a sample:
+
+```bash
+cd samples/chat
+npm install
+npm run start
+```
+
+## Quick start
+
+### 1. Register the module
+
+You can register the `LangChainModule` in your `AppModule` or any specific feature module.
+
+```ts
+import { LangChainModule } from 'nestjs-langchain';
+
+@Module({
+  imports: [
+    LangChainModule.register({
+      model: {
+        model: 'your-model-name', // Syntax: provider:model-name
+        apiKey: 'your-api-key',
+      },
+      systemPrompt: 'your-system-prompt',
+    }),
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+> **_NOTE:_** The model property allows you to select your AI engine based on the provider (OpenAI, Anthropic, Google, etc.). You can find the list of all available integrations here:  
+> 👉 [LangChain Chat Integrations](https://docs.langchain.com/oss/javascript/integrations/chat/index)
+
+### 2. Usage
+
+Once registered, simply inject the `LangChainService` to interact with your agent.
+
+```ts
+@Injectable()
+export class AppService {
+  constructor(private readonly agent: LangChainService) {}
+
+  async ask(question: string) {
+    return await this.agent.run(question);
+  }
+}
+```
+
+## Defining Tools
+
+Tools allow your AI agents to interact with the real world, fetch live data, and perform complex tasks, significantly enriching their responses beyond their static training data.
+
+### 1. Define the tool
+
+You can easily turn any NestJS service method into an AI tool using the @Tool() decorator.
+
+```ts
+import { Tool, ToolParam } from 'nestjs-langchain';
+
+@Injectable()
+export class MathService {
+  @Tool({ description: 'Adds two numbers together.' })
+  add(
+    @ToolParam({
+      name: 'a',
+      description: 'The first number to add.',
+      type: 'number',
+    })
+    a: number,
+    @ToolParam({
+      name: 'b',
+      description: 'The second number to add.',
+      type: 'number',
+    })
+    b: number,
+  ): number {
+    return a + b;
+  }
+}
+```
+
+### 2. Attach tool to the agent
+
+To make tools available to your agent, simply add the corresponding module to the tools array option of the LangChainModule during the registration.
+
+```ts
+import { LangChainModule } from 'nestjs-langchain';
+import { MathModule } from './math/math.module';
+
+@Module({
+  imports: [
+    LangChainModule.register({
+      model: {
+        model: 'your-model-name', // Syntax: provider:model-name
+        apiKey: 'your-api-key',
+      },
+      systemPrompt: 'your-system-prompt',
+      tools: [MathModule],
+    }),
+    MathModule,
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+> **_NOTE:_** Any module passed to the tools array of LangChainModule must also be imported into the NestJS context (usually in the same @Module decorator). This ensures that the services containing your @Tool() decorators are correctly instantiated and managed by the NestJS dependency injection system.
+
+## Multi-Agent Support
+
+If you need multiple agents with different roles in the same application, you can register them with unique names. Each agent is a distinct instance with its own configuration, system prompt, and specific set of tools. This isolation prevents "tool confusion" where an agent might try to use irrelevant tools for a given task, improving accuracy and reducing token costs.
+
+For example, you can have a "Support Agent" with access to your database and a "Math Agent" with access to calculation tools.
+
+### 1. Register a specific agent
+
+To register a specific agent you must define a name:
+
+```ts
+import { LangChainModule } from 'nestjs-langchain';
+import { MathModule } from './math/math.module';
+import { MongoModule } from './mongo/mongo.module';
+
+@Module({
+  imports: [
+    LangChainModule.register({
+      name: 'MATH_AGENT',
+      model: {
+        model: 'your-model-name', // Syntax: provider:model-name
+        apiKey: 'your-api-key',
+      },
+      systemPrompt: 'your-system-prompt',
+      tools: [MathModule],
+    }),
+    LangChainModule.register({
+      name: 'MONGO_AGENT',
+      model: {
+        model: 'your-model-name', // Syntax: provider:model-name
+        apiKey: 'your-api-key',
+      },
+      systemPrompt: 'your-system-prompt',
+      tools: [MongoModule],
+    }),
+    MathModule,
+    MongoModule,
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+### 2. Use a specific agent
+
+o use a specific agent in your services, use the @InjectAgent() decorator with the corresponding name:
+
+```ts
+@Injectable()
+export class AppService {
+  constructor(
+    @InjectAgent('MATH_AGENT') private readonly mathAgent: LangChainService,
+    @InjectAgent('SUPPORT_AGENT')
+    private readonly supportAgent: LangChainService,
+  ) {}
+
+  async solveProblem(query: string) {
+    return this.mathAgent.run(query);
+  }
+}
+```
+
+## Async Configuration
+
+To inject configuration from a ConfigService or other providers, use registerAsync:
+
+```ts
+import { LangChainModule } from 'nestjs-langchain';
+import { MathModule } from './math/math.module';
+import { MongoModule } from './mongo/mongo.module';
+
+@Module({
+  imports: [
+    LangChainModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => ({
+        model: {
+          model: 'openai:gpt-5-mini',
+          apiKey: configService.get<string>('OPENAI_API_KEY'),
+        },
+        systemPrompt: 'your-system-prompt',
+        tools: [MongoModule],
+      }),
+      inject: [ConfigService],
+      name: 'MONGO',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+> **_NOTE:_** The name property is required at the root of registerAsync because it defines the injection token used by @InjectAgent(). It cannot be determined dynamically inside the factory.
+
+## Contributing
+
+All types of contributions are encouraged and valued. See the Contributing guidelines, the community looks forward to your contributions!
+
+## License
+
+This project is released under the under terms of the MIT License.

package/dist/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './inject-agent.decorator';
+export * from './tool.decorator';

package/dist/decorators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./inject-agent.decorator"), exports);
+__exportStar(require("./tool.decorator"), exports);

package/dist/decorators/inject-agent.decorator.d.ts

@@ -0,0 +1 @@
+export declare const InjectAgent: (name: string) => PropertyDecorator & ParameterDecorator;

package/dist/decorators/inject-agent.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectAgent = void 0;
+const common_1 = require("@nestjs/common");
+const langchain_module_definition_1 = require("../langchain.module-definition");
+const InjectAgent = (name) => (0, common_1.Inject)((0, langchain_module_definition_1.getAgentToken)(name));
+exports.InjectAgent = InjectAgent;

package/dist/decorators/tool.decorator.d.ts

@@ -0,0 +1,13 @@
+export declare const TOOL_METADATA = "TOOL_METADATA";
+export declare const TOOL_PARAM_METADATA = "TOOL_PARAM_METADATA";
+export interface ToolOptions {
+    description: string;
+}
+export declare const Tool: (options: ToolOptions) => import("@nestjs/common").CustomDecorator<string>;
+export interface ToolParamOptions {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object';
+    description: string;
+}
+export declare const TOOL_PARAMS_METADATA = "LANGCHAIN_TOOL_PARAMS";
+export declare function ToolParam(options: ToolParamOptions): ParameterDecorator;

package/dist/decorators/tool.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_PARAMS_METADATA = exports.Tool = exports.TOOL_PARAM_METADATA = exports.TOOL_METADATA = void 0;
+exports.ToolParam = ToolParam;
+const common_1 = require("@nestjs/common");
+exports.TOOL_METADATA = 'TOOL_METADATA';
+exports.TOOL_PARAM_METADATA = 'TOOL_PARAM_METADATA';
+const Tool = (options) => (0, common_1.SetMetadata)(exports.TOOL_METADATA, options);
+exports.Tool = Tool;
+exports.TOOL_PARAMS_METADATA = 'LANGCHAIN_TOOL_PARAMS';
+function ToolParam(options) {
+    return (target, propertyKey, parameterIndex) => {
+        if (propertyKey === undefined) {
+            throw new Error('ToolParam can only be used on method parameters');
+        }
+        const existingParams = Reflect.getMetadata(exports.TOOL_PARAMS_METADATA, target, propertyKey) || [];
+        // On enregistre l'index pour savoir quel argument remplir plus tard
+        existingParams.push({ ...options, index: parameterIndex });
+        Reflect.defineMetadata(exports.TOOL_PARAMS_METADATA, existingParams, target, propertyKey);
+    };
+}

package/dist/factories/message.factory.d.ts

@@ -0,0 +1,7 @@
+import { AIMessage, Message, ToolMessage } from '../types/message';
+export declare class MessageFactory {
+    static fromLangChain(lcMessage: any): Message | AIMessage | ToolMessage;
+    private static mapBaseMessage;
+    private static mapAIMessage;
+    private static mapToolMessage;
+}

package/dist/factories/message.factory.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageFactory = void 0;
+const message_1 = require("../types/message");
+class MessageFactory {
+    static fromLangChain(lcMessage) {
+        if (lcMessage.name === 'model') {
+            return this.mapAIMessage(lcMessage);
+        }
+        else if (lcMessage.tool_call_id) {
+            return this.mapToolMessage(lcMessage);
+        }
+        return this.mapBaseMessage(lcMessage);
+    }
+    static mapBaseMessage(lcMessage) {
+        const message = new message_1.Message(lcMessage.id, lcMessage.name, lcMessage.content, message_1.MessageType.UNKNOWN);
+        return message;
+    }
+    static mapAIMessage(lcMessage) {
+        return new message_1.AIMessage(lcMessage.id, lcMessage.name, lcMessage.content, lcMessage.response_metadata, lcMessage.usage_metadata, lcMessage.tool_calls.map((tc) => {
+            return new message_1.ToolCall(tc.id, tc.name, tc.args);
+        }), lcMessage.invalid_tool_calls);
+    }
+    static mapToolMessage(lcMessage) {
+        return new message_1.ToolMessage(lcMessage.id, lcMessage.name, lcMessage.content, lcMessage.tool_call_id);
+    }
+}
+exports.MessageFactory = MessageFactory;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './langchain.module';
+export * from './decorators';
+export * from './langchain.service';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./langchain.module"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./langchain.service"), exports);

package/dist/interfaces/langchain-module-options.interface.d.ts

@@ -0,0 +1,14 @@
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export type Model = {
+    model: string;
+    apiKey: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeout?: number;
+    maxRetries?: number;
+};
+export interface LangChainModuleOptions {
+    model: Model;
+    systemPrompt?: string;
+    tools?: Type<any>[];
+}

package/dist/interfaces/langchain-module-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/langchain.module-definition.d.ts

@@ -0,0 +1,9 @@
+import { LangChainModuleOptions } from './interfaces/langchain-module-options.interface';
+export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<LangChainModuleOptions, "register", "create", {
+    name: string;
+}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: LangChainModuleOptions & Partial<{
+    name: string;
+}>, ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<LangChainModuleOptions, "create"> & Partial<{
+    name: string;
+}>;
+export declare const getAgentToken: (name: string) => string;

package/dist/langchain.module-definition.js

@@ -0,0 +1,13 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentToken = exports.ASYNC_OPTIONS_TYPE = exports.OPTIONS_TYPE = exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const common_1 = require("@nestjs/common");
+_a = new common_1.ConfigurableModuleBuilder()
+    .setExtras({ name: 'default' }, (definition, extras) => ({
+    ...definition,
+    tag: extras.name,
+}))
+    .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN, exports.OPTIONS_TYPE = _a.OPTIONS_TYPE, exports.ASYNC_OPTIONS_TYPE = _a.ASYNC_OPTIONS_TYPE;
+const getAgentToken = (name) => `LANGCHAIN_AGENT_${name.toUpperCase()}`;
+exports.getAgentToken = getAgentToken;

package/dist/langchain.module.d.ts

@@ -0,0 +1,7 @@
+import { DynamicModule } from '@nestjs/common';
+import { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, OPTIONS_TYPE } from './langchain.module-definition';
+export declare class LangChainModule extends ConfigurableModuleClass {
+    static register(options: typeof OPTIONS_TYPE): DynamicModule;
+    static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+    private static addDynamicAgentProvider;
+}

package/dist/langchain.module.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainModule = void 0;
+const common_1 = require("@nestjs/common");
+const langchain_module_definition_1 = require("./langchain.module-definition");
+const langchain_service_1 = require("./langchain.service");
+const tool_discovery_service_1 = require("./tool-discovery.service");
+const metadata_scanner_1 = require("@nestjs/core/metadata-scanner");
+const core_1 = require("@nestjs/core");
+let LangChainModule = class LangChainModule extends langchain_module_definition_1.ConfigurableModuleClass {
+    static register(options) {
+        const dynamicModule = super.register(options);
+        return this.addDynamicAgentProvider(dynamicModule, options.name);
+    }
+    static registerAsync(options) {
+        const dynamicModule = super.registerAsync(options);
+        return this.addDynamicAgentProvider(dynamicModule, options.name);
+    }
+    static addDynamicAgentProvider(dynamicModule, name) {
+        if (!name)
+            return dynamicModule;
+        const agentToken = (0, langchain_module_definition_1.getAgentToken)(name);
+        const agentProvider = {
+            provide: agentToken,
+            useExisting: langchain_service_1.LangChainService,
+        };
+        return {
+            ...dynamicModule,
+            providers: [...(dynamicModule.providers || []), agentProvider],
+            exports: [agentToken],
+        };
+    }
+};
+exports.LangChainModule = LangChainModule;
+exports.LangChainModule = LangChainModule = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.DiscoveryModule],
+        providers: [langchain_service_1.LangChainService, tool_discovery_service_1.ToolDiscoveryService, metadata_scanner_1.MetadataScanner],
+        exports: [langchain_service_1.LangChainService],
+    })
+], LangChainModule);

package/dist/langchain.service.d.ts

@@ -0,0 +1,18 @@
+import { OnModuleInit } from '@nestjs/common';
+import { LangChainModuleOptions } from './interfaces/langchain-module-options.interface';
+import { ToolDiscoveryService } from './tool-discovery.service';
+export declare class LangChainService implements OnModuleInit {
+    private readonly options;
+    private readonly toolDiscovery;
+    private agent;
+    private readonly logger;
+    constructor(options: LangChainModuleOptions, toolDiscovery: ToolDiscoveryService);
+    /**
+     * Discover tools and initialize the agent
+     */
+    onModuleInit(): Promise<void>;
+    /**
+     * Run the agent with the given input and stream the response
+     */
+    run(input: string): Promise<string>;
+}

package/dist/langchain.service.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var LangChainService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainService = void 0;
+const common_1 = require("@nestjs/common");
+const langchain_1 = require("langchain");
+const message_1 = require("./types/message");
+const message_factory_1 = require("./factories/message.factory");
+const langchain_module_definition_1 = require("./langchain.module-definition");
+const tool_discovery_service_1 = require("./tool-discovery.service");
+let LangChainService = LangChainService_1 = class LangChainService {
+    constructor(options, toolDiscovery) {
+        this.options = options;
+        this.toolDiscovery = toolDiscovery;
+        this.logger = new common_1.Logger(LangChainService_1.name);
+    }
+    /**
+     * Discover tools and initialize the agent
+     */
+    async onModuleInit() {
+        const tools = this.toolDiscovery.getToolsFromModules(this.options.tools || []);
+        const modelName = this.options.model.model;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { model: _, ...modelFields } = this.options.model;
+        const model = await (0, langchain_1.initChatModel)(modelName, modelFields);
+        this.agent = (0, langchain_1.createAgent)({
+            model,
+            tools,
+            systemPrompt: this.options.systemPrompt,
+        });
+        this.logger.log(`Agent initialized with ${tools.length} tools.`);
+    }
+    /**
+     * Run the agent with the given input and stream the response
+     */
+    async run(input) {
+        const humanMessage = new message_1.HumanMessage('no_id', 'user', input);
+        humanMessage.content = input;
+        common_1.Logger.verbose(humanMessage.getLogString());
+        for await (const chunk of await this.agent.stream({
+            messages: [{ role: 'user', content: input }],
+        }, { streamMode: 'updates' })) {
+            const message = message_factory_1.MessageFactory.fromLangChain(Object.values(chunk)[0].messages[0]);
+            common_1.Logger.verbose(message.getLogString());
+            if (message.isFinished()) {
+                return message.content;
+            }
+        }
+        throw new Error('No response from agent.');
+    }
+};
+exports.LangChainService = LangChainService;
+exports.LangChainService = LangChainService = LangChainService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(langchain_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object, tool_discovery_service_1.ToolDiscoveryService])
+], LangChainService);

package/dist/tool-discovery.service.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { DiscoveryService } from '@nestjs/core/discovery/discovery-service';
+import { MetadataScanner } from '@nestjs/core';
+export declare class ToolDiscoveryService {
+    private readonly discoveryService;
+    private readonly metadataScanner;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner);
+    private generateZodSchema;
+    getToolsFromModules(allowedModules: Type<any>[]): DynamicStructuredTool[];
+}

package/dist/tool-discovery.service.js

@@ -0,0 +1,79 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolDiscoveryService = void 0;
+const common_1 = require("@nestjs/common");
+const tools_1 = require("@langchain/core/tools");
+const tool_decorator_1 = require("./decorators/tool.decorator");
+const zod_1 = __importDefault(require("zod"));
+const discovery_service_1 = require("@nestjs/core/discovery/discovery-service");
+const core_1 = require("@nestjs/core");
+let ToolDiscoveryService = class ToolDiscoveryService {
+    constructor(discoveryService, metadataScanner) {
+        this.discoveryService = discoveryService;
+        this.metadataScanner = metadataScanner;
+    }
+    generateZodSchema(params) {
+        const schemaObject = {};
+        params.forEach((param) => {
+            switch (param.type) {
+                case 'number':
+                    schemaObject[param.name] = zod_1.default.number().describe(param.description);
+                    break;
+                case 'boolean':
+                    schemaObject[param.name] = zod_1.default.boolean().describe(param.description);
+                    break;
+                default:
+                    schemaObject[param.name] = zod_1.default.string().describe(param.description);
+            }
+        });
+        return zod_1.default.object(schemaObject);
+    }
+    getToolsFromModules(allowedModules) {
+        const providers = this.discoveryService.getProviders();
+        const allowedModuleNames = allowedModules.map((m) => m.name);
+        const tools = [];
+        providers.forEach((wrapper) => {
+            const { instance, host } = wrapper;
+            if (!instance || !host || !allowedModuleNames.includes(host.name)) {
+                return;
+            }
+            const methodNames = this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance));
+            methodNames.forEach((name) => {
+                const metadata = Reflect.getMetadata(tool_decorator_1.TOOL_METADATA, instance[name]);
+                const paramsMeta = Reflect.getMetadata(tool_decorator_1.TOOL_PARAMS_METADATA, instance, name) || [];
+                const zodSchema = this.generateZodSchema(paramsMeta);
+                if (metadata) {
+                    tools.push(new tools_1.DynamicStructuredTool({
+                        name: name,
+                        description: metadata.description,
+                        schema: zodSchema,
+                        func: (args) => {
+                            const sortedParams = paramsMeta.sort((a, b) => a.index - b.index);
+                            const orderedArgs = sortedParams.map((p) => args[p.name]);
+                            return instance[name](...orderedArgs);
+                        },
+                    }));
+                }
+            });
+        });
+        return tools;
+    }
+};
+exports.ToolDiscoveryService = ToolDiscoveryService;
+exports.ToolDiscoveryService = ToolDiscoveryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [discovery_service_1.DiscoveryService,
+        core_1.MetadataScanner])
+], ToolDiscoveryService);

package/dist/types/message.d.ts

@@ -0,0 +1,69 @@
+export declare class Message {
+    id: string;
+    name: string;
+    content: string;
+    type: MessageType;
+    constructor(id: string, name: string, content: string, type: MessageType);
+    getLogString(): string;
+    isFinished(): boolean;
+}
+export declare class HumanMessage extends Message {
+    constructor(id: string, name: string, content: string);
+    getLogString(): string;
+    isFinished(): boolean;
+}
+export declare class AIMessage extends Message {
+    response_metadata: ResponseMetadata;
+    usage_metadata: UsageMetadata;
+    tool_calls: ToolCall[];
+    invalid_tool_calls: any[];
+    constructor(id: string, name: string, content: string, response_metadata: ResponseMetadata, usage_metadata: UsageMetadata, tool_calls: ToolCall[], invalid_tool_calls: any[]);
+    getLogString(): string;
+    isFinished(): boolean;
+}
+export declare class ToolMessage extends Message {
+    constructor(id: string, name: string, content: string, tool_call_id: string);
+    tool_call_id: string;
+    getLogString(): string;
+}
+export declare class ToolCall {
+    name: string;
+    args: any;
+    id: string;
+    constructor(id: string, name: string, args: any);
+    toString(): string;
+}
+export declare class ResponseMetadata {
+    tokenUsage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finish_reason: string;
+    model_provider: string;
+    model_name: string;
+    constructor(tokenUsage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }, finish_reason: string, model_provider: string, model_name: string);
+}
+export declare enum FinishReason {
+    STOP = "stop",
+    TOOL_CALLS = "tool_calls",
+    UNKNOWN = "unknown"
+}
+export declare class UsageMetadata {
+    constructor(output_tokens: number, input_tokens: number, total_tokens: number, input_token_details: any, output_token_details: any);
+    output_tokens: number;
+    input_tokens: number;
+    total_tokens: number;
+    input_token_details: any;
+    output_token_details: any;
+}
+export declare enum MessageType {
+    AI = "ai",
+    HUMAN = "human",
+    TOOL = "tool",
+    UNKNOWN = "unknown"
+}

package/dist/types/message.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = exports.UsageMetadata = exports.FinishReason = exports.ResponseMetadata = exports.ToolCall = exports.ToolMessage = exports.AIMessage = exports.HumanMessage = exports.Message = void 0;
+class Message {
+    constructor(id, name, content, type) {
+        this.id = id;
+        this.name = name;
+        this.content = content;
+        this.type = type;
+    }
+    getLogString() {
+        return `Message [ID: ${this.id}, Name: ${this.name}, Type: ${this.type}, Content: ${this.content}]`;
+    }
+    isFinished() {
+        return false;
+    }
+}
+exports.Message = Message;
+class HumanMessage extends Message {
+    constructor(id, name, content) {
+        super(id, name, content, MessageType.HUMAN);
+    }
+    getLogString() {
+        return `HumanMessage: ${this.content}`;
+    }
+    isFinished() {
+        return false;
+    }
+}
+exports.HumanMessage = HumanMessage;
+class AIMessage extends Message {
+    constructor(id, name, content, response_metadata, usage_metadata, tool_calls, invalid_tool_calls) {
+        super(id, name, content, MessageType.AI);
+        this.response_metadata = response_metadata;
+        this.usage_metadata = usage_metadata;
+        this.tool_calls = tool_calls;
+        this.invalid_tool_calls = invalid_tool_calls;
+    }
+    getLogString() {
+        if (this.response_metadata?.finish_reason === FinishReason.TOOL_CALLS) {
+            return `AIMessage: Call tools: ${this.tool_calls
+                .map((tc) => tc.toString())
+                .join(', ')}`;
+        }
+        return `AIMessage: ${this.content}`;
+    }
+    isFinished() {
+        return this.response_metadata?.finish_reason === FinishReason.STOP;
+    }
+}
+exports.AIMessage = AIMessage;
+class ToolMessage extends Message {
+    constructor(id, name, content, tool_call_id) {
+        super(id, name, content, MessageType.TOOL);
+        this.tool_call_id = tool_call_id;
+    }
+    getLogString() {
+        return `ToolMessage call tool ${this.name} with args: ${this.content}`;
+    }
+}
+exports.ToolMessage = ToolMessage;
+class ToolCall {
+    constructor(id, name, args) {
+        this.name = name;
+        this.args = args;
+        this.id = id;
+    }
+    toString() {
+        return `${this.name} with args ${JSON.stringify(this.args)}`;
+    }
+}
+exports.ToolCall = ToolCall;
+class ResponseMetadata {
+    constructor(tokenUsage, finish_reason, model_provider, model_name) {
+        this.tokenUsage = tokenUsage;
+        this.finish_reason = finish_reason;
+        this.model_provider = model_provider;
+        this.model_name = model_name;
+    }
+}
+exports.ResponseMetadata = ResponseMetadata;
+var FinishReason;
+(function (FinishReason) {
+    FinishReason["STOP"] = "stop";
+    FinishReason["TOOL_CALLS"] = "tool_calls";
+    FinishReason["UNKNOWN"] = "unknown";
+})(FinishReason || (exports.FinishReason = FinishReason = {}));
+class UsageMetadata {
+    constructor(output_tokens, input_tokens, total_tokens, input_token_details, output_token_details) {
+        this.output_tokens = output_tokens;
+        this.input_tokens = input_tokens;
+        this.total_tokens = total_tokens;
+        this.input_token_details = input_token_details;
+        this.output_token_details = output_token_details;
+    }
+}
+exports.UsageMetadata = UsageMetadata;
+var MessageType;
+(function (MessageType) {
+    MessageType["AI"] = "ai";
+    MessageType["HUMAN"] = "human";
+    MessageType["TOOL"] = "tool";
+    MessageType["UNKNOWN"] = "unknown";
+})(MessageType || (exports.MessageType = MessageType = {}));

package/package.json

@@ -1,12 +1,91 @@
-{
-  "name": "nestjs-langchain",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
-}
+{
+  "name": "nestjs-langchain",
+  "version": "1.0.2",
+  "description": "NestJS librairy to build agent with LangChain",
+  "keywords": [
+    "nestjs",
+    "langchain",
+    "agents",
+    "ai"
+  ],
+  "author": "Martin Bruel",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rimraf -rf dist && tsc -p tsconfig.json",
+    "format": "prettier --write \"{lib,test}/**/*.ts\"",
+    "lint": "eslint \"lib/**/*.ts\" --fix",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next",
+    "test": "jest",
+    "test:integration": "jest --config ./tests/jest-e2e.json --runInBand",
+    "prerelease": "npm run build",
+    "release": "release-it",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "20.3.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@eslint/eslintrc": "3.3.3",
+    "@eslint/js": "9.39.2",
+    "@nestjs/cli": "^11.0.16",
+    "@nestjs/common": "^11.1.12",
+    "@nestjs/core": "^11.1.12",
+    "@nestjs/platform-express": "^11.1.12",
+    "@nestjs/schematics": "^11.0.9",
+    "@nestjs/testing": "^11.1.12",
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/lodash": "4.17.23",
+    "@types/node": "^25.1.0",
+    "@types/supertest": "^6.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "17.2.0",
+    "husky": "9.1.7",
+    "jest": "^30.2.0",
+    "joi": "18.0.2",
+    "lint-staged": "16.2.7",
+    "prettier": "^3.8.1",
+    "reflect-metadata": "^0.2.2",
+    "release-it": "19.2.4",
+    "rimraf": "6.1.2",
+    "rxjs": "^7.8.2",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.6",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.12",
+    "@nestjs/core": "^11.1.12",
+    "langchain": "^1.2.15",
+    "reflect-metadata": "^0.2.2"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  }
+}