@ziggs-ai/api-client 0.1.3 → 0.1.4

package/src/http/TelemetryClient.js

@@ -1,43 +0,0 @@
-import 'dotenv/config';
-import { getBackendUrl } from '../utils/urlUtils.js';
-
-export class TelemetryClient {
-  constructor(operatorKey, agentId) {
-    if (!operatorKey) throw new Error('TelemetryClient: operatorKey is required');
-    if (!agentId) throw new Error('TelemetryClient: agentId is required (operator-token impersonation)');
-    this.operatorKey = operatorKey;
-    this.agentId = agentId;
-    this._queue = [];
-    this._flushing = false;
-  }
-
-  async send(payload) {
-    this._queue.push(payload);
-    if (!this._flushing) this._flush();
-  }
-
-  async _flush() {
-    this._flushing = true;
-    while (this._queue.length > 0) {
-      const batch = this._queue.splice(0, 10);
-      await Promise.allSettled(batch.map((p) => this._post(p)));
-    }
-    this._flushing = false;
-  }
-
-  async _post(payload) {
-    try {
-      await fetch(`${getBackendUrl()}/agents/monitoring/ingest`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'Authorization': `Bearer ${this.operatorKey}`,
-          'X-Agent-Id': this.agentId,
-        },
-        body: JSON.stringify({ payload }),
-      });
-    } catch (err) {
-      console.warn(`[Telemetry] ingest failed: ${err.message}`);
-    }
-  }
-}

package/src/http/index.js

@@ -1,6 +0,0 @@
-// HTTP API Clients
-export * from './TaskClient.js';
-export { ContextReader } from './ContextReader.js';
-export { ContextWriter } from './ContextWriter.js';
-export { AgentSearchClient } from './AgentSearchClient.js';
-export { TelemetryClient } from './TelemetryClient.js';

package/src/types.js

@@ -1,28 +0,0 @@
-/**
- * Type constants for the Ziggs API
- * These types are used when interacting with the backend timeline/history API
- */
-
-// Entry Types (entryType) - The kind of timeline entry
-export const EntryTypes = {
-  MESSAGE: 'message',
-  NOTIFICATION: 'notification',
-  ARTIFACT: 'artifact',
-  TASK_HISTORY: 'task_history',
-};
-
-// Content Types (content_type) - The type of content within an entry
-export const ContentTypes = {
-  TEXT: 'text',
-  OPERATION: 'operation',
-  CONTEXT: 'context',
-  RESULT: 'result',
-  TASK_UPDATE: 'task_update',
-  THOUGHT: 'thought',
-};
-
-/**
- * Open ledger proposals: proposal.proposedTo === this value means any agent can claim (approve).
- * ⚠️  SYNC: Keep in sync with backend/src/tasks/task-core.ts and agent-sdk/src/tasks/taskCore.js
- */
-export const OPEN_PROPOSAL_TARGET = 'everyone';

package/src/utils/urlUtils.js

@@ -1,17 +0,0 @@
-/**
- * Gets the HTTP backend URL from HTTP_URL env var or defaults to api.ziggsai.com
- */
-export function getBackendUrl() {
-  const url = process.env.HTTP_URL || 'https://api.ziggsai.com';
-  // Ensure it has a protocol
-  return url.startsWith('http') ? url : `https://${url}`;
-}
-
-/**
- * Gets the WebSocket URL from WS_URL env var or defaults to wss://api.ziggsai.com
- */
-export function getWebSocketUrl() {
-  const wsUrl = process.env.WS_URL || 'wss://api.ziggsai.com';
-  // Ensure it has a protocol
-  return wsUrl.startsWith('ws') ? wsUrl : `wss://${wsUrl}`;
-}

package/src/websocket/ControlSocket.js

