@jterrazz/intelligence 2.0.0 → 3.0.1

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapters/agents/chat-agent.adapter.ts"],"sourcesContent":["import { type LoggerPort } from '@jterrazz/logger';\nimport { generateText } from 'ai';\nimport { 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';\n\nimport { StructuredResponseParser } from '../utils/structured-response-parser.js';\n\nimport type { SystemPrompt } from '../prompts/system-prompt.adapter.js';\n\nexport interface ChatAgentOptions<TOutput = string> {\n    logger?: LoggerPort;\n    model: ModelPort;\n    schema?: z.ZodSchema<TOutput>;\n    systemPrompt: SystemPrompt;\n    verbose?: boolean;\n}\n\n/**\n * A conversational agent for direct, one-shot interactions with a model.\n * It supports optional response parsing against a Zod schema but does not use tools.\n * @template TOutput - The TypeScript type of the output\n */\nexport class ChatAgent<TOutput = string> implements AgentPort<PromptPort, TOutput> {\n    constructor(\n        public readonly name: string,\n        private readonly options: ChatAgentOptions<TOutput>,\n    ) {}\n\n    async run(input?: PromptPort): Promise<null | TOutput> {\n        this.options.logger?.debug('Starting query execution', { agent: this.name });\n\n        try {\n            const content = await this.invokeModel(input);\n\n            if (this.options.schema) {\n                const parsedResponse = this.parseResponse(content, this.options.schema);\n\n                this.options.logger?.debug('Execution finished and response parsed', {\n                    agent: this.name,\n                });\n\n                return parsedResponse;\n            } else {\n                this.options.logger?.debug('Execution finished', { agent: this.name });\n\n                return content as TOutput;\n            }\n        } catch (error) {\n            this.options.logger?.error('Execution failed', {\n                agent: this.name,\n                error: error instanceof Error ? error.message : 'Unknown error',\n                errorStack: error instanceof Error ? error.stack : undefined,\n            });\n            return null;\n        }\n    }\n\n    private async invokeModel(input?: PromptPort): Promise<string> {\n        const userInput = this.resolveUserInput(input);\n        let systemMessage = this.options.systemPrompt.generate();\n\n        if (this.options.schema) {\n            const jsonSchema = z.toJSONSchema(this.options.schema);\n            const isPrimitiveType = ['boolean', 'integer', 'number', 'string'].includes(\n                jsonSchema.type as string,\n            );\n\n            if (isPrimitiveType) {\n                systemMessage += `\\n\\n<OUTPUT_FORMAT>\nYou must respond with a ${jsonSchema.type} value that matches this schema:\n\n\\`\\`\\`json\n${JSON.stringify(jsonSchema, null, 2)}\n\\`\\`\\`\n\nYour response should be only the ${jsonSchema.type} value, without any JSON wrapping or additional text.\n</OUTPUT_FORMAT>`;\n            } else {\n                systemMessage += `\\n\\n<OUTPUT_FORMAT>\nYou must respond with valid JSON that matches this JSON schema description:\n\n\\`\\`\\`json\n${JSON.stringify(jsonSchema, null, 2)}\n\\`\\`\\`\n\nYour response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.\n</OUTPUT_FORMAT>`;\n            }\n        }\n\n        const messages = [\n            { content: systemMessage, role: 'system' as const },\n            { content: userInput, role: 'user' as const },\n        ];\n\n        this.options.logger?.debug('Invoking model...', {\n            agent: this.name,\n            hasSchema: !!this.options.schema,\n        });\n\n        if (this.options.verbose) {\n            this.options.logger?.debug('Sending messages to model...', {\n                agent: this.name,\n                messages,\n            });\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const generateConfig: any = {\n            messages,\n            model: this.options.model.getVercelModel(),\n        };\n\n        // Prepare structured outputs configuration for better schema validation when schema is provided\n        // NOTE: OpenRouter supports structured outputs, but @openrouter/ai-sdk-provider (v0.7.3)\n        // doesn't pass through responseFormat parameter yet. Currently relies on prompt-based instructions.\n        // Once provider support is added, this will provide stronger guarantees than prompts alone.\n        // See: https://openrouter.ai/docs/features/structured-outputs\n        if (this.options.schema) {\n            const jsonSchema = z.toJSONSchema(this.options.schema);\n            generateConfig.responseFormat = {\n                json_schema: {\n                    name: 'response',\n                    schema: jsonSchema,\n                    strict: true,\n                },\n                type: 'json_schema',\n            };\n        }\n\n        const { text } = await generateText(generateConfig);\n\n        return text;\n    }\n\n    private parseResponse<TResponse>(content: string, schema: z.ZodSchema<TResponse>): TResponse {\n        try {\n            return new StructuredResponseParser(schema).parse(content);\n        } catch (error) {\n            this.options.logger?.error('Failed to parse model response.', {\n                agent: this.name,\n                error: error instanceof Error ? error.message : 'Unknown error',\n                rawContent: content,\n            });\n            throw new Error('Invalid response format from model.');\n        }\n    }\n\n    private resolveUserInput(input?: PromptPort): string {\n        if (input) {\n            return input.generate();\n        }\n        return 'Proceed with your instructions.';\n    }\n}\n"],"names":["generateText","z","StructuredResponseParser","ChatAgent","name","options","run","input","content","parsedResponse","error","logger","debug","agent","invokeModel","schema","parseResponse","Error","message","errorStack","stack","undefined","userInput","systemMessage","jsonSchema","isPrimitiveType","messages","generateConfig","text","resolveUserInput","systemPrompt","generate","toJSONSchema","includes","type","JSON","stringify","role","hasSchema","verbose","model","getVercelModel","responseFormat","json_schema","strict","parse","rawContent"],"mappings":"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"}

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

@@ -1,20 +0,0 @@
-import { type LoggerPort } from '@jterrazz/logger';
-import { type AgentPort } from '../../ports/agent.port.js';
-import type { PromptPort } from '../../ports/prompt.port.js';
-export interface ResilientAgentOptions {
-    logger?: LoggerPort;
-    retries?: number;
-}
-/**
- * A decorator agent that adds retry logic to an existing agent for resilient execution.
- * @template TInput - The TypeScript type of the input
- * @template TOutput - The TypeScript type of the output
- */
-export declare class ResilientAgent<TInput = PromptPort, TOutput = string> implements AgentPort<TInput, TOutput> {
-    private readonly agent;
-    readonly name: string;
-    private readonly logger?;
-    private readonly retries;
-    constructor(agent: AgentPort<TInput, TOutput>, options?: ResilientAgentOptions);
-    run(input?: TInput): Promise<null | TOutput>;
-}

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

@@ -1,263 +0,0 @@
-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 _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
-        };
-    }
-}
-/**
- * A decorator agent that adds retry logic to an existing agent for resilient execution.
- * @template TInput - The TypeScript type of the input
- * @template TOutput - The TypeScript type of the output
- */ export var ResilientAgent = /*#__PURE__*/ function() {
-    "use strict";
-    function ResilientAgent(agent) {
-        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-        _class_call_check(this, ResilientAgent);
-        _define_property(this, "agent", void 0);
-        _define_property(this, "name", void 0);
-        _define_property(this, "logger", void 0);
-        _define_property(this, "retries", void 0);
-        this.agent = agent;
-        var logger = options.logger, _options_retries = options.retries, retries = _options_retries === void 0 ? 1 : _options_retries;
-        this.name = "Resilient(".concat(agent.name, ")");
-        this.logger = logger;
-        this.retries = retries;
-    }
-    _create_class(ResilientAgent, [
-        {
-            key: "run",
-            value: function run(input) {
-                return _async_to_generator(function() {
-                    var _this_logger, maxAttempts, attempt, _this_logger1, _this_logger2, result, _this_logger3, error, _this_logger4;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                maxAttempts = this.retries + 1;
-                                attempt = 1;
-                                _state.label = 1;
-                            case 1:
-                                if (!(attempt <= maxAttempts)) return [
-                                    3,
-                                    6
-                                ];
-                                _state.label = 2;
-                            case 2:
-                                _state.trys.push([
-                                    2,
-                                    4,
-                                    ,
-                                    5
-                                ]);
-                                (_this_logger1 = this.logger) === null || _this_logger1 === void 0 ? void 0 : _this_logger1.debug("Attempt ".concat(attempt, " of ").concat(maxAttempts), {
-                                    agent: this.name
-                                });
-                                return [
-                                    4,
-                                    this.agent.run(input)
-                                ];
-                            case 3:
-                                result = _state.sent();
-                                if (result !== null) {
-                                    ;
-                                    (_this_logger3 = this.logger) === null || _this_logger3 === void 0 ? void 0 : _this_logger3.debug("Attempt ".concat(attempt, " of ").concat(maxAttempts, " succeeded"), {
-                                        agent: this.name
-                                    });
-                                    return [
-                                        2,
-                                        result
-                                    ];
-                                }
-                                (_this_logger2 = this.logger) === null || _this_logger2 === void 0 ? void 0 : _this_logger2.debug("Attempt ".concat(attempt, " of ").concat(maxAttempts, " failed: agent returned null"), {
-                                    agent: this.name
-                                });
-                                return [
-                                    3,
-                                    5
-                                ];
-                            case 4:
-                                error = _state.sent();
-                                (_this_logger4 = this.logger) === null || _this_logger4 === void 0 ? void 0 : _this_logger4.debug("Attempt ".concat(attempt, " of ").concat(maxAttempts, " failed with an error"), {
-                                    agent: this.name,
-                                    error: _instanceof(error, Error) ? error.message : 'Unknown error'
-                                });
-                                return [
-                                    3,
-                                    5
-                                ];
-                            case 5:
-                                attempt++;
-                                return [
-                                    3,
-                                    1
-                                ];
-                            case 6:
-                                (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.error("All ".concat(maxAttempts, " attempts failed"), {
-                                    agent: this.name
-                                });
-                                return [
-                                    2,
-                                    null
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        }
-    ]);
-    return ResilientAgent;
-}();
-
-//# sourceMappingURL=resilient-agent.adapter.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapters/agents/resilient-agent.adapter.ts"],"sourcesContent":["import { type LoggerPort } from '@jterrazz/logger';\n\nimport { type AgentPort } from '../../ports/agent.port.js';\nimport type { PromptPort } from '../../ports/prompt.port.js';\n\nexport interface ResilientAgentOptions {\n    logger?: LoggerPort;\n    retries?: number;\n}\n\n/**\n * A decorator agent that adds retry logic to an existing agent for resilient execution.\n * @template TInput - The TypeScript type of the input\n * @template TOutput - The TypeScript type of the output\n */\nexport class ResilientAgent<TInput = PromptPort, TOutput = string>\n    implements AgentPort<TInput, TOutput>\n{\n    public readonly name: string;\n    private readonly logger?: LoggerPort;\n    private readonly retries: number;\n\n    constructor(\n        private readonly agent: AgentPort<TInput, TOutput>,\n        options: ResilientAgentOptions = {},\n    ) {\n        const { logger, retries = 1 } = options;\n        this.name = `Resilient(${agent.name})`;\n        this.logger = logger;\n        this.retries = retries;\n    }\n\n    async run(input?: TInput): Promise<null | TOutput> {\n        const maxAttempts = this.retries + 1;\n\n        for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n            try {\n                this.logger?.debug(`Attempt ${attempt} of ${maxAttempts}`, { agent: this.name });\n                const result = await this.agent.run(input);\n\n                if (result !== null) {\n                    this.logger?.debug(`Attempt ${attempt} of ${maxAttempts} succeeded`, {\n                        agent: this.name,\n                    });\n                    return result;\n                }\n\n                this.logger?.debug(\n                    `Attempt ${attempt} of ${maxAttempts} failed: agent returned null`,\n                    { agent: this.name },\n                );\n            } catch (error) {\n                this.logger?.debug(`Attempt ${attempt} of ${maxAttempts} failed with an error`, {\n                    agent: this.name,\n                    error: error instanceof Error ? error.message : 'Unknown error',\n                });\n            }\n        }\n\n        this.logger?.error(`All ${maxAttempts} attempts failed`, { agent: this.name });\n        return null;\n    }\n}\n"],"names":["ResilientAgent","agent","options","name","logger","retries","run","input","maxAttempts","attempt","result","error","debug","Error","message"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA;;;;CAIC,GACD,OAAO,IAAA,AAAMA,+BAAN;;aAAMA,eAQL,AAAiBC,KAAiC;YAClDC,UAAAA,iEAAiC,CAAC;gCAT7BF;;QAGT,uBAAgBG,QAAhB,KAAA;QACA,uBAAiBC,UAAjB,KAAA;QACA,uBAAiBC,WAAjB,KAAA;aAGqBJ,QAAAA;QAGjB,IAAQG,SAAwBF,QAAxBE,2BAAwBF,QAAhBG,SAAAA,wCAAU;QAC1B,IAAI,CAACF,IAAI,GAAG,AAAC,aAAuB,OAAXF,MAAME,IAAI,EAAC;QACpC,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACC,OAAO,GAAGA;;kBAdVL;;YAiBHM,KAAAA;mBAAN,SAAMA,IAAIC,KAAc;;wBA2BpB,cA1BMC,aAEGC,SAED,eAUA,eATMC,QAGF,eAUCC,OACL;;;;gCAnBFH,cAAc,IAAI,CAACH,OAAO,GAAG;gCAE1BI,UAAU;;;qCAAGA,CAAAA,WAAWD,WAAU;;;;;;;;;;;;iCAEnC,gBAAA,IAAI,CAACJ,MAAM,cAAX,oCAAA,cAAaQ,KAAK,CAAC,AAAC,WAAwBJ,OAAdC,SAAQ,QAAkB,OAAZD,cAAe;oCAAEP,OAAO,IAAI,CAACE,IAAI;gCAAC;gCAC/D;;oCAAM,IAAI,CAACF,KAAK,CAACK,GAAG,CAACC;;;gCAA9BG,SAAS;gCAEf,IAAIA,WAAW,MAAM;;qCACjB,gBAAA,IAAI,CAACN,MAAM,cAAX,oCAAA,cAAaQ,KAAK,CAAC,AAAC,WAAwBJ,OAAdC,SAAQ,QAAkB,OAAZD,aAAY,eAAa;wCACjEP,OAAO,IAAI,CAACE,IAAI;oCACpB;oCACA;;wCAAOO;;gCACX;iCAEA,gBAAA,IAAI,CAACN,MAAM,cAAX,oCAAA,cAAaQ,KAAK,CACd,AAAC,WAAwBJ,OAAdC,SAAQ,QAAkB,OAAZD,aAAY,iCACrC;oCAAEP,OAAO,IAAI,CAACE,IAAI;gCAAC;;;;;;gCAElBQ;iCACL,gBAAA,IAAI,CAACP,MAAM,cAAX,oCAAA,cAAaQ,KAAK,CAAC,AAAC,WAAwBJ,OAAdC,SAAQ,QAAkB,OAAZD,aAAY,0BAAwB;oCAC5EP,OAAO,IAAI,CAACE,IAAI;oCAChBQ,OAAOA,AAAK,YAALA,OAAiBE,SAAQF,MAAMG,OAAO,GAAG;gCACpD;;;;;;gCApBsCL;;;;;;iCAwB9C,eAAA,IAAI,CAACL,MAAM,cAAX,mCAAA,aAAaO,KAAK,CAAC,AAAC,OAAkB,OAAZH,aAAY,qBAAmB;oCAAEP,OAAO,IAAI,CAACE,IAAI;gCAAC;gCAC5E;;oCAAO;;;;gBACX;;;;WA9CSH;IA+CZ"}

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

@@ -1,30 +0,0 @@
-import { type LoggerPort } from '@jterrazz/logger';
-import { 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 { SystemPrompt } from '../prompts/system-prompt.adapter.js';
-export interface ToolAgentOptions<TOutput = string> {
-    logger?: LoggerPort;
-    model: ModelPort;
-    schema?: z.ZodSchema<TOutput>;
-    systemPrompt: SystemPrompt;
-    tools: ToolPort[];
-    verbose?: boolean;
-}
-/**
- * A tool-enabled agent that uses tools and a structured prompt to accomplish tasks.
- * It can decide whether to respond or remain silent and supports schema-validated responses.
- * @template TOutput - The TypeScript type of the output
- */
-export declare class ToolAgent<TOutput = string> implements AgentPort<PromptPort, TOutput> {
-    readonly name: string;
-    private readonly options;
-    constructor(name: string, options: ToolAgentOptions<TOutput>);
-    run(input?: PromptPort): Promise<null | TOutput>;
-    private createExecutor;
-    private parseAgentOutput;
-    private resolveUserInput;
-    private validateResponseContent;
-}