@jterrazz/intelligence 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jean-Baptiste Terrazzoni <contact@jterrazz.com>
+
+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,229 @@
+# @jterrazz/intelligence
+
+**A composable, type-safe, and framework-agnostic AI agent library for TypeScript.**
+
+[![NPM Version](https://img.shields.io/npm/v/@jterrazz/intelligence.svg)](https://www.npmjs.com/package/@jterrazz/intelligence)
+[![License](https://img.shields.io/npm/l/@jterrazz/intelligence.svg)](./LICENSE)
+
+`@jterrazz/intelligence` provides a clean, structured, and extensible foundation for building sophisticated AI agents. By combining a composable prompt system, safe tool integration, and a ports-and-adapters architecture, it empowers developers to create reliable and maintainable AI-powered applications.
+
+---
+
+## Why Use This Library?
+
+- **🤖 Build Predictable Agents**: Use the composable prompt library to ensure your agents have a consistent personality, tone, and behavior.
+- **🛠️ Integrate Tools Safely**: `SafeToolAdapter` provides built-in error handling, logging, and Zod-based schema validation for all your tools.
+- **🏗️ Stay Flexible**: The ports-and-adapters architecture makes it easy to swap out underlying models or frameworks (like LangChain) without rewriting your core logic.
+- **🎯 Get Type-Safe Responses**: Move beyond string parsing with `AIResponseParser`, which validates and types your model's output against a Zod schema.
+
+## Installation
+
+```bash
+npm install @jterrazz/intelligence
+```
+
+---
+
+## Quick Start
+
+Get your first agent running in under a minute. This example uses a preset to create a helpful Discord community animator.
+
+```typescript
+import {
+  ChatAgentAdapter,
+  OpenRouterModelAdapter,
+  SystemPromptAdapter,
+  PROMPTS,
+} from '@jterrazz/intelligence';
+
+// 1. Set up the model provider
+const model = new OpenRouterModelAdapter({
+  apiKey: process.env.OPENROUTER_API_KEY!, // Make sure to set this environment variable
+  modelName: 'anthropic/claude-3.5-sonnet',
+});
+
+// 2. Create an agent using a preset prompt
+const agent = new ChatAgentAdapter(
+  'discord-bot',
+  new SystemPromptAdapter(PROMPTS.PRESETS.DISCORD_COMMUNITY_ANIMATOR),
+  { model },
+);
+
+// 3. Run the agent
+const response = await agent.run();
+
+console.log(response);
+// Output might be: "Hello, community! I'm here to help with any questions and keep the good vibes flowing. What's on your mind today?"
+```
+
+---
+
+## Core Concepts
+
+### 1. Composable Prompts
+
+Instead of writing monolithic prompts, the library provides a collection of composable string constants. Mix and match them to build a precise, fine-grained system prompt that defines your agent's behavior.
+
+- **`PERSONA`**: Who the agent is (e.g., `EXPERT_ADVISOR`).
+- **`TONE`**: How the agent communicates (e.g., `PROFESSIONAL`, `EMPATHETIC`).
+- **`FORMAT`** How the agent structures its response (e.g., `MARKDOWN`, `JSON`).
+- **`DIRECTIVES`**: Core rules the agent must follow (e.g., `BE_SAFE`, `BE_FACTUAL`).
+
+This approach makes agent behavior more predictable and easier to modify.
+
+### 2. Safe Tool Integration
+
+The `SafeToolAdapter` is a wrapper for your functions that ensures they are executed safely.
+
+```typescript
+import { SafeToolAdapter } from '@jterrazz/intelligence';
+import { z } from 'zod/v4';
+
+const weatherTool = new SafeToolAdapter(
+  {
+    name: 'get_weather',
+    description: 'Get the current weather for a specific city.',
+    execute: async ({ city }) => `The weather in ${city} is currently sunny.`,
+  },
+  {
+    // Zod schema for automatic validation and type-safety
+    schema: z.object({
+      city: z.string().describe('The city name'),
+    }),
+  },
+);
+```
+
+The adapter handles errors gracefully and integrates seamlessly with the agent, which will automatically provide the Zod schema to the underlying model.
+
+### 3. Ports and Adapters Architecture
+
+The library is built on a hexagonal architecture.
+
+- **Ports (`/ports`)**: Define the contracts (interfaces) for core components like `Agent`, `Model`, and `Tool`.
+- **Adapters (`/adapters`)**: Provide concrete implementations. For example, `ChatAgentAdapter` is an adapter that uses LangChain, and `OpenRouterModelAdapter` is an adapter for the OpenRouter API.
+
+This separation of concerns means you can easily create your own adapters to support different models or services without changing the application's core logic.
+
+```
+src/
+├── ports/      # Abstract interfaces (the "what")
+└── adapters/   # Concrete implementations (the "how")
+```
+
+---
+
+## Recipes
+
+### Recipe: Code Review Assistant
+
+This recipe creates an agent that acts as an expert software engineer, providing detailed feedback on code.
+
+```typescript
+import {
+  ChatAgentAdapter,
+  OpenRouterModelAdapter,
+  SystemPromptAdapter,
+  UserPromptAdapter,
+  PROMPTS,
+} from '@jterrazz/intelligence';
+
+const model = new OpenRouterModelAdapter({
+  apiKey: process.env.OPENROUTER_API_KEY!,
+  modelName: 'anthropic/claude-3.5-sonnet',
+});
+
+// 1. Compose the system prompt from multiple parts (using rest arguments)
+const systemPrompt = new SystemPromptAdapter(
+  PROMPTS.PERSONA.EXPERT_ADVISOR,
+  PROMPTS.DOMAIN.SOFTWARE_ENGINEERING,
+  PROMPTS.TONE.PROFESSIONAL,
+  PROMPTS.VERBOSITY.DETAILED,
+  PROMPTS.FORMAT.MARKDOWN,
+  PROMPTS.DIRECTIVES.BE_FACTUAL,
+);
+
+// 2. Create the user request (using a single array)
+const userPrompt = new UserPromptAdapter([
+  'Please review this TypeScript code for best practices:',
+  'const x = (s) => s.trim();',
+]);
+
+// 3. Configure and run the agent
+const agent = new ChatAgentAdapter('code-reviewer', systemPrompt, { model });
+
+const response = await agent.run(userPrompt);
+
+console.log(response);
+```
+
+### Recipe: Weather Bot with Tools
+
+This example shows how to give an agent a tool and have it respond to a user query.
+
+```typescript
+import {
+  ChatAgentAdapter,
+  OpenRouterModelAdapter,
+  SafeToolAdapter,
+  SystemPromptAdapter,
+  PROMPTS,
+} from '@jterrazz/intelligence';
+import { z } from 'zod/v4';
+
+// Assume 'model' is already configured
+
+// 1. Define the tool
+const weatherTool = new SafeToolAdapter(
+  {
+    name: 'get_weather',
+    description: 'Get the current weather for a location.',
+    execute: async ({ city }) => {
+      // In a real app, you would fetch from a weather API here
+      return `The weather in ${city} is 75°F and sunny.`;
+    },
+  },
+  { schema: z.object({ city: z.string().describe('City name') }) },
+);
+
+// 2. Create an agent that knows how to use tools
+const agent = new ChatAgentAdapter(
+  'weather-bot',
+  new SystemPromptAdapter(PROMPTS.PRESETS.EMPATHETIC_SUPPORT_AGENT), // A good general-purpose preset
+  {
+    model,
+    tools: [weatherTool], // Pass the tool instance directly
+  },
+);
+
+// 3. Run the agent with a user query that requires the tool
+const response = await agent.run({ generate: () => "What's the weather like in Boston?" });
+
+console.log(response);
+// Expected output: "The weather in Boston is 75°F and sunny."
+```
+
+---
+
+## API Reference
+
+### Core Components
+
+| Class                    | Description                                                                |
+| ------------------------ | -------------------------------------------------------------------------- |
+| `ChatAgentAdapter`       | The main agent implementation. Runs prompts and coordinates tools.         |
+| `OpenRouterModelAdapter` | An adapter for connecting to any model on the OpenRouter platform.         |
+| `SafeToolAdapter`        | A type-safe wrapper for creating tools with validation and error handling. |
+| `SystemPromptAdapter`    | A simple adapter to generate a system prompt string from a prompt array.   |
+| `UserPromptAdapter`      | A simple adapter to generate a user prompt string from a prompt array.     |
+| `AIResponseParser`       | A utility to parse a model's string output into a typed object using Zod.  |
+| `PROMPTS`                | A frozen object containing the entire composable prompt library.           |
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Author
+
+- Jean-Baptiste Terrazzoni ([@jterrazz](https://github.com/jterrazz))
+- Email: contact@jterrazz.com

package/dist/adapters/agents/chat-agent.adapter.d.ts

@@ -0,0 +1,35 @@
+import { type LoggerPort } from '@jterrazz/logger';
+import { z } from 'zod/v4';
+import type { Agent } from '../../ports/agent.port.js';
+import type { Model } from '../../ports/model.port.js';
+import type { Prompt } from '../../ports/prompt.port.js';
+import type { Tool } from '../../ports/tool.port.js';
+import type { SystemPromptAdapter } from '../prompts/system-prompt.adapter.js';
+export type AgentResponse = z.infer<typeof AgentResponseSchema>;
+export interface ChatAgentOptions {
+    logger?: LoggerPort;
+    model: Model;
+    tools: Tool[];
+}
+declare const AgentResponseSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    shouldRespond: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Chat agent adapter that provides structured chat capabilities with optional responses
+ */
+export declare class ChatAgentAdapter implements Agent {
+    private readonly executorPromise;
+    private readonly logger?;
+    private readonly name;
+    private readonly responseParser;
+    constructor(name: string, systemPrompt: SystemPromptAdapter, options: ChatAgentOptions);
+    run(userPrompt?: Prompt): Promise<null | string>;
+    private createExecutor;
+    private extractActionInput;
+    private handleResponse;
+    private parseAgentResponse;
+    private resolveUserInput;
+}
+export {};

package/dist/adapters/agents/chat-agent.adapter.js

@@ -0,0 +1,388 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate } from '@langchain/core/prompts';
+import { AgentExecutor, createStructuredChatAgent } from 'langchain/agents';
+import { z } from 'zod/v4';
+import { AIResponseParser } from '../utils/ai-response-parser.js';
+// Schema for agent responses
+var AgentResponseSchema = z.object({
+    message: z.string().optional(),
+    reason: z.string().optional(),
+    shouldRespond: z["boolean"]()
+});
+// LangChain-specific framework rules (internal to this adapter)
+var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent piloted by the LangChain framework.\n\nYou have access to the following tools: {tools}\nTool names: {tool_names}\nAgent scratchpad: {agent_scratchpad}\n\nWhen you want to provide your final response, you MUST format it exactly like this:\n\n```json\n{{"action": "Final Answer", "action_input": {{"shouldRespond": false, "reason": "<your reason>"}}}}\n```\n\nOR \n\n```json\n{{"action": "Final Answer", "action_input": {{"shouldRespond": true, "message": "<your response message>"}}}}\n```\n\n"shouldRespond" set to true means the message will be sent to the user.\n"shouldRespond" set to false means the message will not be sent to the user.\n\nALWAYS use this exact format with markdown code blocks and the action/action_input structure.\n</AGENT_FRAMEWORK>';
+/**
+ * Chat agent adapter that provides structured chat capabilities with optional responses
+ */ export var ChatAgentAdapter = /*#__PURE__*/ function() {
+    "use strict";
+    function ChatAgentAdapter(name, systemPrompt, options) {
+        _class_call_check(this, ChatAgentAdapter);
+        _define_property(this, "executorPromise", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "responseParser", void 0);
+        this.name = name;
+        this.logger = options.logger;
+        this.responseParser = new AIResponseParser(AgentResponseSchema);
+        this.executorPromise = this.createExecutor(systemPrompt, options);
+    }
+    _create_class(ChatAgentAdapter, [
+        {
+            key: "run",
+            value: function run(userPrompt) {
+                return _async_to_generator(function() {
+                    var _this_logger, executor, input, result, response, error, _this_logger1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this.executorPromise
+                                ];
+                            case 1:
+                                executor = _state.sent();
+                                input = this.resolveUserInput(userPrompt);
+                                return [
+                                    4,
+                                    executor.invoke({
+                                        input: input
+                                    })
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.debug('Agent execution result', {
+                                    agentName: this.name,
+                                    hasOutput: 'output' in result,
+                                    hasUserPrompt: !!userPrompt,
+                                    outputType: _type_of(result.output)
+                                });
+                                if (!result || typeof result.output === 'undefined') {
+                                    throw new Error('Agent returned invalid result structure');
+                                }
+                                response = this.parseAgentResponse(result.output);
+                                return [
+                                    2,
+                                    this.handleResponse(response)
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                (_this_logger1 = this.logger) === null || _this_logger1 === void 0 ? void 0 : _this_logger1.error('Error running chat agent', {
+                                    agentName: this.name,
+                                    error: _instanceof(error, Error) ? error.message : 'Unknown error',
+                                    userPrompt: userPrompt ? 'Prompt object' : 'none'
+                                });
+                                return [
+                                    2,
+                                    null
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "createExecutor",
+            value: function createExecutor(systemPrompt, options) {
+                return _async_to_generator(function() {
+                    var model, dynamicTools, systemPromptText, systemTemplate, humanTemplate, prompt, agent;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                model = options.model.getModel();
+                                // Convert Tool instances to DynamicTool instances
+                                dynamicTools = options.tools.map(function(tool) {
+                                    return tool.getDynamicTool();
+                                });
+                                // Combine LangChain framework rules with user-provided system prompts
+                                systemPromptText = "".concat(LANGCHAIN_FRAMEWORK_RULES, "\n\n").concat(systemPrompt.generate());
+                                systemTemplate = SystemMessagePromptTemplate.fromTemplate(systemPromptText);
+                                humanTemplate = HumanMessagePromptTemplate.fromTemplate('{input}');
+                                prompt = ChatPromptTemplate.fromMessages([
+                                    systemTemplate,
+                                    humanTemplate
+                                ]);
+                                return [
+                                    4,
+                                    createStructuredChatAgent({
+                                        llm: model,
+                                        prompt: prompt,
+                                        tools: dynamicTools
+                                    })
+                                ];
+                            case 1:
+                                agent = _state.sent();
+                                return [
+                                    2,
+                                    AgentExecutor.fromAgentAndTools({
+                                        agent: agent,
+                                        tools: dynamicTools
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "extractActionInput",
+            value: function extractActionInput(output) {
+                if ((typeof output === "undefined" ? "undefined" : _type_of(output)) === 'object' && output !== null) {
+                    return JSON.stringify(output);
+                }
+                if (typeof output !== 'string') {
+                    return String(output);
+                }
+                // Check for LangChain's action/action_input format first
+                var codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
+                if (codeBlockMatch) {
+                    var content = codeBlockMatch[1].trim();
+                    try {
+                        var parsed = JSON.parse(content);
+                        if (parsed.action === 'Final Answer' && parsed.action_input) {
+                            return JSON.stringify(parsed.action_input);
+                        }
+                    } catch (e) {
+                    // Fall through to return original content
+                    }
+                    return content;
+                }
+                // Fallback: Look for "Final Answer:" pattern
+                if (output.includes('Final Answer:')) {
+                    var actionInputMatch = output.match(/Final Answer:\s*([\s\S]*?)$/i);
+                    if (actionInputMatch) {
+                        return actionInputMatch[1].trim();
+                    }
+                }
+                return output;
+            }
+        },
+        {
+            key: "handleResponse",
+            value: function handleResponse(response) {
+                var _this_logger;
+                if (response.shouldRespond && response.message) {
+                    var _this_logger1;
+                    (_this_logger1 = this.logger) === null || _this_logger1 === void 0 ? void 0 : _this_logger1.info('Agent responding with message', {
+                        agentName: this.name
+                    });
+                    return response.message;
+                }
+                if (!response.shouldRespond) {
+                    var _this_logger2;
+                    (_this_logger2 = this.logger) === null || _this_logger2 === void 0 ? void 0 : _this_logger2.info('Agent chose not to respond', {
+                        agentName: this.name,
+                        reason: response.reason
+                    });
+                    return null;
+                }
+                (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.error('Invalid agent response state', {
+                    agentName: this.name,
+                    response: response
+                });
+                return null;
+            }
+        },
+        {
+            key: "parseAgentResponse",
+            value: function parseAgentResponse(output) {
+                try {
+                    // Handle LangChain's action/action_input format
+                    var processedOutput = this.extractActionInput(output);
+                    return this.responseParser.parse(processedOutput);
+                } catch (error) {
+                    var _this_logger;
+                    (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.error('Failed to parse agent response', {
+                        agentName: this.name,
+                        error: _instanceof(error, Error) ? error.message : 'Unknown error',
+                        rawOutput: output
+                    });
+                    throw new Error('Invalid agent response format');
+                }
+            }
+        },
+        {
+            key: "resolveUserInput",
+            value: function resolveUserInput(userPrompt) {
+                if (!userPrompt) {
+                    return 'Please analyze the current situation and respond if appropriate.';
+                }
+                return userPrompt.generate();
+            }
+        }
+    ]);
+    return ChatAgentAdapter;
+}();
+
+//# sourceMappingURL=chat-agent.adapter.js.map