@@ -1,55 +0,0 @@
-import { io } from 'socket.io-client';
-
-/**
- * createControlSocket — raw launcher-control protocol.
- *
- * Opens a single WebSocket to the backend identified as `role=launcher`, sends
- * `launcher:register { agentIds }` on every connect, and invokes `onWake(id)`
- * when the backend pushes a `launcher:wake { agentId }` frame.
- *
- * This is the minimum a non-SDK integrator needs in order to participate in
- * the "agents are available" story. Drop-in for other languages by mirroring
- * the three frames: connect with `?role=launcher`, emit `launcher:register`,
- * handle `launcher:wake`.
- *
- * @param {object}   opts
- * @param {string}   opts.wsUrl                    Backend WebSocket URL
- * @param {string}   opts.operatorKey              Operator key (JWT) with `launcher` scope.
- * @param {() => string[]} opts.agentIds           Returns the current registered agentIds; called on every (re)connect
- * @param {(agentId: string) => void} opts.onWake  Invoked when the backend requests a wake
- * @returns {{ close: () => void, resync: () => void, socket: import('socket.io-client').Socket }}
- */
-export function createControlSocket({ wsUrl, operatorKey, agentIds, onWake }) {
-  if (!wsUrl || !operatorKey) throw new Error('[createControlSocket] wsUrl and operatorKey are required');
-  if (typeof agentIds !== 'function') throw new Error('[createControlSocket] agentIds must be a function returning string[]');
-  if (typeof onWake !== 'function') throw new Error('[createControlSocket] onWake must be a function');
-
-  const socket = io(wsUrl, {
-    auth: { token: `Bearer ${operatorKey}` },
-    query: { token: operatorKey, role: 'launcher' },
-    extraHeaders: { Authorization: `Bearer ${operatorKey}` },
-    transports: ['websocket'],
-    reconnection: true,
-    reconnectionDelay: 1000,
-    reconnectionDelayMax: 5000,
-  });
-
-  socket.on('connect', () => {
-    const ids = agentIds();
-    console.log(`[ControlSocket] connected (${socket.id}); registering ${ids.length} agent(s)`);
-    socket.emit('launcher:register', { agentIds: ids });
-  });
-
-  socket.on('launcher:wake', ({ agentId }) => {
-    if (agentId) onWake(agentId);
-  });
-
-  socket.on('disconnect', (reason) => console.log(`[ControlSocket] disconnected: ${reason}`));
-  socket.on('connect_error', (err) => console.warn(`[ControlSocket] connect error: ${err.message}`));
-
-  return {
-    socket,
-    close: () => socket.disconnect(),
-    resync: () => { if (socket.connected) socket.emit('launcher:register', { agentIds: agentIds() }); },
-  };
-}

package/src/websocket/WebSocketClient.js

