@forgehive/hive-sdk 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export interface Metadata {
 export type { ExecutionRecord } from '@forgehive/task';
 export interface HiveLogClientConfig {
     projectName: string;
+    projectUuid?: string;
     apiKey?: string;
     apiSecret?: string;
     host?: string;
@@ -35,12 +36,14 @@ export declare class HiveLogClient {
     private apiSecret;
     private host;
     private projectName;
+    private projectUuid;
     private baseMetadata;
     private isInitialized;
     constructor(config: HiveLogClientConfig);
     isActive(): boolean;
     private mergeMetadata;
-    sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent'>;
+    sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess>;
+    sendLogByUuid(record: ExecutionRecord, taskUuid: string, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess>;
     getListener(): (record: ExecutionRecord) => Promise<void>;
     getLog(taskName: string, uuid: string): Promise<LogApiResult | null>;
     setQuality(taskName: string, uuid: string, quality: Quality): Promise<boolean>;

package/dist/index.js

@@ -8,6 +8,7 @@ exports.isApiError = isApiError;
 exports.isInvokeError = isInvokeError;
 const axios_1 = __importDefault(require("axios"));
 const debug_1 = __importDefault(require("debug"));
+const uuid_1 = require("uuid");
 const log = (0, debug_1.default)('hive-sdk');
 // Type guard to check if response is an error
 function isApiError(response) {
@@ -19,6 +20,7 @@ class HiveLogClient {
         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;
@@ -58,19 +60,21 @@ 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,
                 metadata: finalMetadata
             };
-            await axios_1.default.post(logsUrl, {
+            const response = await axios_1.default.post(logsUrl, {
                 projectName: this.projectName,
                 taskName,
                 logItem: JSON.stringify(logItem)
@@ -81,6 +85,10 @@ class HiveLogClient {
                 }
             });
             log('Success: Sent log for task "%s"', taskName);
+            // 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) {
@@ -89,6 +97,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);

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.2",
+  "version": "0.1.4",
   "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",

package/src/index.ts

@@ -1,5 +1,6 @@
 import axios from 'axios'
 import debug from 'debug'
+import { v7 as uuidv7 } from 'uuid'
 import type { ExecutionRecord } from '@forgehive/task'
 
 const log = debug('hive-sdk')
@@ -15,6 +16,7 @@ export type { ExecutionRecord } from '@forgehive/task'
 // Configuration interface for HiveLogClient
 export interface HiveLogClientConfig {
   projectName: string
+  projectUuid?: string // Optional UUID for new endpoint
   apiKey?: string
   apiSecret?: string
   host?: string
@@ -56,6 +58,7 @@ export class HiveLogClient {
   private apiSecret: string | null
   private host: string | null
   private projectName: string
+  private projectUuid: string | null
   private baseMetadata: Metadata
   private isInitialized: boolean
 
@@ -65,6 +68,7 @@ export class HiveLogClient {
     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) {
@@ -103,7 +107,7 @@ export class HiveLogClient {
     return finalMetadata
   }
 
-  async sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent'> {
+  async sendLog(record: ExecutionRecord, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess> {
     // Extract taskName from record
     const taskName = record.taskName || 'unknown-task'
 
@@ -112,6 +116,9 @@ export class HiveLogClient {
       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)
@@ -121,14 +128,14 @@ export class HiveLogClient {
       // 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,
         metadata: finalMetadata
       }
 
-      await axios.post(logsUrl, {
+      const response = await axios.post(logsUrl, {
         projectName: this.projectName,
         taskName,
         logItem: JSON.stringify(logItem)
@@ -140,6 +147,12 @@ export class HiveLogClient {
       })
 
       log('Success: Sent log for task "%s"', taskName)
+
+      // Return the full response data if available
+      if (response.data && typeof response.data === 'object' && 'uuid' in response.data) {
+        return response.data as LogApiSuccess
+      }
+
       return 'success'
     } catch (e) {
       const error = e as Error
@@ -148,6 +161,62 @@ export class HiveLogClient {
     }
   }
 
+  async sendLogByUuid(record: ExecutionRecord, taskUuid: string, metadata?: Metadata): Promise<'success' | 'error' | 'silent' | LogApiSuccess> {
+    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 || uuidv7(),
+        metadata: finalMetadata
+      }
+
+      // Create logItem with merged metadata and UUID
+      const logItem = recordWithUuid
+
+      const response = await axios.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 as LogApiSuccess
+      }
+
+      return 'success'
+    } catch (e) {
+      const error = e as Error
+      log('Error: Failed to send log for task UUID "%s": %s', taskUuid, error.message)
+      return 'error'
+    }
+  }
+
   getListener(): (record: ExecutionRecord) => Promise<void> {
     return async (record: ExecutionRecord) => {
       await this.sendLog(record)

package/src/test/sendLogByUuid.test.ts

@@ -0,0 +1,272 @@
+import axios from 'axios'
+import { HiveLogClient } from '../index'
+
+// Mock axios
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+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 HiveLogClient(testConfig)
+      const executionRecord = {
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        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] as { projectUuid: string; taskUuid: string; logItem: string }
+      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 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' as const,
+        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] as { projectUuid: string; taskUuid: string; logItem: string }
+      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 HiveLogClient(testConfig)
+      const executionRecord = {
+        uuid: '', // Empty string should trigger UUID generation
+        input: { value: 'test-input' },
+        output: { result: 'test-output' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        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] as { projectUuid: string; taskUuid: string; logItem: string }
+      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 HiveLogClient(testConfig)
+      const taskUuid = 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+      const executionRecord = {
+        input: { userId: 123 },
+        output: { result: 'processed' },
+        taskName: 'process-user',
+        type: 'success' as const,
+        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] as { projectUuid: string; taskUuid: string; logItem: string }
+      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 HiveLogClient({
+        projectName: 'test-project',
+        projectUuid: testConfig.projectUuid
+        // Missing apiKey and apiSecret
+      })
+
+      const executionRecord = {
+        input: { value: 'test' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        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 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' as const,
+        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 HiveLogClient(testConfig)
+      const executionRecord = {
+        input: { value: 'test' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        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 HiveLogClient(testConfig)
+      const executionRecord = {
+        input: { value: 'test' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        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 HiveLogClient({ ...testConfig, metadata: baseMetadata })
+
+      const recordMetadata = { session: 'abc123' }
+      const sendLogMetadata = { priority: 'high' }
+
+      const executionRecord = {
+        input: { value: 'test' },
+        taskName: 'test-task',
+        type: 'success' as const,
+        boundaries: {},
+        metadata: recordMetadata
+      }
+
+      await client.sendLogByUuid(executionRecord, 'task-uuid-123', sendLogMetadata)
+
+      const callArgs = mockedAxios.post.mock.calls[0]
+      const requestBody = callArgs[1] as { projectUuid: string; taskUuid: string; logItem: string }
+      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)
+      })
+    })
+  })
+})