task-o-matic-core 0.1.0

package/dist/test/task-loop-git.test.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const git_utils_1 = require("../lib/git-utils");
+describe("Task Loop Git Integration", () => {
+    const mockTaskTitle = "Test Task";
+    const mockExecutionMessage = "Executed task";
+    it("should extract commit info from existing commit", async () => {
+        const gitState = {
+            beforeHead: "abc",
+            afterHead: "def",
+            hasUncommittedChanges: false,
+        };
+        const mockExec = async (cmd) => {
+            if (cmd.includes("git show")) {
+                return {
+                    stdout: "feat: test commit\n\nBody\n src/file.ts | 10 +",
+                    stderr: "",
+                };
+            }
+            return { stdout: "", stderr: "" };
+        };
+        const result = await (0, git_utils_1.extractCommitInfo)("1", mockTaskTitle, mockExecutionMessage, gitState, mockExec);
+        assert_1.default.strictEqual(result.message, "feat: test commit");
+        assert_1.default.deepStrictEqual(result.files, ["src/file.ts"]);
+    });
+    it("should generate commit info from uncommitted changes", async () => {
+        const gitState = {
+            beforeHead: "abc",
+            afterHead: "abc",
+            hasUncommittedChanges: true,
+        };
+        const mockExec = async (cmd) => {
+            if (cmd.includes("git diff")) {
+                return { stdout: "diff content", stderr: "" };
+            }
+            if (cmd.includes("git status")) {
+                return { stdout: " M src/changed.ts", stderr: "" };
+            }
+            return { stdout: "", stderr: "" };
+        };
+        const mockAiOps = {
+            streamText: async () => JSON.stringify({ message: "fix: auto commit" }),
+        };
+        const result = await (0, git_utils_1.extractCommitInfo)("1", mockTaskTitle, mockExecutionMessage, gitState, mockExec, mockAiOps);
+        assert_1.default.strictEqual(result.message, "fix: auto commit");
+        assert_1.default.deepStrictEqual(result.files, ["src/changed.ts"]);
+    });
+    it("should return default info when no changes", async () => {
+        const gitState = {
+            beforeHead: "abc",
+            afterHead: "abc",
+            hasUncommittedChanges: false,
+        };
+        const result = await (0, git_utils_1.extractCommitInfo)("1", mockTaskTitle, mockExecutionMessage, gitState);
+        assert_1.default.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+        assert_1.default.deepStrictEqual(result.files, []);
+    });
+    it("should handle git command failures gracefully", async () => {
+        const gitState = {
+            beforeHead: "abc",
+            afterHead: "def",
+            hasUncommittedChanges: false,
+        };
+        const mockExec = async () => {
+            throw new Error("Git failed");
+        };
+        const result = await (0, git_utils_1.extractCommitInfo)("1", mockTaskTitle, mockExecutionMessage, gitState, mockExec);
+        assert_1.default.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+        assert_1.default.deepStrictEqual(result.files, []);
+    });
+    it("should handle invalid AI JSON response", async () => {
+        const gitState = {
+            beforeHead: "abc",
+            afterHead: "abc",
+            hasUncommittedChanges: true,
+        };
+        const mockExec = async (cmd) => {
+            if (cmd.includes("git diff"))
+                return { stdout: "diff", stderr: "" };
+            if (cmd.includes("git status"))
+                return { stdout: " M file.ts", stderr: "" };
+            return { stdout: "", stderr: "" };
+        };
+        const mockAiOps = {
+            streamText: async () => "Not JSON",
+        };
+        const result = await (0, git_utils_1.extractCommitInfo)("1", mockTaskTitle, mockExecutionMessage, gitState, mockExec, mockAiOps);
+        assert_1.default.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+        assert_1.default.deepStrictEqual(result.files, ["file.ts"]);
+    });
+});

