@jterrazz/intelligence 1.6.1 → 3.0.0

package/dist/index.d.ts

@@ -1,12 +1,5 @@
-export { AutonomousAgentAdapter, type AutonomousAgentOptions, } from './adapters/agents/autonomous-agent.adapter.js';
-export { BasicAgentAdapter, type BasicAgentOptions, } from './adapters/agents/basic-agent.adapter.js';
-export { OpenRouterModelAdapter as OpenRouterAdapter } from './adapters/models/openrouter-model.adapter.js';
-export { PROMPT_LIBRARY } from './adapters/prompts/library/index.js';
-export { SystemPromptAdapter } from './adapters/prompts/system-prompt.adapter.js';
-export { UserPromptAdapter } from './adapters/prompts/user-prompt.adapter.js';
-export { SafeToolAdapter } from './adapters/tools/safe-tool.adapter.js';
-export { AIResponseParser } from './adapters/utils/ai-response-parser.js';
-export * from './ports/agent.port.js';
-export * from './ports/model.port.js';
-export * from './ports/prompt.port.js';
-export * from './ports/tool.port.js';
+export { createLoggingMiddleware, type LoggingMiddlewareOptions, } from './middleware/logging.middleware.js';
+export { createSchemaPrompt } from './parsing/create-schema-prompt.js';
+export { parseObject, ParseObjectError } from './parsing/parse-object.js';
+export { parseText, type ParseTextOptions } from './parsing/parse-text.js';
+export { createOpenRouterProvider, type ModelOptions, type OpenRouterConfig, type OpenRouterMetadata, type OpenRouterProvider, } from './providers/openrouter.provider.js';

package/dist/index.js

@@ -1,14 +1,7 @@
-export { AutonomousAgentAdapter } from './adapters/agents/autonomous-agent.adapter.js';
-export { BasicAgentAdapter } from './adapters/agents/basic-agent.adapter.js';
-export { OpenRouterModelAdapter as OpenRouterAdapter } from './adapters/models/openrouter-model.adapter.js';
-export { PROMPT_LIBRARY } from './adapters/prompts/library/index.js';
-export { SystemPromptAdapter } from './adapters/prompts/system-prompt.adapter.js';
-export { UserPromptAdapter } from './adapters/prompts/user-prompt.adapter.js';
-export { SafeToolAdapter } from './adapters/tools/safe-tool.adapter.js';
-export { AIResponseParser } from './adapters/utils/ai-response-parser.js';
-export * from './ports/agent.port.js';
-export * from './ports/model.port.js';
-export * from './ports/prompt.port.js';
-export * from './ports/tool.port.js';
+export { createLoggingMiddleware } from './middleware/logging.middleware.js';
+export { createSchemaPrompt } from './parsing/create-schema-prompt.js';
+export { parseObject, ParseObjectError } from './parsing/parse-object.js';
+export { parseText } from './parsing/parse-text.js';
+export { createOpenRouterProvider } from './providers/openrouter.provider.js';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n    AutonomousAgentAdapter,\n    type AutonomousAgentOptions,\n} from './adapters/agents/autonomous-agent.adapter.js';\nexport {\n    BasicAgentAdapter,\n    type BasicAgentOptions,\n} from './adapters/agents/basic-agent.adapter.js';\nexport { OpenRouterModelAdapter as OpenRouterAdapter } from './adapters/models/openrouter-model.adapter.js';\nexport { PROMPT_LIBRARY } from './adapters/prompts/library/index.js';\nexport { SystemPromptAdapter } from './adapters/prompts/system-prompt.adapter.js';\nexport { UserPromptAdapter } from './adapters/prompts/user-prompt.adapter.js';\nexport { SafeToolAdapter } from './adapters/tools/safe-tool.adapter.js';\nexport { AIResponseParser } from './adapters/utils/ai-response-parser.js';\n\nexport * from './ports/agent.port.js';\nexport * from './ports/model.port.js';\nexport * from './ports/prompt.port.js';\nexport * from './ports/tool.port.js';\n"],"names":["AutonomousAgentAdapter","BasicAgentAdapter","OpenRouterModelAdapter","OpenRouterAdapter","PROMPT_LIBRARY","SystemPromptAdapter","UserPromptAdapter","SafeToolAdapter","AIResponseParser"],"mappings":"AAAA,SACIA,sBAAsB,QAEnB,gDAAgD;AACvD,SACIC,iBAAiB,QAEd,2CAA2C;AAClD,SAASC,0BAA0BC,iBAAiB,QAAQ,gDAAgD;AAC5G,SAASC,cAAc,QAAQ,sCAAsC;AACrE,SAASC,mBAAmB,QAAQ,8CAA8C;AAClF,SAASC,iBAAiB,QAAQ,4CAA4C;AAC9E,SAASC,eAAe,QAAQ,wCAAwC;AACxE,SAASC,gBAAgB,QAAQ,yCAAyC;AAE1E,cAAc,wBAAwB;AACtC,cAAc,wBAAwB;AACtC,cAAc,yBAAyB;AACvC,cAAc,uBAAuB"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n    createLoggingMiddleware,\n    type LoggingMiddlewareOptions,\n} from './middleware/logging.middleware.js';\nexport { createSchemaPrompt } from './parsing/create-schema-prompt.js';\nexport { parseObject, ParseObjectError } from './parsing/parse-object.js';\nexport { parseText, type ParseTextOptions } from './parsing/parse-text.js';\nexport {\n    createOpenRouterProvider,\n    type ModelOptions,\n    type OpenRouterConfig,\n    type OpenRouterMetadata,\n    type OpenRouterProvider,\n} from './providers/openrouter.provider.js';\n"],"names":["createLoggingMiddleware","createSchemaPrompt","parseObject","ParseObjectError","parseText","createOpenRouterProvider"],"mappings":"AAAA,SACIA,uBAAuB,QAEpB,qCAAqC;AAC5C,SAASC,kBAAkB,QAAQ,oCAAoC;AACvE,SAASC,WAAW,EAAEC,gBAAgB,QAAQ,4BAA4B;AAC1E,SAASC,SAAS,QAA+B,0BAA0B;AAC3E,SACIC,wBAAwB,QAKrB,qCAAqC"}

