@forgehive/hive-sdk 0.1.3 → 0.1.5

package/dist/index.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHiveClient = exports.HiveClient = exports.createHiveLogClient = exports.HiveLogClient = void 0;
+exports.createClientFromForgeConf = exports.createHiveClient = exports.HiveClient = exports.createHiveLogClient = exports.HiveLogClient = void 0;
 exports.isApiError = isApiError;
 exports.isInvokeError = isInvokeError;
 const axios_1 = __importDefault(require("axios"));
 const debug_1 = __importDefault(require("debug"));
+const uuid_1 = require("uuid");
+const fs_1 = __importDefault(require("fs"));
 const log = (0, debug_1.default)('hive-sdk');
 // Type guard to check if response is an error
 function isApiError(response) {
@@ -15,10 +17,12 @@ function isApiError(response) {
 }
 class HiveLogClient {
     constructor(config) {
+        this.forgeConfig = null;
         const apiKey = config.apiKey || process.env.HIVE_API_KEY;
         const apiSecret = config.apiSecret || process.env.HIVE_API_SECRET;
         const host = config.host || process.env.HIVE_HOST || 'https://www.forgehive.cloud';
         this.projectName = config.projectName;
+        this.projectUuid = config.projectUuid || null;
         this.baseMetadata = config.metadata || {};
         if (!apiKey || !apiSecret) {
             this.apiKey = null;
@@ -34,10 +38,117 @@ class HiveLogClient {
             this.isInitialized = true;
             log('HiveLogClient initialized for project "%s" with host "%s"', config.projectName, host);
         }
+        // Load forge.json - use provided path or default to ./forge.json
+        const configPath = config.forgeConfigPath || './forge.json';
+        this.loadForgeConfig(configPath);
     }
     isActive() {
         return this.isInitialized;
     }
+    maskSecret(secret) {
+        if (!secret || secret.length <= 8) {
+            return secret ? '****' : 'null';
+        }
+        const first4 = secret.slice(0, 4);
+        const last4 = secret.slice(-4);
+        const middle = '*'.repeat(secret.length - 8);
+        return `${first4}${middle}${last4}`;
+    }
+    getConf() {
+        return {
+            projectName: this.projectName,
+            projectUuid: this.projectUuid,
+            host: this.host,
+            apiKey: this.maskSecret(this.apiKey),
+            apiSecret: this.maskSecret(this.apiSecret),
+            isInitialized: this.isInitialized,
+            baseMetadata: this.baseMetadata,
+            forgeConfig: this.forgeConfig
+        };
+    }
+    async testConfig() {
+        if (!this.isInitialized) {
+            return {
+                success: false,
+                error: 'Client not initialized - missing API credentials'
+            };
+        }
+        try {
+            // First verify credentials with /api/me
+            const meResponse = await axios_1.default.get(`${this.host}/api/me`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}:${this.apiSecret}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (meResponse.status !== 200) {
+                const error = `Credential verification failed: HTTP ${meResponse.status}`;
+                log('Failed to verify credentials: %s', error);
+                return { success: false, error };
+            }
+            const meData = meResponse.data;
+            log('Successfully verified credentials for user "%s" in team "%s"', meData.user?.name, meData.team?.name);
+            // Then verify project exists if we have a projectUuid
+            let projectExists = false;
+            let projectName;
+            let tasksVerified;
+            if (this.projectUuid) {
+                try {
+                    const projectResponse = await axios_1.default.get(`${this.host}/api/projects/${this.projectUuid}`, {
+                        headers: {
+                            'Authorization': `Bearer ${this.apiKey}:${this.apiSecret}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (projectResponse.status === 200) {
+                        projectExists = true;
+                        projectName = projectResponse.data.project?.projectName;
+                        log('Successfully verified project "%s" exists with UUID "%s"', projectName, this.projectUuid);
+                        // Verify tasks if we have forge config
+                        if (this.forgeConfig && this.forgeConfig.tasks) {
+                            const localTasks = Object.keys(this.forgeConfig.tasks);
+                            const remoteTasks = projectResponse.data.project?.tasks || [];
+                            const remoteTaskUuids = new Set(remoteTasks.map((task) => task.uuid));
+                            const missing = [];
+                            let found = 0;
+                            for (const taskName of localTasks) {
+                                const taskUuid = this.forgeConfig.tasks[taskName].uuid;
+                                if (remoteTaskUuids.has(taskUuid)) {
+                                    found++;
+                                }
+                                else {
+                                    missing.push(taskName);
+                                }
+                            }
+                            tasksVerified = {
+                                total: localTasks.length,
+                                found,
+                                missing
+                            };
+                            log('Task verification: %d/%d tasks found, missing: %s', found, localTasks.length, missing.join(', '));
+                        }
+                    }
+                }
+                catch (projectError) {
+                    log('Project verification failed for UUID "%s": %s', this.projectUuid, projectError instanceof Error ? projectError.message : String(projectError));
+                }
+            }
+            return {
+                success: true,
+                teamName: meData.team?.name,
+                teamUuid: meData.team?.uuid,
+                userName: meData.user?.name,
+                projectName,
+                projectExists: this.projectUuid ? projectExists : undefined,
+                tasksVerified
+            };
+        }
+        catch (e) {
+            const error = e instanceof Error ? e.message : 'Network error';
+            log('Error during config test: %s', error);
+            return { success: false, error };
+        }
+    }
     mergeMetadata(record, sendLogMetadata) {
         // Start with base metadata from client
         let finalMetadata = { ...this.baseMetadata };
@@ -58,13 +169,15 @@ class HiveLogClient {
             log('Silent mode: Skipping sendLog for task "%s" - client not initialized', taskName);
             return 'silent';
         }
+        // Deprecation warning for legacy endpoint
+        log('DEPRECATION WARNING: sendLog() is deprecated. Use sendLogByUuid() with project and task UUIDs for enhanced features and better performance.');
         try {
             const logsUrl = `${this.host}/api/tasks/log-ingest`;
             log('Sending log for task "%s" to %s', taskName, logsUrl);
             const authToken = `${this.apiKey}:${this.apiSecret}`;
             // Merge metadata with priority: sendLog > record.metadata > client
             const finalMetadata = this.mergeMetadata(record, metadata);
-            // Create logItem with merged metadata
+            // Create logItem with merged metadata (no UUID generation for legacy method)
             const logItem = {
                 ...record,
                 taskName,
@@ -93,6 +206,52 @@ class HiveLogClient {
             return 'error';
         }
     }
+    async sendLogByUuid(record, taskUuid, metadata) {
+        if (!this.isInitialized) {
+            log('Silent mode: Skipping sendLogByUuid for task UUID "%s" - client not initialized', taskUuid);
+            return 'silent';
+        }
+        if (!this.projectUuid) {
+            log('Error: sendLogByUuid requires projectUuid to be set in client config');
+            return 'error';
+        }
+        try {
+            const logsUrl = `${this.host}/api/log-ingest`;
+            log('Sending log for task UUID "%s" to %s', taskUuid, logsUrl);
+            const authToken = `${this.apiKey}:${this.apiSecret}`;
+            // Merge metadata with priority: sendLog > record.metadata > client
+            const finalMetadata = this.mergeMetadata(record, metadata);
+            // Ensure execution record has a UUID - generate one if missing
+            const recordWithUuid = {
+                ...record,
+                uuid: record.uuid || (0, uuid_1.v7)(),
+                metadata: finalMetadata
+            };
+            // Create logItem with merged metadata and UUID
+            const logItem = recordWithUuid;
+            const response = await axios_1.default.post(logsUrl, {
+                projectUuid: this.projectUuid,
+                taskUuid,
+                logItem: JSON.stringify(logItem)
+            }, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            log('Success: Sent log for task UUID "%s"', taskUuid);
+            // Return the full response data if available
+            if (response.data && typeof response.data === 'object' && 'uuid' in response.data) {
+                return response.data;
+            }
+            return 'success';
+        }
+        catch (e) {
+            const error = e;
+            log('Error: Failed to send log for task UUID "%s": %s', taskUuid, error.message);
+            return 'error';
+        }
+    }
     getListener() {
         return async (record) => {
             await this.sendLog(record);
@@ -148,6 +307,52 @@ class HiveLogClient {
             return false;
         }
     }
+    loadForgeConfig(configPath) {
+        try {
+            if (fs_1.default.existsSync(configPath)) {
+                const configContent = fs_1.default.readFileSync(configPath, 'utf8');
+                this.forgeConfig = JSON.parse(configContent);
+                log('Found forge.json configuration at %s', configPath);
+            }
+            else {
+                log('No forge.json configuration found at %s', configPath);
+            }
+        }
+        catch (error) {
+            log('Error loading forge.json: %s', error instanceof Error ? error.message : String(error));
+        }
+    }
+    getTaskUUID(taskName) {
+        if (!this.forgeConfig) {
+            log('No forge.json configuration loaded, cannot get UUID for task "%s"', taskName);
+            return null;
+        }
+        const task = this.forgeConfig.tasks[taskName];
+        if (!task) {
+            log('Task "%s" not found in forge.json configuration', taskName);
+            return null;
+        }
+        log('Found UUID "%s" for task "%s"', task.uuid, taskName);
+        return task.uuid;
+    }
+    async sendLogByName(taskName, record, metadata) {
+        if (!this.isInitialized) {
+            log('Silent mode: Skipping sendLogByName for task "%s" - client not initialized', taskName);
+            return 'silent';
+        }
+        if (!this.projectUuid) {
+            log('Error: sendLogByName requires projectUuid to be set in client config');
+            return 'error';
+        }
+        const taskUuid = this.getTaskUUID(taskName);
+        if (!taskUuid) {
+            log('Error: Cannot find UUID for task "%s" in forge.json', taskName);
+            return 'error';
+        }
+        // Use the existing sendLogByUuid method
+        log('Sending log for task "%s" with uuid "%s"', taskName, taskUuid);
+        return await this.sendLogByUuid(record, taskUuid, metadata);
+    }
 }
 exports.HiveLogClient = HiveLogClient;
 const createHiveLogClient = (config) => {
@@ -173,10 +378,77 @@ class HiveClient {
         this.apiSecret = apiSecret;
         log('HiveClient initialized for project "%s" with host "%s"', config.projectUuid, host);
     }
-    async invoke(taskName, payload) {
+    maskSecret(secret) {
+        if (secret.length <= 8) {
+            return '****';
+        }
+        const first4 = secret.slice(0, 4);
+        const last4 = secret.slice(-4);
+        const middle = '*'.repeat(secret.length - 8);
+        return `${first4}${middle}${last4}`;
+    }
+    getConf() {
+        return {
+            projectUuid: this.projectUuid,
+            host: this.host,
+            apiKey: this.maskSecret(this.apiKey),
+            apiSecret: this.maskSecret(this.apiSecret)
+        };
+    }
+    async testConfig() {
+        try {
+            // First verify credentials with /api/me
+            const meResponse = await axios_1.default.get(`${this.host}/api/me`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}:${this.apiSecret}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (meResponse.status !== 200) {
+                const error = `Credential verification failed: HTTP ${meResponse.status}`;
+                log('Failed to verify credentials: %s', error);
+                return { success: false, error };
+            }
+            const meData = meResponse.data;
+            log('Successfully verified credentials for user "%s" in team "%s"', meData.user?.name, meData.team?.name);
+            // Then verify project exists
+            let projectExists = false;
+            let projectName;
+            try {
+                const projectResponse = await axios_1.default.get(`${this.host}/api/projects/${this.projectUuid}`, {
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}:${this.apiSecret}`,
+                        'Content-Type': 'application/json'
+                    }
+                });
+                if (projectResponse.status === 200) {
+                    projectExists = true;
+                    projectName = projectResponse.data.project?.projectName;
+                    log('Successfully verified project "%s" exists with UUID "%s"', projectName, this.projectUuid);
+                }
+            }
+            catch (projectError) {
+                log('Project verification failed for UUID "%s": %s', this.projectUuid, projectError instanceof Error ? projectError.message : String(projectError));
+            }
+            return {
+                success: true,
+                teamName: meData.team?.name,
+                teamUuid: meData.team?.uuid,
+                userName: meData.user?.name,
+                projectName,
+                projectExists
+            };
+        }
+        catch (e) {
+            const error = e instanceof Error ? e.message : 'Network error';
+            log('Error during config test: %s', error);
+            return { success: false, error };
+        }
+    }
+    async invoke(taskUuid, payload) {
         try {
-            const invokeUrl = `${this.host}/api/project/${this.projectUuid}/task/${taskName}/invoke`;
-            log('Invoking task "%s" at %s', taskName, invokeUrl);
+            const invokeUrl = `${this.host}/api/projects/${this.projectUuid}/tasks/${taskUuid}/invoke`;
+            log('Invoking task UUID "%s" at %s', taskUuid, invokeUrl);
             const authToken = `${this.apiKey}:${this.apiSecret}`;
             const response = await axios_1.default.post(invokeUrl, {
                 payload
@@ -186,12 +458,12 @@ class HiveClient {
                     'Content-Type': 'application/json'
                 }
             });
-            log('Success: Invoked task "%s"', taskName);
+            log('Success: Invoked task UUID "%s"', taskUuid);
             return response.data;
         }
         catch (e) {
             const error = e;
-            log('Error: Failed to invoke task "%s": %s', taskName, error.message);
+            log('Error: Failed to invoke task UUID "%s": %s', taskUuid, error.message);
             // Check if it's an axios error with response data
             if (axios_1.default.isAxiosError(error) && error.response?.data) {
                 return error.response.data;
@@ -206,3 +478,36 @@ const createHiveClient = (config) => {
     return new HiveClient(config);
 };
 exports.createHiveClient = createHiveClient;
+/**
+ * Create a HiveLogClient from forge.json configuration
+ * @param forgeConfigPath Path to forge.json file (defaults to './forge.json')
+ * @param additionalConfig Additional config options to override forge.json values
+ * @returns HiveLogClient configured from forge.json
+ */
+const createClientFromForgeConf = (forgeConfigPath = './forge.json', additionalConfig = {}) => {
+    log('Creating HiveLogClient from forge.json at "%s"', forgeConfigPath);
+    let forgeConfig = null;
+    try {
+        if (fs_1.default.existsSync(forgeConfigPath)) {
+            const configContent = fs_1.default.readFileSync(forgeConfigPath, 'utf8');
+            forgeConfig = JSON.parse(configContent);
+            log('Loaded forge.json configuration from %s', forgeConfigPath);
+        }
+        else {
+            log('No forge.json found at %s', forgeConfigPath);
+            throw new Error(`forge.json not found at ${forgeConfigPath}`);
+        }
+    }
+    catch (error) {
+        log('Error loading forge.json: %s', error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+    const config = {
+        projectName: forgeConfig.project.name,
+        projectUuid: forgeConfig.project.uuid,
+        forgeConfigPath,
+        ...additionalConfig // Allow overriding any config values
+    };
+    return new HiveLogClient(config);
+};
+exports.createClientFromForgeConf = createClientFromForgeConf;

package/dist/test/sendLogByUuid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/sendLogByUuid.test.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('HiveLogClient sendLogByUuid', () => {
+    const testConfig = {
+        projectName: 'test-project',
+        projectUuid: '550e8400-e29b-41d4-a716-446655440000',
+        apiKey: 'test-key',
+        apiSecret: 'test-secret',
+        host: 'https://test.example.com'
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('UUID Generation', () => {
+        it('should generate UUID v7 when execution record has no UUID', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const client = new index_1.HiveLogClient(testConfig);
+            const executionRecord = {
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            // Check that the request was made with a UUID
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(typeof logItem.uuid).toBe('string');
+            expect(logItem.uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i); // UUID v7 pattern
+        });
+        it('should preserve existing UUID when execution record already has one', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const client = new index_1.HiveLogClient(testConfig);
+            const existingUuid = '01234567-89ab-7def-8123-456789abcdef';
+            const executionRecord = {
+                uuid: existingUuid,
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            // Check that the existing UUID was preserved
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBe(existingUuid);
+        });
+        it('should generate UUID v7 when execution record has empty UUID', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const client = new index_1.HiveLogClient(testConfig);
+            const executionRecord = {
+                uuid: '', // Empty string should trigger UUID generation
+                input: { value: 'test-input' },
+                output: { result: 'test-output' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('success');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            // Check that a new UUID was generated (not empty string)
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(logItem.uuid).not.toBe('');
+            expect(typeof logItem.uuid).toBe('string');
+            expect(logItem.uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i); // UUID v7 pattern
+        });
+    });
+    describe('API Integration', () => {
+        it('should send correct request to log-ingest endpoint', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const client = new index_1.HiveLogClient(testConfig);
+            const taskUuid = 'f47ac10b-58cc-4372-a567-0e02b2c3d479';
+            const executionRecord = {
+                input: { userId: 123 },
+                output: { result: 'processed' },
+                taskName: 'process-user',
+                type: 'success',
+                boundaries: {},
+                metadata: { session: 'abc123' }
+            };
+            await client.sendLogByUuid(executionRecord, taskUuid);
+            expect(mockedAxios.post).toHaveBeenCalledWith('https://test.example.com/api/log-ingest', {
+                projectUuid: testConfig.projectUuid,
+                taskUuid: taskUuid,
+                logItem: expect.any(String)
+            }, {
+                headers: {
+                    'Authorization': 'Bearer test-key:test-secret',
+                    'Content-Type': 'application/json'
+                }
+            });
+            // Verify the logItem contains the execution record with UUID
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            expect(logItem.uuid).toBeDefined();
+            expect(logItem.input).toEqual({ userId: 123 });
+            expect(logItem.output).toEqual({ result: 'processed' });
+            expect(logItem.taskName).toBe('process-user');
+            expect(logItem.type).toBe('success');
+            expect(logItem.metadata).toEqual({ session: 'abc123' });
+        });
+        it('should return "silent" when client is not initialized', async () => {
+            const client = new index_1.HiveLogClient({
+                projectName: 'test-project',
+                projectUuid: testConfig.projectUuid
+                // Missing apiKey and apiSecret
+            });
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('silent');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+        it('should return "error" when projectUuid is missing', async () => {
+            const client = new index_1.HiveLogClient({
+                projectName: 'test-project',
+                apiKey: 'test-key',
+                apiSecret: 'test-secret',
+                host: 'https://test.example.com'
+                // Missing projectUuid
+            });
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('error');
+            expect(mockedAxios.post).not.toHaveBeenCalled();
+        });
+        it('should handle API error responses', async () => {
+            mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+            const client = new index_1.HiveLogClient(testConfig);
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toBe('error');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+        });
+        it('should return response data when API returns object with uuid', async () => {
+            const responseData = { uuid: 'log-uuid-123', success: true };
+            mockedAxios.post.mockResolvedValueOnce({ data: responseData });
+            const client = new index_1.HiveLogClient(testConfig);
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: {}
+            };
+            const result = await client.sendLogByUuid(executionRecord, 'task-uuid-123');
+            expect(result).toEqual(responseData);
+        });
+    });
+    describe('Metadata Handling', () => {
+        it('should merge metadata correctly with UUID generation', async () => {
+            mockedAxios.post.mockResolvedValueOnce({ data: { success: true } });
+            const baseMetadata = { environment: 'test', version: '1.0' };
+            const client = new index_1.HiveLogClient({ ...testConfig, metadata: baseMetadata });
+            const recordMetadata = { session: 'abc123' };
+            const sendLogMetadata = { priority: 'high' };
+            const executionRecord = {
+                input: { value: 'test' },
+                taskName: 'test-task',
+                type: 'success',
+                boundaries: {},
+                metadata: recordMetadata
+            };
+            await client.sendLogByUuid(executionRecord, 'task-uuid-123', sendLogMetadata);
+            const callArgs = mockedAxios.post.mock.calls[0];
+            const requestBody = callArgs[1];
+            const logItem = JSON.parse(requestBody.logItem);
+            // Should have UUID generated
+            expect(logItem.uuid).toBeDefined();
+            expect(typeof logItem.uuid).toBe('string');
+            // Should have merged metadata (sendLog > record > client)
+            expect(logItem.metadata).toEqual({
+                environment: 'test', // from client
+                version: '1.0', // from client
+                session: 'abc123', // from record
+                priority: 'high' // from sendLog (highest priority)
+            });
+        });
+    });
+});

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@forgehive/hive-sdk",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/task": "^0.2.5"
+      "@forgehive/task": "^0.2.6"
     }
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/node": "^24.0.3",
+    "@types/uuid": "^10.0.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2"
   },
@@ -22,7 +23,8 @@
   "dependencies": {
     "axios": "^1.8.4",
     "debug": "^4.4.1",
-    "@forgehive/task": "0.2.5"
+    "uuid": "^11.1.0",
+    "@forgehive/task": "0.2.6"
   },
   "scripts": {
     "build": "tsc",