package/dist/test/test-mock-setup.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Test Mock Setup - Provides mock instances for ai-service-factory
+ * Uses the injectTestInstances function to inject mocks
+ */
+import { MockStorage } from "./mocks/mock-storage";
+import { MockAIOperations } from "./mocks/mock-ai-operations";
+import { MockModelProvider } from "./mocks/mock-model-provider";
+import { MockContextBuilder } from "./mocks/mock-context-builder";
+export declare let mockStorage: MockStorage;
+export declare let mockAIOperations: MockAIOperations;
+export declare let mockModelProvider: MockModelProvider;
+export declare let mockContextBuilder: MockContextBuilder;
+/**
+ * Initialize fresh mock instances and inject them into the service factory
+ */
+export declare function resetMocks(): void;
+/**
+ * Get current mock instances for test assertions
+ */
+export declare function getMocks(): {
+    storage: MockStorage;
+    aiOperations: MockAIOperations;
+    modelProvider: MockModelProvider;
+    contextBuilder: MockContextBuilder;
+};
+//# sourceMappingURL=test-mock-setup.d.ts.map

package/dist/test/test-mock-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-mock-setup.d.ts","sourceRoot":"","sources":["../../src/test/test-mock-setup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAIlE,eAAO,IAAI,WAAW,EAAE,WAAW,CAAC;AACpC,eAAO,IAAI,gBAAgB,EAAE,gBAAgB,CAAC;AAC9C,eAAO,IAAI,iBAAiB,EAAE,iBAAiB,CAAC;AAChD,eAAO,IAAI,kBAAkB,EAAE,kBAAkB,CAAC;AAElD;;GAEG;AACH,wBAAgB,UAAU,SAazB;AAED;;GAEG;AACH,wBAAgB,QAAQ;;;;;EAOvB"}

package/dist/test/test-mock-setup.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Test Mock Setup - Provides mock instances for ai-service-factory
+ * Uses the injectTestInstances function to inject mocks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockContextBuilder = exports.mockModelProvider = exports.mockAIOperations = exports.mockStorage = void 0;
+exports.resetMocks = resetMocks;
+exports.getMocks = getMocks;
+const mock_storage_1 = require("./mocks/mock-storage");
+const mock_ai_operations_1 = require("./mocks/mock-ai-operations");
+const mock_model_provider_1 = require("./mocks/mock-model-provider");
+const mock_context_builder_1 = require("./mocks/mock-context-builder");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+/**
+ * Initialize fresh mock instances and inject them into the service factory
+ */
+function resetMocks() {
+    exports.mockStorage = new mock_storage_1.MockStorage();
+    exports.mockAIOperations = new mock_ai_operations_1.MockAIOperations(); // Cast to any to avoid type issues
+    exports.mockModelProvider = new mock_model_provider_1.MockModelProvider();
+    exports.mockContextBuilder = new mock_context_builder_1.MockContextBuilder(exports.mockStorage);
+    // Inject mocks into the service factory
+    (0, ai_service_factory_1.injectTestInstances)({
+        storage: exports.mockStorage,
+        aiOperations: exports.mockAIOperations,
+        modelProvider: exports.mockModelProvider,
+        contextBuilder: exports.mockContextBuilder,
+    });
+}
+/**
+ * Get current mock instances for test assertions
+ */
+function getMocks() {
+    return {
+        storage: exports.mockStorage,
+        aiOperations: exports.mockAIOperations,
+        modelProvider: exports.mockModelProvider,
+        contextBuilder: exports.mockContextBuilder,
+    };
+}

package/dist/test/test-setup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Test Setup - Global test configuration and cleanup
+ * This file sets up the test environment to ensure proper isolation and configuration
+ */
+export declare function setupTestEnvironment(): {
+    config: import("../lib/config").Config;
+    workingDir: string;
+};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../../src/test/test-setup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAsCH,wBAAgB,oBAAoB;;;EAMnC"}

