@jterrazz/intelligence 1.0.0 → 1.1.1

package/README.md

@@ -43,11 +43,10 @@ const model = new OpenRouterModelAdapter({
 });
 
 // 2. Create an agent using a preset prompt
-const agent = new ChatAgentAdapter(
-  'discord-bot',
-  new SystemPromptAdapter(PROMPTS.PRESETS.DISCORD_COMMUNITY_ANIMATOR),
-  { model },
-);
+const agent = new ChatAgentAdapter('discord-bot', {
+  model,
+  systemPrompt: new SystemPromptAdapter(PROMPTS.PRESETS.DISCORD_COMMUNITY_ANIMATOR),
+});
 
 // 3. Run the agent
 const response = await agent.run();
@@ -150,13 +149,113 @@ const userPrompt = new UserPromptAdapter([
 ]);
 
 // 3. Configure and run the agent
-const agent = new ChatAgentAdapter('code-reviewer', systemPrompt, { model });
+const agent = new ChatAgentAdapter('code-reviewer', {
+  model,
+  systemPrompt,
+});
 
 const response = await agent.run(userPrompt);
 
 console.log(response);
 ```
 
+### Recipe: Simple Text Processor (QueryAgent)
+
+This example shows how to use the simpler `QueryAgentAdapter` for one-shot responses without tools.
+
+```typescript
+import {
+  QueryAgentAdapter,
+  OpenRouterModelAdapter,
+  SystemPromptAdapter,
+  UserPromptAdapter,
+  PROMPTS,
+} from '@jterrazz/intelligence';
+
+const model = new OpenRouterModelAdapter({
+  apiKey: process.env.OPENROUTER_API_KEY!,
+  modelName: 'anthropic/claude-3.5-sonnet',
+});
+
+// 1. Create a simple system prompt for text processing
+const systemPrompt = new SystemPromptAdapter(
+  PROMPTS.PERSONA.EXPERT_ADVISOR,
+  PROMPTS.TONE.PROFESSIONAL,
+  PROMPTS.FORMAT.MARKDOWN,
+  'You are a helpful assistant that improves text clarity and grammar.',
+);
+
+// 2. Create a query agent (no tools needed)
+const agent = new QueryAgentAdapter('text-processor', {
+  model,
+  systemPrompt,
+});
+
+// 3. Run a simple query
+const userPrompt = new UserPromptAdapter(
+  'Please improve this text: "Me and john was going to store yesterday"',
+);
+const response = await agent.run(userPrompt);
+
+console.log(response);
+// Expected output: A grammatically corrected and improved version of the text
+```
+
+### Recipe: Structured Data Extraction (QueryAgent with Schema)
+
+This example shows how to use `QueryAgentAdapter` with schema parsing for structured responses.
+
+```typescript
+import {
+  QueryAgentAdapter,
+  OpenRouterModelAdapter,
+  SystemPromptAdapter,
+  UserPromptAdapter,
+  PROMPTS,
+} from '@jterrazz/intelligence';
+import { z } from 'zod/v4';
+
+const model = new OpenRouterModelAdapter({
+  apiKey: process.env.OPENROUTER_API_KEY!,
+  modelName: 'anthropic/claude-3.5-sonnet',
+});
+
+// 1. Define the response schema
+const extractionSchema = z.object({
+  name: z.string(),
+  email: z.string().email(),
+  phone: z.string().optional(),
+  company: z.string().optional(),
+});
+
+// 2. Create a system prompt for data extraction
+const systemPrompt = new SystemPromptAdapter(
+  PROMPTS.PERSONA.EXPERT_ADVISOR,
+  PROMPTS.TONE.PROFESSIONAL,
+  PROMPTS.FORMAT.JSON,
+  'You extract contact information from text and return it as JSON.',
+);
+
+// 3. Create a query agent with schema parsing
+const agent = new QueryAgentAdapter('contact-extractor', {
+  model,
+  schema: extractionSchema,
+  systemPrompt,
+});
+
+// 4. Run the query
+const userPrompt = new UserPromptAdapter(
+  'Extract contact info: "Hi, I\'m John Doe from TechCorp. Email me at john@techcorp.com or call 555-1234"',
+);
+const response = await agent.run(userPrompt);
+
+// 5. Get both raw response and parsed data
+console.log('Raw response:', response);
+const parsedData = agent.getLastParsedResult();
+console.log('Parsed data:', parsedData);
+// Expected: { name: "John Doe", email: "john@techcorp.com", phone: "555-1234", company: "TechCorp" }
+```
+
 ### Recipe: Weather Bot with Tools
 
 This example shows how to give an agent a tool and have it respond to a user query.
@@ -187,14 +286,11 @@ const weatherTool = new SafeToolAdapter(
 );
 
 // 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
-  },
-);
+const agent = new ChatAgentAdapter('weather-bot', {
+  model,
+  systemPrompt: new SystemPromptAdapter(PROMPTS.PRESETS.EMPATHETIC_SUPPORT_AGENT), // A good general-purpose preset
+  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?" });
@@ -212,6 +308,7 @@ console.log(response);
 | Class                    | Description                                                                |
 | ------------------------ | -------------------------------------------------------------------------- |
 | `ChatAgentAdapter`       | The main agent implementation. Runs prompts and coordinates tools.         |
+| `QueryAgentAdapter`      | A simpler agent for one-shot responses without tools or complex logic.     |
 | `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.   |

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