package/dist/middleware/__tests__/logging.middleware.test.js

@@ -0,0 +1,390 @@
+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 _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 { describe, expect, it, vi } from 'vitest';
+import { createLoggingMiddleware } from '../logging.middleware.js';
+function createMockLogger() {
+    var logger = {
+        child: vi.fn(function() {
+            return logger;
+        }),
+        debug: vi.fn(),
+        error: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn()
+    };
+    return logger;
+}
+function createMockGenerateResult() {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: 'Hello world'
+            }
+        ],
+        finishReason: 'stop',
+        usage: {
+            inputTokens: 10,
+            outputTokens: 20,
+            totalTokens: 30
+        },
+        warnings: []
+    };
+}
+function createMockStreamResult() {
+    return {
+        stream: new ReadableStream(),
+        warnings: []
+    };
+}
+describe('createLoggingMiddleware', function() {
+    describe('wrapGenerate', function() {
+        it('logs request start and completion on success', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapGenerate, logger, middleware, mockResult, doGenerate, result;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger
+                            });
+                            mockResult = createMockGenerateResult();
+                            doGenerate = vi.fn().mockResolvedValue(mockResult);
+                            return [
+                                4,
+                                (_middleware_wrapGenerate = middleware.wrapGenerate) === null || _middleware_wrapGenerate === void 0 ? void 0 : _middleware_wrapGenerate.call(middleware, {
+                                    doGenerate: doGenerate,
+                                    doStream: vi.fn(),
+                                    params: {},
+                                    model: {}
+                                })
+                            ];
+                        case 1:
+                            result = _state.sent();
+                            expect(logger.debug).toHaveBeenCalledTimes(2);
+                            expect(logger.debug).toHaveBeenNthCalledWith(1, 'Model request started', {});
+                            expect(logger.debug).toHaveBeenNthCalledWith(2, 'Model request completed', expect.objectContaining({
+                                durationMs: expect.any(Number),
+                                finishReason: 'stop',
+                                usage: mockResult.usage
+                            }));
+                            expect(result).toBe(mockResult);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('logs error on failure', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapGenerate, logger, middleware, error, doGenerate;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger
+                            });
+                            error = new Error('API error');
+                            doGenerate = vi.fn().mockRejectedValue(error);
+                            return [
+                                4,
+                                expect((_middleware_wrapGenerate = middleware.wrapGenerate) === null || _middleware_wrapGenerate === void 0 ? void 0 : _middleware_wrapGenerate.call(middleware, {
+                                    doGenerate: doGenerate,
+                                    doStream: vi.fn(),
+                                    params: {},
+                                    model: {}
+                                })).rejects.toThrow('API error')
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(logger.debug).toHaveBeenCalledWith('Model request started', {});
+                            expect(logger.error).toHaveBeenCalledWith('Model request failed', expect.objectContaining({
+                                durationMs: expect.any(Number),
+                                error: 'API error'
+                            }));
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('includes params and content when verbose is true', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapGenerate, logger, middleware, mockResult, mockParams, doGenerate;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger,
+                                verbose: true
+                            });
+                            mockResult = createMockGenerateResult();
+                            mockParams = {
+                                prompt: 'Hello'
+                            };
+                            doGenerate = vi.fn().mockResolvedValue(mockResult);
+                            return [
+                                4,
+                                (_middleware_wrapGenerate = middleware.wrapGenerate) === null || _middleware_wrapGenerate === void 0 ? void 0 : _middleware_wrapGenerate.call(middleware, {
+                                    doGenerate: doGenerate,
+                                    doStream: vi.fn(),
+                                    params: mockParams,
+                                    model: {}
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(logger.debug).toHaveBeenNthCalledWith(1, 'Model request started', expect.objectContaining({
+                                params: mockParams
+                            }));
+                            expect(logger.debug).toHaveBeenNthCalledWith(2, 'Model request completed', expect.objectContaining({
+                                content: mockResult.content
+                            }));
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('wrapStream', function() {
+        it('logs stream start on success', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapStream, logger, middleware, mockResult, doStream, result;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger
+                            });
+                            mockResult = createMockStreamResult();
+                            doStream = vi.fn().mockResolvedValue(mockResult);
+                            return [
+                                4,
+                                (_middleware_wrapStream = middleware.wrapStream) === null || _middleware_wrapStream === void 0 ? void 0 : _middleware_wrapStream.call(middleware, {
+                                    doGenerate: vi.fn(),
+                                    doStream: doStream,
+                                    params: {},
+                                    model: {}
+                                })
+                            ];
+                        case 1:
+                            result = _state.sent();
+                            expect(logger.debug).toHaveBeenCalledWith('Model stream started', {});
+                            expect(result === null || result === void 0 ? void 0 : result.stream).toBe(mockResult.stream);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('logs error on stream failure', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapStream, logger, middleware, error, doStream;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger
+                            });
+                            error = new Error('Stream error');
+                            doStream = vi.fn().mockRejectedValue(error);
+                            return [
+                                4,
+                                expect((_middleware_wrapStream = middleware.wrapStream) === null || _middleware_wrapStream === void 0 ? void 0 : _middleware_wrapStream.call(middleware, {
+                                    doGenerate: vi.fn(),
+                                    doStream: doStream,
+                                    params: {},
+                                    model: {}
+                                })).rejects.toThrow('Stream error')
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(logger.error).toHaveBeenCalledWith('Model stream failed', expect.objectContaining({
+                                durationMs: expect.any(Number),
+                                error: 'Stream error'
+                            }));
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('includes params when verbose is true', function() {
+            return _async_to_generator(function() {
+                var _middleware_wrapStream, logger, middleware, mockResult, mockParams, doStream;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            logger = createMockLogger();
+                            middleware = createLoggingMiddleware({
+                                logger: logger,
+                                verbose: true
+                            });
+                            mockResult = createMockStreamResult();
+                            mockParams = {
+                                prompt: 'Hello'
+                            };
+                            doStream = vi.fn().mockResolvedValue(mockResult);
+                            return [
+                                4,
+                                (_middleware_wrapStream = middleware.wrapStream) === null || _middleware_wrapStream === void 0 ? void 0 : _middleware_wrapStream.call(middleware, {
+                                    doGenerate: vi.fn(),
+                                    doStream: doStream,
+                                    params: mockParams,
+                                    model: {}
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            expect(logger.debug).toHaveBeenCalledWith('Model stream started', expect.objectContaining({
+                                params: mockParams
+                            }));
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('middleware structure', function() {
+        it('returns middleware with v2 version', function() {
+            var logger = createMockLogger();
+            var middleware = createLoggingMiddleware({
+                logger: logger
+            });
+            expect(middleware.middlewareVersion).toBe('v2');
+        });
+    });
+});
+
+//# sourceMappingURL=logging.middleware.test.js.map

package/dist/middleware/__tests__/logging.middleware.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/__tests__/logging.middleware.test.ts"],"sourcesContent":["import { describe, expect, it, vi } from 'vitest';\n\nimport { createLoggingMiddleware } from '../logging.middleware.js';\n\nfunction createMockLogger() {\n    const logger = {\n        child: vi.fn(() => logger),\n        debug: vi.fn(),\n        error: vi.fn(),\n        info: vi.fn(),\n        warn: vi.fn(),\n    };\n    return logger;\n}\n\nfunction createMockGenerateResult() {\n    return {\n        content: [{ type: 'text' as const, text: 'Hello world' }],\n        finishReason: 'stop' as const,\n        usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },\n        warnings: [],\n    };\n}\n\nfunction createMockStreamResult() {\n    return {\n        stream: new ReadableStream(),\n        warnings: [],\n    };\n}\n\ndescribe('createLoggingMiddleware', () => {\n    describe('wrapGenerate', () => {\n        it('logs request start and completion on success', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger });\n            const mockResult = createMockGenerateResult();\n            const doGenerate = vi.fn().mockResolvedValue(mockResult);\n\n            const result = await middleware.wrapGenerate?.({\n                doGenerate,\n                doStream: vi.fn(),\n                params: {} as never,\n                model: {} as never,\n            });\n\n            expect(logger.debug).toHaveBeenCalledTimes(2);\n            expect(logger.debug).toHaveBeenNthCalledWith(1, 'Model request started', {});\n            expect(logger.debug).toHaveBeenNthCalledWith(\n                2,\n                'Model request completed',\n                expect.objectContaining({\n                    durationMs: expect.any(Number),\n                    finishReason: 'stop',\n                    usage: mockResult.usage,\n                }),\n            );\n            expect(result).toBe(mockResult);\n        });\n\n        it('logs error on failure', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger });\n            const error = new Error('API error');\n            const doGenerate = vi.fn().mockRejectedValue(error);\n\n            await expect(\n                middleware.wrapGenerate?.({\n                    doGenerate,\n                    doStream: vi.fn(),\n                    params: {} as never,\n                    model: {} as never,\n                }),\n            ).rejects.toThrow('API error');\n\n            expect(logger.debug).toHaveBeenCalledWith('Model request started', {});\n            expect(logger.error).toHaveBeenCalledWith(\n                'Model request failed',\n                expect.objectContaining({\n                    durationMs: expect.any(Number),\n                    error: 'API error',\n                }),\n            );\n        });\n\n        it('includes params and content when verbose is true', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger, verbose: true });\n            const mockResult = createMockGenerateResult();\n            const mockParams = { prompt: 'Hello' };\n            const doGenerate = vi.fn().mockResolvedValue(mockResult);\n\n            await middleware.wrapGenerate?.({\n                doGenerate,\n                doStream: vi.fn(),\n                params: mockParams as never,\n                model: {} as never,\n            });\n\n            expect(logger.debug).toHaveBeenNthCalledWith(\n                1,\n                'Model request started',\n                expect.objectContaining({ params: mockParams }),\n            );\n            expect(logger.debug).toHaveBeenNthCalledWith(\n                2,\n                'Model request completed',\n                expect.objectContaining({ content: mockResult.content }),\n            );\n        });\n    });\n\n    describe('wrapStream', () => {\n        it('logs stream start on success', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger });\n            const mockResult = createMockStreamResult();\n            const doStream = vi.fn().mockResolvedValue(mockResult);\n\n            const result = await middleware.wrapStream?.({\n                doGenerate: vi.fn(),\n                doStream,\n                params: {} as never,\n                model: {} as never,\n            });\n\n            expect(logger.debug).toHaveBeenCalledWith('Model stream started', {});\n            expect(result?.stream).toBe(mockResult.stream);\n        });\n\n        it('logs error on stream failure', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger });\n            const error = new Error('Stream error');\n            const doStream = vi.fn().mockRejectedValue(error);\n\n            await expect(\n                middleware.wrapStream?.({\n                    doGenerate: vi.fn(),\n                    doStream,\n                    params: {} as never,\n                    model: {} as never,\n                }),\n            ).rejects.toThrow('Stream error');\n\n            expect(logger.error).toHaveBeenCalledWith(\n                'Model stream failed',\n                expect.objectContaining({\n                    durationMs: expect.any(Number),\n                    error: 'Stream error',\n                }),\n            );\n        });\n\n        it('includes params when verbose is true', async () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger, verbose: true });\n            const mockResult = createMockStreamResult();\n            const mockParams = { prompt: 'Hello' };\n            const doStream = vi.fn().mockResolvedValue(mockResult);\n\n            await middleware.wrapStream?.({\n                doGenerate: vi.fn(),\n                doStream,\n                params: mockParams as never,\n                model: {} as never,\n            });\n\n            expect(logger.debug).toHaveBeenCalledWith(\n                'Model stream started',\n                expect.objectContaining({ params: mockParams }),\n            );\n        });\n    });\n\n    describe('middleware structure', () => {\n        it('returns middleware with v2 version', () => {\n            const logger = createMockLogger();\n            const middleware = createLoggingMiddleware({ logger });\n\n            expect(middleware.middlewareVersion).toBe('v2');\n        });\n    });\n});\n"],"names":["describe","expect","it","vi","createLoggingMiddleware","createMockLogger","logger","child","fn","debug","error","info","warn","createMockGenerateResult","content","type","text","finishReason","usage","inputTokens","outputTokens","totalTokens","warnings","createMockStreamResult","stream","ReadableStream","middleware","mockResult","doGenerate","result","mockResolvedValue","wrapGenerate","doStream","params","model","toHaveBeenCalledTimes","toHaveBeenNthCalledWith","objectContaining","durationMs","any","Number","toBe","Error","mockRejectedValue","rejects","toThrow","toHaveBeenCalledWith","mockParams","verbose","prompt","wrapStream","middlewareVersion"],"mappings":"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"}

package/dist/middleware/logging.middleware.d.ts

@@ -0,0 +1,21 @@
+import type { LoggerPort } from '@jterrazz/logger';
+import type { LanguageModelMiddleware } from 'ai';
+export interface LoggingMiddlewareOptions {
+    logger: LoggerPort;
+    /** Include request/response details in logs (default: false) */
+    verbose?: boolean;
+}
+/**
+ * Creates AI SDK middleware that logs model requests and responses.
+ *
+ * @example
+ * ```ts
+ * import { wrapLanguageModel } from 'ai';
+ *
+ * const model = wrapLanguageModel({
+ *   model: openrouter('anthropic/claude-sonnet-4-20250514'),
+ *   middleware: createLoggingMiddleware({ logger }),
+ * });
+ * ```
+ */
+export declare function createLoggingMiddleware(options: LoggingMiddlewareOptions): LanguageModelMiddleware;