package/dist/test/test-setup.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Test Setup - Global test configuration and cleanup
+ * This file sets up the test environment to ensure proper isolation and configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTestEnvironment = setupTestEnvironment;
+const config_1 = require("../lib/config");
+const hooks_1 = require("../lib/hooks");
+const test_mock_setup_1 = require("./test-mock-setup");
+// Global test setup
+before(async function () {
+    // Set up a test working directory
+    const testDir = process.cwd();
+    config_1.configManager.setWorkingDirectory(testDir);
+    // Set up a minimal test configuration (no need to load from disk)
+    config_1.configManager.setConfig({
+        ai: {
+            provider: "openrouter",
+            model: "anthropic/claude-3-5-sonnet",
+            maxTokens: 4000,
+            temperature: 0.7,
+            apiKey: "test-key",
+        },
+        workingDirectory: testDir,
+    });
+    // Reset mocks to ensure clean state
+    (0, test_mock_setup_1.resetMocks)();
+});
+// Clean up between tests
+afterEach(function () {
+    // Reset mocks to ensure clean state
+    (0, test_mock_setup_1.resetMocks)();
+    // Clean up hooks to prevent interference
+    hooks_1.hooks.clear();
+});
+// Additional test utilities
+function setupTestEnvironment() {
+    // This can be called in individual tests for additional setup
+    return {
+        config: config_1.configManager.getConfig(),
+        workingDir: config_1.configManager.getWorkingDirectory(),
+    };
+}

package/dist/test/test-utils.d.ts