@@ -1,318 +0,0 @@
-import { io } from "socket.io-client";
-import 'dotenv/config';
-import { getWebSocketUrl } from '../utils/urlUtils.js';
-
-class SessionState {
-  constructor() {
-    this.chatId = null;
-    this.userId = null;
-  }
-
-  updateFromPayload(payload) {
-
-    if (!payload || typeof payload !== 'object') {
-      throw new Error('SessionState.updateFromPayload: payload must be an object');
-    }
-
-    if (payload.chatId) {
-      if (typeof payload.chatId !== 'string') {
-        throw new Error('SessionState.updateFromPayload: chatId must be a string');
-      }
-      this.chatId = payload.chatId;
-    }
-
-    if (payload.senderId) {
-      if (typeof payload.senderId !== 'string') {
-        throw new Error('SessionState.updateFromPayload: senderId must be a string');
-      }
-      this.userId = payload.senderId;
-    }
-  }
-
-  isReady() {
-    return !!(this.userId && this.chatId);
-  }
-
-  reset() {
-    this.chatId = null;
-    this.userId = null;
-  }
-
-  getMetadata() {
-    return {
-      chatId: this.chatId,
-      userId: this.userId
-    };
-  }
-}
-
-export class WebSocketClient {
-  constructor(options = {}) {
-    this.wsUrl = options.wsUrl || getWebSocketUrl();
-    this.operatorKey = options.operatorKey || process.env.ZIGGS_OPERATOR_KEY || null;
-    this.agentId = options.agentId || null;
-    this.label = options.label || 'agent';
-    this.agentName = options.name || null;
-    this.sessionState = new SessionState();
-    this.socket = null;
-    this.messageHandler = null;
-    this.sessionOperationLimit = options.sessionOperationLimit ?? 30;
-    // Per-chat operation counters — keyed by chatId to avoid cross-session interference
-    this.operationCounts = new Map();
-  }
-
-  setMessageHandler(handler) {
-    this.messageHandler = handler;
-  }
-
-  connect() {
-    if (this.socket?.connected) {
-      return;
-    }
-
-    console.log(`[${this.label}] Connecting to ${this.wsUrl}`);
-    const socketOptions = this.buildSocketOptions();
-    this.socket = io(this.wsUrl, socketOptions);
-
-    this.socket.on('connect', () => {
-      console.log(`[${this.label}] Connected`);
-    });
-
-    this.socket.on('connect_error', (error) => {
-      console.error(`[${this.label}] Connection error: ${error.message}`);
-    });
-
-    this.socket.on('disconnect', (reason) => {
-      const reasonDescriptions = {
-        'io server disconnect': 'Server forcefully disconnected the client',
-        'io client disconnect': 'Client manually disconnected',
-        'ping timeout': 'Server did not respond to ping (connection timeout)',
-        'transport close': 'Connection closed by transport layer',
-        'transport error': 'Transport error occurred',
-        'parse error': 'Error parsing server message',
-        'forced close': 'Connection was forcibly closed',
-        'forced server close': 'Server forcibly closed the connection'
-      };
-
-      const description = reasonDescriptions[reason] || 'Unknown disconnect reason';
-      console.log(`[${this.label}] Disconnected: ${reason} — ${description}`);
-
-      if (reason === 'io server disconnect') {
-        console.log(`[${this.label}] Server disconnected — resetting session state`);
-        this.sessionState.reset();
-        this.operationCounts.clear();
-      }
-    });
-
-    this.socket.on('messages', async (payload) => {
-      try {
-        await this.handleIncomingMessage(payload);
-      } catch (error) {
-        console.error(`[${this.label}] Error handling incoming message:`, error.message);
-        throw error;
-      }
-    });
-
-    this.socket.on('error', (error) => {
-      console.error(`[${this.label}] Socket.IO error:`, error);
-    });
-  }
-
-  connectAsync(timeout = 10_000) {
-    if (this.socket?.connected) return Promise.resolve(this);
-    return new Promise((resolve, reject) => {
-      this.connect();
-      const timer = setTimeout(
-        () => reject(new Error(`[${this.label}] Connection timeout after ${timeout}ms`)),
-        timeout
-      );
-      this.socket.once('connect', () => { clearTimeout(timer); resolve(this); });
-      this.socket.once('connect_error', (err) => { clearTimeout(timer); reject(err); });
-    });
-  }
-
-  disconnect() {
-    if (this.socket) {
-      this.socket.disconnect();
-      this.socket = null;
-    }
-  }
-
-  sendResponse(content, options = {}) {
-
-    if (typeof content !== 'string' || content.trim().length === 0) {
-      throw new Error('sendResponse: content must be a non-empty string');
-    }
-
-    const explicitReceiver = options.receiverId;
-    const receiver = explicitReceiver || this.sessionState.userId;
-
-    if (!receiver || typeof receiver !== 'string') {
-      throw new Error('sendResponse: receiver is required (provide via options.receiverId or ensure session state has userId)');
-    }
-
-    if (!explicitReceiver) {
-      console.warn(`[${this.label}] sendResponse: no receiverId in options, falling back to sessionState.userId (${receiver}) — pass receiverId explicitly to avoid cross-chat races`);
-    }
-
-    const explicitChatId = options.chatId;
-    const chatId = explicitChatId || this.sessionState.chatId;
-
-    if (!chatId) {
-      throw new Error('sendResponse: chatId is required (provide via options.chatId or ensure session state has chatId)');
-    }
-
-    if (!explicitChatId) {
-      console.warn(`[${this.label}] sendResponse: no chatId in options, falling back to sessionState.chatId (${chatId}) — pass chatId explicitly to avoid cross-chat races`);
-    }
-
-    if (!this.socket) {
-      throw new Error('sendResponse: socket is not initialized. Call connect() first.');
-    }
-    if (!this.socket.connected) {
-      throw new Error('sendResponse: socket is not connected. Call connect() and wait for connection.');
-    }
-
-    const messageId = this.generateMessageId();
-    if (!messageId || typeof messageId !== 'string') {
-      throw new Error('sendResponse: failed to generate valid messageId');
-    }
-
-    // Backend socket handler requires entryType + content_type (same as frontend useMessages).
-    const message = {
-      receiverId: receiver,
-      chatId,
-      messageId: messageId,
-      text: content,
-      entryType: options.entryType || 'message',
-      content_type: options.content_type || options.contentType || 'text'
-    };
-
-    // Add service object with task if taskId provided
-    if (options.taskId) {
-      message.service = { task: { taskId: options.taskId } };
-    }
-
-    if (!message.receiverId || !message.chatId || !message.messageId || !message.text) {
-      throw new Error('sendResponse: message validation failed - missing required fields');
-    }
-
-    const messagePreview = content.length > 100 ? content.substring(0, 100) + '...' : content;
-    console.log(`📤 Sending message - chatId: ${message.chatId}, receiverId: ${message.receiverId}${options.receiverId ? ' (routed)' : ' (default)'}\n   Message: ${messagePreview}`);
-
-    this.socket.emit('chat', message);
-  }
-
-  getSessionMetadata() {
-    return this.sessionState.getMetadata();
-  }
-
-  isConnected() {
-    return this.socket?.connected || false;
-  }
-
-  isSessionReady() {
-    return this.sessionState.isReady();
-  }
-
-  async handleIncomingMessage(payload) {
-
-    if (!payload || typeof payload !== 'object') {
-      throw new Error('handleIncomingMessage: payload must be an object');
-    }
-
-    if (!payload.text || typeof payload.text !== 'string' || payload.text.trim().length === 0) {
-      throw new Error('handleIncomingMessage: payload.text is required and must be a non-empty string');
-    }
-
-    if (!payload.chatId || typeof payload.chatId !== 'string') {
-      throw new Error('handleIncomingMessage: payload.chatId is required and must be a string');
-    }
-
-    // Extract sender info from new format: sender is { id, type } object
-    const senderId = payload.sender?.id;
-    const senderType = payload.sender?.type;
-
-    if (!senderId || typeof senderId !== 'string') {
-      throw new Error('handleIncomingMessage: payload.sender.id is required and must be a string');
-    }
-
-    console.log(`📥 Received message - chatId: ${payload.chatId}, sender: ${senderId} (${senderType})`);
-
-    // Ignore own messages to prevent infinite loops
-    if (this.agentId && senderId === this.agentId) {
-      return;
-    }
-
-    // Update session state with extracted senderId (last-seen, for backward compat)
-    this.sessionState.updateFromPayload({ chatId: payload.chatId, senderId });
-
-    // Enforce per-chat operation limit to prevent infinite loops
-    const chatOpCount = (this.operationCounts.get(payload.chatId) || 0) + 1;
-    this.operationCounts.set(payload.chatId, chatOpCount);
-    if (chatOpCount > this.sessionOperationLimit) {
-      console.warn(`⚠️ Session operation limit (${this.sessionOperationLimit}) reached for chatId: ${payload.chatId}. Dropping message.`);
-      await this.sendResponse(
-        'This session has reached its operation limit. Please start a new conversation.',
-        { receiverId: senderId, chatId: payload.chatId }
-      );
-      return;
-    }
-
-    const text = payload.text;
-
-    if (!this.messageHandler) {
-      throw new Error('handleIncomingMessage: messageHandler is not set. Call setMessageHandler() first.');
-    }
-
-    const metadata = {
-      chatId: payload.chatId,
-      userId: senderId,
-      sender: payload.sender,
-      senderId: senderId,
-      senderType: senderType,
-      receiver: payload.receiver || null,
-      receiverId: payload.receiver?.id || null,
-      entryType: payload.entryType,
-      content_type: payload.content_type,
-      service: payload.service || null,
-      taskId: payload.service?.task?.taskId || null
-    };
-
-    await this.messageHandler(text, metadata);
-  }
-
-  buildSocketOptions() {
-    const options = {
-      transports: ["websocket"],
-      reconnection: true,
-      reconnectionAttempts: Infinity,
-      reconnectionDelay: 1000,
-      reconnectionDelayMax: 5000,
-      timeout: 20000,
-      autoConnect: true,
-      forceNew: false,
-      multiplex: true,
-    };
-
-    if (this.operatorKey) {
-      const bearer = `Bearer ${this.operatorKey}`;
-      // Send token in multiple ways for maximum compatibility:
-      // 1. Auth object (Socket.IO native)
-      options.auth = { token: bearer };
-      if (this.agentName) options.auth.agentName = this.agentName;
-      // 2. Extra headers (works for direct connections)
-      options.extraHeaders = { Authorization: bearer };
-      // 3. Query parameter (works when proxies strip headers, e.g., Cloud Load Balancer)
-      options.query = { token: bearer };
-      if (this.agentId) options.query.agentId = this.agentId;
-      if (this.agentName) options.query.agentName = this.agentName;
-    }
-
-    return options;
-  }
-
-  generateMessageId() {
-    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-}