@@ -1,35 +1,29 @@
 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 z } from 'zod/v4';
+import { type AgentPort } from '../../ports/agent.port.js';
+import type { ModelPort } from '../../ports/model.port.js';
+import type { PromptPort } from '../../ports/prompt.port.js';
+import type { ToolPort } from '../../ports/tool.port.js';
 import type { SystemPromptAdapter } from '../prompts/system-prompt.adapter.js';
-export type AgentResponse = z.infer<typeof AgentResponseSchema>;
-export interface ChatAgentOptions {
+export interface ChatAgentOptions<T = unknown> {
     logger?: LoggerPort;
-    model: Model;
-    tools: Tool[];
+    model: ModelPort;
+    schema?: z.ZodSchema<T>;
+    systemPrompt: SystemPromptAdapter;
+    tools: ToolPort[];
+    verbose?: boolean;
 }
-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
+ * An advanced agent that uses tools and a structured prompt to engage in conversational chat.
+ * It can decide whether to respond or remain silent and supports schema-validated 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>;
+export declare class ChatAgentAdapter<T = unknown> implements AgentPort {
+    readonly name: string;
+    private readonly options;
+    constructor(name: string, options: ChatAgentOptions<T>);
+    run(userPrompt?: PromptPort): Promise<null | string>;
     private createExecutor;
-    private extractActionInput;
-    private handleResponse;
-    private parseAgentResponse;
+    private parseAgentOutput;
     private resolveUserInput;
+    private validateResponseContent;
 }
-export {};

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

@@ -66,10 +66,6 @@ function _instanceof(left, right) {
         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,
@@ -161,89 +157,95 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate } from '@langchain/core/prompts';
+import { ChatPromptTemplate } 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>';
+var SYSTEM_PROMPT_TEMPLATE = '\n<OBJECTIVE>\n{mission_prompt}\n</OBJECTIVE>\n\n<OUTPUT_FORMAT>\nCRITICAL: The format instructions in this section are the ONLY valid way to structure your response. Any formatting guidelines within the <OBJECTIVE> section (like message templates) apply ONLY to the content that goes inside the "RESPOND: " part of your final answer.\n\nYou have two ways to respond:\n\n1.  **Call a tool** to gather information. For this, you MUST output a JSON blob with the tool\'s name and its input.\n    *Valid tool names are: {tool_names}*\n    ```json\n    {{\n      "action": "tool_name_to_use",\n      "action_input": "the input for the tool, or an empty object {{}} if no input is needed"\n    }}\n    ```\n\n2.  **Provide the Final Answer** once you have enough information. For this, you MUST output a JSON blob with the "Final Answer" action. The input must start with "RESPOND: " or "SILENT: ".\n    - To send a message:\n      ```json\n      {{\n        "action": "Final Answer",\n        "action_input": "RESPOND: <your response message>"\n      }}\n      ```\n    - To stay silent:\n      ```json\n      {{\n        "action": "Final Answer",\n        "action_input": "SILENT: <your reason for staying silent>"\n      }}\n      ```\n</OUTPUT_FORMAT>\n\n<EXECUTION_CONTEXT>\nThis is internal data for your reference.\n\n<TOOLS>\n{tools}\n</TOOLS>\n\n<WORKING_MEMORY>\nThis is your internal thought process and previous tool usage.\n{agent_scratchpad}\n</WORKING_MEMORY>\n</EXECUTION_CONTEXT>\n';
 /**
- * Chat agent adapter that provides structured chat capabilities with optional responses
+ * An advanced agent that uses tools and a structured prompt to engage in conversational chat.
+ * It can decide whether to respond or remain silent and supports schema-validated responses.
  */ export var ChatAgentAdapter = /*#__PURE__*/ function() {
     "use strict";
-    function ChatAgentAdapter(name, systemPrompt, options) {
+    function ChatAgentAdapter(name, 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);
+        _define_property(this, "options", void 0);
         this.name = name;
-        this.logger = options.logger;
-        this.responseParser = new AIResponseParser(AgentResponseSchema);
-        this.executorPromise = this.createExecutor(systemPrompt, options);
+        this.options = 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;
+                    var _this_options_logger, _this_options_logger1, executor, userInput, result, agentResponse, _this_options_logger2, _agentResponse_message, message, _this_options_logger3, _this_options_logger4, error, _this_options_logger5;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
+                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug("[".concat(this.name, "] Starting chat execution."));
+                                _state.label = 1;
+                            case 1:
                                 _state.trys.push([
-                                    0,
-                                    3,
+                                    1,
+                                    4,
                                     ,
-                                    4
+                                    5
                                 ]);
                                 return [
                                     4,
-                                    this.executorPromise
+                                    this.createExecutor()
                                 ];
-                            case 1:
+                            case 2:
                                 executor = _state.sent();
-                                input = this.resolveUserInput(userPrompt);
+                                userInput = this.resolveUserInput(userPrompt);
                                 return [
                                     4,
                                     executor.invoke({
-                                        input: input
+                                        input: userInput
                                     })
                                 ];
-                            case 2:
+                            case 3:
                                 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)
+                                (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.debug("[".concat(this.name, "] Agent execution completed."), {
+                                    hasOutput: 'output' in result
                                 });
-                                if (!result || typeof result.output === 'undefined') {
-                                    throw new Error('Agent returned invalid result structure');
+                                if (!result || typeof result.output !== 'string') {
+                                    throw new Error('Agent returned an invalid result structure.');
+                                }
+                                agentResponse = this.parseAgentOutput(result.output);
+                                if (!agentResponse.shouldRespond) {
+                                    ;
+                                    (_this_options_logger2 = this.options.logger) === null || _this_options_logger2 === void 0 ? void 0 : _this_options_logger2.info("[".concat(this.name, "] Agent chose to remain silent."), {
+                                        reason: agentResponse.reason
+                                    });
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                                message = (_agentResponse_message = agentResponse.message) !== null && _agentResponse_message !== void 0 ? _agentResponse_message : '';
+                                if (this.options.schema) {
+                                    ;
+                                    this.validateResponseContent(message, this.options.schema);
+                                    (_this_options_logger3 = this.options.logger) === null || _this_options_logger3 === void 0 ? void 0 : _this_options_logger3.info("[".concat(this.name, "] Execution finished; response content validated."));
+                                } else {
+                                    ;
+                                    (_this_options_logger4 = this.options.logger) === null || _this_options_logger4 === void 0 ? void 0 : _this_options_logger4.info("[".concat(this.name, "] Execution finished."));
                                 }
-                                response = this.parseAgentResponse(result.output);
                                 return [
                                     2,
-                                    this.handleResponse(response)
+                                    message
                                 ];
-                            case 3:
+                            case 4:
                                 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'
+                                (_this_options_logger5 = this.options.logger) === null || _this_options_logger5 === void 0 ? void 0 : _this_options_logger5.error("[".concat(this.name, "] Chat execution failed."), {
+                                    error: _instanceof(error, Error) ? error.message : 'Unknown error'
                                 });
                                 return [
                                     2,
                                     null
                                 ];
-                            case 4:
+                            case 5:
                                 return [
                                     2
                                 ];
@@ -254,31 +256,32 @@ var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent pilot
         },
         {
             key: "createExecutor",
-            value: function createExecutor(systemPrompt, options) {
+            value: function createExecutor() {
                 return _async_to_generator(function() {
-                    var model, dynamicTools, systemPromptText, systemTemplate, humanTemplate, prompt, agent;
+                    var model, tools, 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) {
+                                model = this.options.model.getModel();
+                                tools = this.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
+                                    [
+                                        'system',
+                                        SYSTEM_PROMPT_TEMPLATE.replace('{mission_prompt}', this.options.systemPrompt.generate())
+                                    ],
+                                    [
+                                        'human',
+                                        '{input}'
+                                    ]
                                 ]);
                                 return [
                                     4,
                                     createStructuredChatAgent({
                                         llm: model,
                                         prompt: prompt,
-                                        tools: dynamicTools
+                                        tools: tools
                                     })
                                 ];
                             case 1:
@@ -287,98 +290,65 @@ var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent pilot
                                     2,
                                     AgentExecutor.fromAgentAndTools({
                                         agent: agent,
-                                        tools: dynamicTools
+                                        tools: tools,
+                                        verbose: this.options.verbose
                                     })
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
-            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;
+            key: "parseAgentOutput",
+            value: function parseAgentOutput(output) {
+                var _this_options_logger;
+                var text = output.trim();
+                var respondMatch = text.match(/^RESPOND:\s*([\s\S]+)$/i);
+                if (respondMatch) {
+                    return {
+                        message: respondMatch[1].trim(),
+                        shouldRespond: true
+                    };
                 }
-                // 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();
-                    }
+                var silentMatch = text.match(/^SILENT:\s*([\s\S]+)$/i);
+                if (silentMatch) {
+                    return {
+                        reason: silentMatch[1].trim(),
+                        shouldRespond: false
+                    };
                 }
-                return output;
+                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.warn("[".concat(this.name, "] Agent output was missing 'RESPOND:' or 'SILENT:' prefix. Treating as a direct response."), {
+                    rawOutput: output
+                });
+                return {
+                    message: text,
+                    shouldRespond: true
+                };
             }
         },
         {
-            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;
+            key: "resolveUserInput",
+            value: function resolveUserInput(userPrompt) {
+                if (userPrompt) {
+                    return userPrompt.generate();
                 }
-                (_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;
+                return 'Proceed with your instructions.';
             }
         },
         {
-            key: "parseAgentResponse",
-            value: function parseAgentResponse(output) {
+            key: "validateResponseContent",
+            value: function validateResponseContent(content, schema) {
                 try {
-                    // Handle LangChain's action/action_input format
-                    var processedOutput = this.extractActionInput(output);
-                    return this.responseParser.parse(processedOutput);
+                    new AIResponseParser(schema).parse(content);
                 } 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,
+                    var _this_options_logger;
+                    (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.error("[".concat(this.name, "] Failed to validate response content against schema."), {
                         error: _instanceof(error, Error) ? error.message : 'Unknown error',
-                        rawOutput: output
+                        rawContent: content
                     });
-                    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.';
+                    throw new Error('Invalid response content from model.');
                 }
-                return userPrompt.generate();
             }
         }
     ]);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/agents/chat-agent.adapter.ts"],"sourcesContent":["import { type LoggerPort } from '@jterrazz/logger';\nimport {\n    ChatPromptTemplate,\n    HumanMessagePromptTemplate,\n    SystemMessagePromptTemplate,\n} from '@langchain/core/prompts';\nimport { AgentExecutor, createStructuredChatAgent } from 'langchain/agents';\nimport { z } from 'zod/v4';\n\nimport type { Agent } from '../../ports/agent.port.js';\nimport type { Model } from '../../ports/model.port.js';\nimport type { Prompt } from '../../ports/prompt.port.js';\nimport type { Tool } from '../../ports/tool.port.js';\n\nimport { AIResponseParser } from '../utils/ai-response-parser.js';\n\nimport type { SystemPromptAdapter } from '../prompts/system-prompt.adapter.js';\n\nexport type AgentResponse = z.infer<typeof AgentResponseSchema>;\n\nexport interface ChatAgentOptions {\n    logger?: LoggerPort;\n    model: Model;\n    tools: Tool[];\n}\n\n// Schema for agent responses\nconst AgentResponseSchema = z.object({\n    message: z.string().optional(),\n    reason: z.string().optional(),\n    shouldRespond: z.boolean(),\n});\n\n// LangChain-specific framework rules (internal to this adapter)\nconst 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>`;\n\n/**\n * Chat agent adapter that provides structured chat capabilities with optional responses\n */\nexport class ChatAgentAdapter implements Agent {\n    private readonly executorPromise: Promise<AgentExecutor>;\n    private readonly logger?: LoggerPort;\n    private readonly name: string;\n    private readonly responseParser: AIResponseParser<AgentResponse>;\n\n    constructor(name: string, systemPrompt: SystemPromptAdapter, options: ChatAgentOptions) {\n        this.name = name;\n        this.logger = options.logger;\n        this.responseParser = new AIResponseParser(AgentResponseSchema);\n        this.executorPromise = this.createExecutor(systemPrompt, options);\n    }\n\n    async run(userPrompt?: Prompt): Promise<null | string> {\n        try {\n            const executor = await this.executorPromise;\n            const input = this.resolveUserInput(userPrompt);\n            const result = await executor.invoke({ input });\n\n            this.logger?.debug('Agent execution result', {\n                agentName: this.name,\n                hasOutput: 'output' in result,\n                hasUserPrompt: !!userPrompt,\n                outputType: typeof result.output,\n            });\n\n            if (!result || typeof result.output === 'undefined') {\n                throw new Error('Agent returned invalid result structure');\n            }\n\n            const response = this.parseAgentResponse(result.output);\n            return this.handleResponse(response);\n        } catch (error) {\n            this.logger?.error('Error running chat agent', {\n                agentName: this.name,\n                error: error instanceof Error ? error.message : 'Unknown error',\n                userPrompt: userPrompt ? 'Prompt object' : 'none',\n            });\n            return null;\n        }\n    }\n\n    private async createExecutor(\n        systemPrompt: SystemPromptAdapter,\n        options: ChatAgentOptions,\n    ): Promise<AgentExecutor> {\n        const model = options.model.getModel();\n\n        // Convert Tool instances to DynamicTool instances\n        const dynamicTools = options.tools.map((tool) => tool.getDynamicTool());\n\n        // Combine LangChain framework rules with user-provided system prompts\n        const systemPromptText = `${LANGCHAIN_FRAMEWORK_RULES}\\n\\n${systemPrompt.generate()}`;\n        const systemTemplate = SystemMessagePromptTemplate.fromTemplate(systemPromptText);\n        const humanTemplate = HumanMessagePromptTemplate.fromTemplate('{input}');\n\n        const prompt = ChatPromptTemplate.fromMessages([systemTemplate, humanTemplate]);\n\n        const agent = await createStructuredChatAgent({\n            llm: model,\n            prompt,\n            tools: dynamicTools,\n        });\n\n        return AgentExecutor.fromAgentAndTools({\n            agent,\n            tools: dynamicTools,\n        });\n    }\n\n    private extractActionInput(output: unknown): string {\n        if (typeof output === 'object' && output !== null) {\n            return JSON.stringify(output);\n        }\n\n        if (typeof output !== 'string') {\n            return String(output);\n        }\n\n        // Check for LangChain's action/action_input format first\n        const codeBlockMatch = output.match(/```(?:json)?\\s*([\\s\\S]*?)```/i);\n        if (codeBlockMatch) {\n            const content = codeBlockMatch[1].trim();\n            try {\n                const parsed = JSON.parse(content);\n                if (parsed.action === 'Final Answer' && parsed.action_input) {\n                    return JSON.stringify(parsed.action_input);\n                }\n            } catch {\n                // Fall through to return original content\n            }\n            return content;\n        }\n\n        // Fallback: Look for \"Final Answer:\" pattern\n        if (output.includes('Final Answer:')) {\n            const actionInputMatch = output.match(/Final Answer:\\s*([\\s\\S]*?)$/i);\n            if (actionInputMatch) {\n                return actionInputMatch[1].trim();\n            }\n        }\n\n        return output;\n    }\n\n    private handleResponse(response: AgentResponse): null | string {\n        if (response.shouldRespond && response.message) {\n            this.logger?.info('Agent responding with message', { agentName: this.name });\n            return response.message;\n        }\n\n        if (!response.shouldRespond) {\n            this.logger?.info('Agent chose not to respond', {\n                agentName: this.name,\n                reason: response.reason,\n            });\n            return null;\n        }\n\n        this.logger?.error('Invalid agent response state', { agentName: this.name, response });\n        return null;\n    }\n\n    private parseAgentResponse(output: unknown): AgentResponse {\n        try {\n            // Handle LangChain's action/action_input format\n            const processedOutput = this.extractActionInput(output);\n            return this.responseParser.parse(processedOutput);\n        } catch (error) {\n            this.logger?.error('Failed to parse agent response', {\n                agentName: this.name,\n                error: error instanceof Error ? error.message : 'Unknown error',\n                rawOutput: output,\n            });\n            throw new Error('Invalid agent response format');\n        }\n    }\n\n    private resolveUserInput(userPrompt?: Prompt): string {\n        if (!userPrompt) {\n            return 'Please analyze the current situation and respond if appropriate.';\n        }\n\n        return userPrompt.generate();\n    }\n}\n"],"names":["ChatPromptTemplate","HumanMessagePromptTemplate","SystemMessagePromptTemplate","AgentExecutor","createStructuredChatAgent","z","AIResponseParser","AgentResponseSchema","object","message","string","optional","reason","shouldRespond","boolean","LANGCHAIN_FRAMEWORK_RULES","ChatAgentAdapter","name","systemPrompt","options","executorPromise","logger","responseParser","createExecutor","run","userPrompt","executor","input","result","response","error","resolveUserInput","invoke","debug","agentName","hasOutput","hasUserPrompt","outputType","output","Error","parseAgentResponse","handleResponse","model","dynamicTools","systemPromptText","systemTemplate","humanTemplate","prompt","agent","getModel","tools","map","tool","getDynamicTool","generate","fromTemplate","fromMessages","llm","fromAgentAndTools","extractActionInput","JSON","stringify","String","codeBlockMatch","match","content","trim","parsed","parse","action","action_input","includes","actionInputMatch","info","processedOutput","rawOutput"],"mappings":"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"}
+{"version":3,"sources":["../../../src/adapters/agents/chat-agent.adapter.ts"],"sourcesContent":["import { type LoggerPort } from '@jterrazz/logger';\nimport { ChatPromptTemplate } from '@langchain/core/prompts';\nimport { AgentExecutor, createStructuredChatAgent } from 'langchain/agents';\nimport { type z } from 'zod/v4';\n\nimport { type AgentPort } from '../../ports/agent.port.js';\nimport type { ModelPort } from '../../ports/model.port.js';\nimport type { PromptPort } from '../../ports/prompt.port.js';\nimport type { ToolPort } from '../../ports/tool.port.js';\n\nimport { AIResponseParser } from '../utils/ai-response-parser.js';\n\nimport type { SystemPromptAdapter } from '../prompts/system-prompt.adapter.js';\n\nexport interface ChatAgentOptions<T = unknown> {\n    logger?: LoggerPort;\n    model: ModelPort;\n    schema?: z.ZodSchema<T>;\n    systemPrompt: SystemPromptAdapter;\n    tools: ToolPort[];\n    verbose?: boolean;\n}\n\nconst SYSTEM_PROMPT_TEMPLATE = `\n<OBJECTIVE>\n{mission_prompt}\n</OBJECTIVE>\n\n<OUTPUT_FORMAT>\nCRITICAL: The format instructions in this section are the ONLY valid way to structure your response. Any formatting guidelines within the <OBJECTIVE> section (like message templates) apply ONLY to the content that goes inside the \"RESPOND: \" part of your final answer.\n\nYou have two ways to respond:\n\n1.  **Call a tool** to gather information. For this, you MUST output a JSON blob with the tool's name and its input.\n    *Valid tool names are: {tool_names}*\n    \\`\\`\\`json\n    {{\n      \"action\": \"tool_name_to_use\",\n      \"action_input\": \"the input for the tool, or an empty object {{}} if no input is needed\"\n    }}\n    \\`\\`\\`\n\n2.  **Provide the Final Answer** once you have enough information. For this, you MUST output a JSON blob with the \"Final Answer\" action. The input must start with \"RESPOND: \" or \"SILENT: \".\n    - To send a message:\n      \\`\\`\\`json\n      {{\n        \"action\": \"Final Answer\",\n        \"action_input\": \"RESPOND: <your response message>\"\n      }}\n      \\`\\`\\`\n    - To stay silent:\n      \\`\\`\\`json\n      {{\n        \"action\": \"Final Answer\",\n        \"action_input\": \"SILENT: <your reason for staying silent>\"\n      }}\n      \\`\\`\\`\n</OUTPUT_FORMAT>\n\n<EXECUTION_CONTEXT>\nThis is internal data for your reference.\n\n<TOOLS>\n{tools}\n</TOOLS>\n\n<WORKING_MEMORY>\nThis is your internal thought process and previous tool usage.\n{agent_scratchpad}\n</WORKING_MEMORY>\n</EXECUTION_CONTEXT>\n`;\n\n/**\n * An advanced agent that uses tools and a structured prompt to engage in conversational chat.\n * It can decide whether to respond or remain silent and supports schema-validated responses.\n */\nexport class ChatAgentAdapter<T = unknown> implements AgentPort {\n    constructor(\n        public readonly name: string,\n        private readonly options: ChatAgentOptions<T>,\n    ) {}\n\n    async run(userPrompt?: PromptPort): Promise<null | string> {\n        this.options.logger?.debug(`[${this.name}] Starting chat execution.`);\n\n        try {\n            const executor = await this.createExecutor();\n            const userInput = this.resolveUserInput(userPrompt);\n\n            const result = await executor.invoke({ input: userInput });\n\n            this.options.logger?.debug(`[${this.name}] Agent execution completed.`, {\n                hasOutput: 'output' in result,\n            });\n\n            if (!result || typeof result.output !== 'string') {\n                throw new Error('Agent returned an invalid result structure.');\n            }\n\n            const agentResponse = this.parseAgentOutput(result.output);\n\n            if (!agentResponse.shouldRespond) {\n                this.options.logger?.info(`[${this.name}] Agent chose to remain silent.`, {\n                    reason: agentResponse.reason,\n                });\n                return null;\n            }\n\n            const message = agentResponse.message ?? '';\n\n            if (this.options.schema) {\n                this.validateResponseContent(message, this.options.schema);\n                this.options.logger?.info(\n                    `[${this.name}] Execution finished; response content validated.`,\n                );\n            } else {\n                this.options.logger?.info(`[${this.name}] Execution finished.`);\n            }\n\n            return message;\n        } catch (error) {\n            this.options.logger?.error(`[${this.name}] Chat execution failed.`, {\n                error: error instanceof Error ? error.message : 'Unknown error',\n            });\n            return null;\n        }\n    }\n\n    private async createExecutor(): Promise<AgentExecutor> {\n        const model = this.options.model.getModel();\n        const tools = this.options.tools.map((tool) => tool.getDynamicTool());\n\n        const prompt = ChatPromptTemplate.fromMessages([\n            [\n                'system',\n                SYSTEM_PROMPT_TEMPLATE.replace(\n                    '{mission_prompt}',\n                    this.options.systemPrompt.generate(),\n                ),\n            ],\n            ['human', '{input}'],\n        ]);\n\n        const agent = await createStructuredChatAgent({\n            llm: model,\n            prompt,\n            tools,\n        });\n\n        return AgentExecutor.fromAgentAndTools({\n            agent,\n            tools,\n            verbose: this.options.verbose,\n        });\n    }\n\n    private parseAgentOutput(output: string): {\n        message?: string;\n        reason?: string;\n        shouldRespond: boolean;\n    } {\n        const text = output.trim();\n\n        const respondMatch = text.match(/^RESPOND:\\s*([\\s\\S]+)$/i);\n        if (respondMatch) {\n            return { message: respondMatch[1].trim(), shouldRespond: true };\n        }\n\n        const silentMatch = text.match(/^SILENT:\\s*([\\s\\S]+)$/i);\n        if (silentMatch) {\n            return { reason: silentMatch[1].trim(), shouldRespond: false };\n        }\n\n        this.options.logger?.warn(\n            `[${this.name}] Agent output was missing 'RESPOND:' or 'SILENT:' prefix. Treating as a direct response.`,\n            { rawOutput: output },\n        );\n\n        return { message: text, shouldRespond: true };\n    }\n\n    private resolveUserInput(userPrompt?: PromptPort): string {\n        if (userPrompt) {\n            return userPrompt.generate();\n        }\n        return 'Proceed with your instructions.';\n    }\n\n    private validateResponseContent<TResponse>(\n        content: string,\n        schema: z.ZodSchema<TResponse>,\n    ): void {\n        try {\n            new AIResponseParser(schema).parse(content);\n        } catch (error) {\n            this.options.logger?.error(\n                `[${this.name}] Failed to validate response content against schema.`,\n                {\n                    error: error instanceof Error ? error.message : 'Unknown error',\n                    rawContent: content,\n                },\n            );\n            throw new Error('Invalid response content from model.');\n        }\n    }\n}\n"],"names":["ChatPromptTemplate","AgentExecutor","createStructuredChatAgent","AIResponseParser","SYSTEM_PROMPT_TEMPLATE","ChatAgentAdapter","name","options","run","userPrompt","executor","userInput","result","agentResponse","message","error","logger","debug","createExecutor","resolveUserInput","invoke","input","hasOutput","output","Error","parseAgentOutput","shouldRespond","info","reason","schema","validateResponseContent","model","tools","prompt","agent","getModel","map","tool","getDynamicTool","fromMessages","replace","systemPrompt","generate","llm","fromAgentAndTools","verbose","text","trim","respondMatch","match","silentMatch","warn","rawOutput","content","parse","rawContent"],"mappings":"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"}

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

@@ -0,0 +1,26 @@
+import { type LoggerPort } from '@jterrazz/logger';
+import { type z } from 'zod/v4';
+import { type AgentPort } from '../../ports/agent.port.js';
+import type { ModelPort } from '../../ports/model.port.js';
+import type { PromptPort } from '../../ports/prompt.port.js';
+import type { SystemPromptAdapter } from '../prompts/system-prompt.adapter.js';
+export interface QueryAgentOptions<T = string> {
+    logger?: LoggerPort;
+    model: ModelPort;
+    schema?: z.ZodSchema<T>;
+    systemPrompt: SystemPromptAdapter;
+    verbose?: boolean;
+}
+/**
+ * A simple agent for direct, one-shot interactions with a model.
+ * It supports optional response parsing against a Zod schema but does not use tools.
+ */
+export declare class QueryAgentAdapter<T = string> implements AgentPort {
+    readonly name: string;
+    private readonly options;
+    constructor(name: string, options: QueryAgentOptions<T>);
+    run(userPrompt?: PromptPort): Promise<null | string>;
+    private invokeModel;
+    private parseResponse;
+    private resolveUserInput;
+}