@@ -0,0 +1,22 @@
+import { MockStorage } from "./mocks/mock-storage";
+import { MockAIOperations } from "./mocks/mock-ai-operations";
+import { MockModelProvider } from "./mocks/mock-model-provider";
+import { MockContextBuilder } from "./mocks/mock-context-builder";
+export interface TestContext {
+    storage: MockStorage;
+    aiOperations: MockAIOperations;
+    modelProvider: MockModelProvider;
+    contextBuilder: MockContextBuilder;
+}
+export declare function createTestContext(): TestContext;
+export declare function createTestTaskData(): {
+    title: string;
+    description: string;
+    content: string;
+    effort: "medium";
+};
+export declare function createTestPRDData(): {
+    description: string;
+    content: string;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/test/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/test/test-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAElE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,WAAW,CAAC;IACrB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,aAAa,EAAE,iBAAiB,CAAC;IACjC,cAAc,EAAE,kBAAkB,CAAC;CACpC;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAc/C;AAED,wBAAgB,kBAAkB;;;;;EAOjC;AAED,wBAAgB,iBAAiB;;;EAMhC"}

package/dist/test/test-utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestContext = createTestContext;
+exports.createTestTaskData = createTestTaskData;
+exports.createTestPRDData = createTestPRDData;
+const mock_service_factory_1 = require("./mocks/mock-service-factory");
+const mock_storage_1 = require("./mocks/mock-storage");
+const mock_ai_operations_1 = require("./mocks/mock-ai-operations");
+const mock_model_provider_1 = require("./mocks/mock-model-provider");
+const mock_context_builder_1 = require("./mocks/mock-context-builder");
+function createTestContext() {
+    (0, mock_service_factory_1.resetMockServices)();
+    const storage = new mock_storage_1.MockStorage();
+    const aiOperations = new mock_ai_operations_1.MockAIOperations();
+    const modelProvider = new mock_model_provider_1.MockModelProvider();
+    const contextBuilder = new mock_context_builder_1.MockContextBuilder(storage);
+    return {
+        storage,
+        aiOperations,
+        modelProvider,
+        contextBuilder,
+    };
+}
+function createTestTaskData() {
+    return {
+        title: "Test Task",
+        description: "This is a test task description",
+        content: "Full content for the test task",
+        effort: "medium",
+    };
+}
+function createTestPRDData() {
+    return {
+        description: "Test PRD description",
+        content: "# Test PRD\n\nThis is a test PRD document with multiple sections.\n\n## Features\n- Feature 1\n- Feature 2\n\n## Requirements\n- Requirement 1\n- Requirement 2",
+    };
+}

package/dist/test/utils/ai-operation-utility.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai-operation-utility.test.d.ts.map

package/dist/test/utils/ai-operation-utility.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-operation-utility.test.d.ts","sourceRoot":"","sources":["../../../src/test/utils/ai-operation-utility.test.ts"],"names":[],"mappings":""}

package/dist/test/utils/ai-operation-utility.test.js

@@ -0,0 +1,290 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const ai_operation_utility_1 = require("../../utils/ai-operation-utility");
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+/**
+ * ⚠️ CRITICAL: These tests use 100% MOCKS - ZERO real AI calls
+ * No API calls are made, no costs incurred, tests run fast
+ */
+describe("AIOperationUtility", () => {
+    let utility;
+    let mockRetryHandler;
+    let mockModelProvider;
+    let mockContext7Client;
+    beforeEach(() => {
+        // Create utility instance
+        utility = new ai_operation_utility_1.AIOperationUtility();
+        // Create mock retry handler - NO REAL RETRIES
+        mockRetryHandler = {
+            executeWithRetry: async (operation) => {
+                // Execute immediately without real retry logic
+                return await operation();
+            },
+        };
+        // Create mock model provider - NO REAL AI MODELS
+        mockModelProvider = {
+            getModel: () => ({
+                // Mock AI SDK v2 compliant model
+                specificationVersion: "v2",
+                provider: "mock",
+                modelId: "mock-model",
+                doGenerate: async () => ({
+                    text: "Mock response",
+                    finishReason: "stop",
+                    usage: {
+                        promptTokens: 10,
+                        completionTokens: 5,
+                        totalTokens: 15,
+                    },
+                }),
+                doStream: async () => ({
+                    stream: (async function* () {
+                        yield { type: "text-delta", textDelta: "Mock" };
+                        yield { type: "text-delta", textDelta: " response" };
+                    })(),
+                }),
+            }),
+            getAIConfig: () => ({
+                provider: "mock",
+                model: "mock-model",
+                apiKey: "mock-key",
+            }),
+        };
+        // Create mock Context7 client - NO REAL DOCUMENTATION FETCHES
+        mockContext7Client = {
+            saveContext7Documentation: () => {
+                // Mock save - no real file writes
+            },
+            getMCPTools: async () => ({}),
+        };
+        // Inject mocks into utility
+        utility.retryHandler = mockRetryHandler;
+        utility.modelProvider = mockModelProvider;
+        utility.context7Client = mockContext7Client;
+    });
+    describe("executeAIOperation", () => {
+        it("should execute operation successfully and return result with metrics", async () => {
+            // Mock operation that returns a simple result
+            const mockResult = { data: "test result" };
+            const operation = async () => mockResult;
+            const result = await utility.executeAIOperation("test operation", operation);
+            assert.deepStrictEqual(result.result, mockResult);
+            assert.ok("duration" in result.metrics);
+            assert.strictEqual(typeof result.metrics.duration, "number");
+            assert.ok(result.metrics.duration >= 0);
+        });
+        it("should throw TaskOMaticError when operation fails", async () => {
+            // Mock operation that throws an error
+            const operation = async () => {
+                throw new Error("Mock AI failure");
+            };
+            try {
+                await utility.executeAIOperation("test operation", operation);
+                assert.fail("Should have thrown TaskOMaticError");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                assert.strictEqual(error.code, "AI_OPERATION_FAILED");
+                assert.ok(error.message.includes("test operation"));
+                assert.ok(Array.isArray(error.suggestions));
+            }
+        });
+        it("should preserve error details in TaskOMaticError", async () => {
+            const originalError = new Error("Original error message");
+            const operation = async () => {
+                throw originalError;
+            };
+            try {
+                await utility.executeAIOperation("test operation", operation);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                const taskError = error;
+                assert.strictEqual(taskError.cause, originalError);
+                assert.ok(taskError.context?.includes("test operation"));
+                assert.ok("operationName" in (taskError.metadata || {}));
+            }
+        });
+        it("should capture duration metrics correctly", async () => {
+            const operation = async () => {
+                // Simulate some work
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                return { data: "result" };
+            };
+            const result = await utility.executeAIOperation("slow operation", operation);
+            assert.ok(result.metrics.duration >= 50);
+        });
+        it("should respect maxRetries option", async () => {
+            let attemptCount = 0;
+            // Mock retry handler that counts attempts
+            utility.retryHandler = {
+                executeWithRetry: async (operation, config) => {
+                    attemptCount++;
+                    assert.strictEqual(config.maxAttempts, 5);
+                    return await operation();
+                },
+            };
+            const operation = async () => ({ data: "result" });
+            await utility.executeAIOperation("test", operation, { maxRetries: 5 });
+            assert.strictEqual(attemptCount, 1);
+        });
+        it("should extract token usage from result if available", async () => {
+            const mockResult = {
+                data: "test",
+                usage: {
+                    prompt_tokens: 100,
+                    completion_tokens: 50,
+                    total_tokens: 150,
+                },
+            };
+            const operation = async () => mockResult;
+            const result = await utility.executeAIOperation("test", operation);
+            assert.deepStrictEqual(result.metrics.tokenUsage, {
+                prompt: 100,
+                completion: 50,
+                total: 150,
+            });
+        });
+        it("should return undefined tokenUsage if not available in result", async () => {
+            const mockResult = { data: "test" };
+            const operation = async () => mockResult;
+            const result = await utility.executeAIOperation("test", operation);
+            assert.strictEqual(result.metrics.tokenUsage, undefined);
+        });
+    });
+    describe("streamTextWithTools", () => {
+        it("should verify method signature exists - NO REAL AI CALL", async () => {
+            // This test verifies the method exists and has the correct signature
+            // We don't actually call it to avoid real AI calls
+            assert.strictEqual(typeof utility.streamTextWithTools, "function");
+            // Verify the method is accessible
+            assert.ok("streamTextWithTools" in utility);
+        });
+        it("should pass tools to streamText when provided - NO REAL AI CALL", async () => {
+            // This test would verify tool passing in a real scenario
+            // For now, we just verify the method accepts tools parameter
+            const mockTools = {
+                readFile: {
+                    description: "Read a file",
+                    parameters: {},
+                    execute: async () => ({}),
+                },
+            };
+            // The method should not throw
+            try {
+                // We can't fully test without real AI, but we verify the signature
+                assert.strictEqual(typeof utility.streamTextWithTools, "function");
+            }
+            catch (error) {
+                assert.fail("Should not throw with valid parameters");
+            }
+        });
+    });
+    describe("Error Handling", () => {
+        it("should wrap string errors in Error objects", async () => {
+            const operation = async () => {
+                throw "String error";
+            };
+            try {
+                await utility.executeAIOperation("test", operation);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                assert.ok(error.cause instanceof Error);
+            }
+        });
+        it("should include suggestions in thrown errors", async () => {
+            const operation = async () => {
+                throw new Error("Network timeout");
+            };
+            try {
+                await utility.executeAIOperation("test", operation);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                const taskError = error;
+                assert.ok(Array.isArray(taskError.suggestions));
+                assert.ok(taskError.suggestions.length > 0);
+                assert.ok(taskError.suggestions?.includes("Check AI configuration"));
+            }
+        });
+    });
+    describe("Metrics Collection", () => {
+        it("should always include duration in metrics", async () => {
+            const operation = async () => ({ data: "result" });
+            const result = await utility.executeAIOperation("test", operation);
+            assert.ok("duration" in result.metrics);
+            assert.strictEqual(typeof result.metrics.duration, "number");
+            assert.ok(result.metrics.duration >= 0);
+        });
+        it("should capture metrics even on error", async () => {
+            const operation = async () => {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                throw new Error("Failure");
+            };
+            try {
+                await utility.executeAIOperation("test", operation);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                const taskError = error;
+                assert.ok("duration" in (taskError.metadata || {}));
+                assert.ok(taskError.metadata?.duration >= 10);
+            }
+        });
+    });
+    describe("Streaming Options", () => {
+        it("should wrap streaming options without modifying original", async () => {
+            let chunkCount = 0;
+            const originalOnChunk = (chunk) => {
+                chunkCount++;
+            };
+            const streamingOptions = {
+                onChunk: originalOnChunk,
+            };
+            // The wrapping happens internally, we just verify it doesn't throw
+            const operation = async () => ({ data: "result" });
+            await utility.executeAIOperation("test", operation, {
+                streamingOptions,
+            });
+            // Original callback should not be modified
+            assert.strictEqual(streamingOptions.onChunk, originalOnChunk);
+        });
+    });
+});

package/dist/test/utils/error-handling.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error-handling.test.d.ts.map

package/dist/test/utils/error-handling.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling.test.d.ts","sourceRoot":"","sources":["../../../src/test/utils/error-handling.test.ts"],"names":[],"mappings":""}