@minded-ai/mindedjs 1.0.96 → 1.0.97-beta-1236

package/src/platform/mindedConnection.ts

@@ -1,199 +0,0 @@
-import { io, Socket } from 'socket.io-client';
-import {
-  mindedConnectionSocketMessageType,
-  mindedConnectionSocketMessageTypeMap,
-} from './mindedConnectionTypes';
-import { stringify } from 'flatted';
-import { getConfig } from './config';
-import { logger } from '../utils/logger';
-import { wait } from '../utils/wait';
-
-// Module-level singleton state
-let socket: Socket | null = null;
-const listeners: {
-  [key: string]: ((message: any, callback: (response: any) => void) => void)[];
-} = {};
-
-export const isConnected = (): boolean => {
-  return socket?.connected ?? false;
-};
-
-export const on = <E extends keyof mindedConnectionSocketMessageTypeMap>(
-  event: E,
-  callback: (message: mindedConnectionSocketMessageTypeMap[E], callback: (response: any) => void) => void,
-) => {
-  if (!listeners[event]) {
-    listeners[event] = [];
-  }
-  listeners[event].push(callback);
-};
-
-export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(
-  event: E,
-  message: mindedConnectionSocketMessageTypeMap[E]
-) => {
-  if (socket) {
-    socket.emit(event, message);
-  }
-};
-
-export const awaitEmit = async <T, R>(
-  event: mindedConnectionSocketMessageType,
-  message: T,
-  timeoutMs: number = 5000
-): Promise<R> => {
-  if (!socket) {
-    throw new Error('Socket is not connected');
-  }
-
-  await waitForConnection();
-
-  return new Promise((resolve, reject) => {
-    // Set up timeout
-    const timeout = setTimeout(() => {
-      reject(new Error(`Acknowledgement timeout after ${timeoutMs}ms; event type: ${event}}`));
-    }, timeoutMs);
-
-    // Emit with acknowledgement callback
-    socket!.emit(event, stringify(message), (response: any) => {
-      clearTimeout(timeout);
-
-      // Check if the response indicates an error
-      if (response && response.error) {
-        reject(new Error(response.error));
-      } else {
-        resolve(response);
-      }
-    });
-  });
-};
-
-const waitForConnection = async (): Promise<void> => {
-  const timeout = 10000;
-  const interval = 100;
-  let cnt = 0;
-  while (!isConnected()) {
-    await wait(interval);
-    cnt += interval;
-    if (cnt > timeout) {
-      throw new Error('Minded connection timeout');
-    }
-  }
-};
-
-const connect = async (token: string): Promise<void> => {
-  const { isDeployed, baseUrl } = getConfig();
-  return new Promise<void>((resolve, reject) => {
-    socket = io(baseUrl, {
-      path: '/minded-connect',
-      query: {
-        isDeployedAgent: isDeployed,
-        token,
-      },
-    });
-
-    let connected = false;
-    let ready = false;
-
-    const checkReady = () => {
-      if (connected && ready) {
-        logger.info('\x1b[32mConnection with Minded platform is ready!\x1b[0m');
-        logger.info('\x1b[32mPress Ctrl+C to exit...');
-        resolve();
-      }
-    };
-
-    // Connection event handlers
-    socket.on('connect', () => {
-      logger.info('Socket connected, waiting for server setup...');
-      connected = true;
-      checkReady();
-    });
-
-    // Listen for ready event from server
-    socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-      logger.info('Server ready signal received', data);
-      ready = true;
-      checkReady();
-    });
-
-    socket.on('connect_error', () => {
-      logger.error('Failed to connect to minded platform');
-      reject(new Error('Failed to connect to minded platform'));
-    });
-
-    socket.on('disconnect', () => {
-      logger.info('Disconnected from local debugging socket');
-      connected = false;
-      ready = false;
-    });
-
-    // Listen for error messages from the server
-    socket.on('error', async (error: { message: string }) => {
-      logger.error({ msg: 'Server error:', error });
-
-      if (error.message.includes('Invalid token')) {
-        logger.info('Invalid token');
-
-        // Disconnect current socket
-        if (socket?.connected) {
-          socket.disconnect();
-        }
-
-        // Get new token and reconnect
-        await connect(token);
-      }
-    });
-
-    // Listen for specific message types
-    socket.onAny((event, message, callback) => {
-      if (listeners[event]) {
-        listeners[event].forEach((listener) => {
-          listener(message, callback);
-        });
-      } else {
-        console.warn({ message: 'No listeners found for event', event });
-      }
-    });
-
-    // Handle process termination
-    process.on('SIGINT', () => {
-      if (socket?.connected) {
-        logger.info('\nDisconnecting...');
-        socket.disconnect();
-      }
-      process.exit(0);
-    });
-  });
-};
-
-export const start = async (): Promise<void> => {
-  const { token } = getConfig();
-  if (!token) {
-    throw new Error('Minded token not found');
-  }
-  await connect(token);
-};
-
-export const disconnect = () => {
-  if (!socket) {
-    logger.warn('No socket connection to disconnect');
-    return;
-  }
-
-  if (socket.connected) {
-    logger.info('Disconnecting from Minded platform...');
-    socket.disconnect();
-    return;
-  }
-
-  logger.warn('Socket is already disconnected');
-};
-
-export const mindedConnection = {
-  isConnected,
-  on,
-  emit,
-  awaitEmit,
-  start,
-};

package/src/platform/mindedConnectionTypes.ts

@@ -1,191 +0,0 @@
-import type {
-  CheckpointListOptions,
-  CheckpointMetadata,
-  PendingWrite,
-  Checkpoint,
-  ChannelVersions,
-  CheckpointTuple,
-} from '@langchain/langgraph-checkpoint';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import { AgentInvokeParams } from '../types/Agent.types';
-
-export enum mindedConnectionSocketMessageType {
-  OnAppAction = 'on-app-action',
-  GET_SECRETS = 'get-secrets',
-  GET_FLOWS = 'get-flows',
-  GET_PLAYBOOKS = 'get-playbooks',
-  INVOKE = 'invoke',
-  PII_HTTP_REQUEST = 'pii-http-request',
-  // Checkpoints
-  CHECKPOINT_GET_TUPLE = 'checkpoint-get-tuple',
-  CHECKPOINT_PUT = 'checkpoint-put',
-  CHECKPOINT_LIST = 'checkpoint-list',
-  CHECKPOINT_PUT_WRITES = 'checkpoint-put-writes',
-  RESTORE_CHECKPOINT = 'restore-checkpoint',
-  // Voice
-  DASHBOARD_VOICE_USER_AUDIO = 'dashboard-voice-user-audio',
-  DASHBOARD_VOICE_AGENT_AUDIO = 'dashboard-voice-agent-audio',
-  DASHBOARD_VOICE_SESSION_START = 'dashboard-voice-session-start',
-  DASHBOARD_VOICE_SESSION_END = 'dashboard-voice-session-end',
-  DASHBOARD_VOICE_INTERRUPTION = 'dashboard-voice-interruption',
-  DASHBOARD_VOICE_PLACEHOLDER_MESSAGES = 'dashboard-voice-placeholder-messages',
-  INTERFACE_FUNCTION_CALL = 'interface-function-call',
-  TIMER_RESET = 'timer-reset',
-  TIMER_CANCEL = 'timer-cancel',
-  TIMER_TRIGGER = 'timer-trigger',
-}
-
-export type mindedConnectionSocketMessageTypeMap = {
-  [mindedConnectionSocketMessageType.OnAppAction]: BasemindedConnectionSocketMessage;
-  [mindedConnectionSocketMessageType.GET_SECRETS]: BasemindedConnectionSocketMessage;
-  [mindedConnectionSocketMessageType.GET_FLOWS]: BasemindedConnectionSocketMessage;
-  [mindedConnectionSocketMessageType.GET_PLAYBOOKS]: BasemindedConnectionSocketMessage;
-  [mindedConnectionSocketMessageType.INVOKE]: InvokeMessage;
-  [mindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE]: OnCheckpointGetTuple;
-  [mindedConnectionSocketMessageType.CHECKPOINT_PUT]: OnCheckpointPut;
-  [mindedConnectionSocketMessageType.CHECKPOINT_LIST]: OnCheckpointList;
-  [mindedConnectionSocketMessageType.CHECKPOINT_PUT_WRITES]: OnCheckpointPutWrites;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_USER_AUDIO]: OnVoiceAudioIn;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_AGENT_AUDIO]: OnVoiceAudioOut;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_START]: BaseVoiceMessage;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END]: OnVoiceSessionEnd;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_INTERRUPTION]: OnVoiceInterruption;
-  [mindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES]: VoicePlaceholderMessage;
-  [mindedConnectionSocketMessageType.PII_HTTP_REQUEST]: OnPiiHttpRequest;
-  [mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL]: InterfaceFunctionCall;
-  [mindedConnectionSocketMessageType.TIMER_RESET]: TimerResetRequest;
-  [mindedConnectionSocketMessageType.TIMER_CANCEL]: TimerCancelRequest;
-  [mindedConnectionSocketMessageType.TIMER_TRIGGER]: TimerTriggerRequest;
-  [mindedConnectionSocketMessageType.RESTORE_CHECKPOINT]: RestoreCheckpointRequest;
-};
-
-export interface BasemindedConnectionSocketMessage {
-  type: mindedConnectionSocketMessageType;
-}
-
-export interface BaseSdkConnectionSocketMessageResponseCallbackAck {
-  error?: string;
-}
-
-export interface OnCheckpointPut extends BasemindedConnectionSocketMessage {
-  config: RunnableConfig;
-  checkpoint: Checkpoint;
-  metadata: CheckpointMetadata;
-  newVersions: ChannelVersions;
-}
-
-export interface OnCheckpointPutResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  config: RunnableConfig;
-}
-export interface OnCheckpointPutWrites extends BasemindedConnectionSocketMessage {
-  config: RunnableConfig;
-  writes: PendingWrite[];
-  taskId: string;
-}
-
-export interface OnCheckpointGetTupleResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  tuple?: CheckpointTuple | undefined;
-}
-
-export interface OnCheckpointGetTuple extends BasemindedConnectionSocketMessage {
-  config: RunnableConfig;
-}
-
-export interface OnCheckpointList extends BasemindedConnectionSocketMessage {
-  config: RunnableConfig;
-  options?: CheckpointListOptions;
-}
-
-export interface OnCheckpointListResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  checkpoints?: CheckpointTuple[];
-}
-
-export interface BaseVoiceMessage extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  timestamp: number;
-}
-
-// Voice/Audio event interfaces
-export interface OnVoiceAudioIn extends BaseVoiceMessage {
-  audioData: string; // base64 encoded audio data
-}
-
-export interface OnVoiceAudioOut extends BaseVoiceMessage {
-  audioData: string; // base64 encoded audio data
-}
-
-export interface VoicePlaceholderMessage extends BaseVoiceMessage {
-  message: string;
-}
-
-export interface OnVoiceInterruption extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  timestamp: number;
-}
-export interface OnVoiceSessionEnd extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  timestamp: number;
-}
-
-export interface InvokeMessage extends BasemindedConnectionSocketMessage, AgentInvokeParams {
-  type: mindedConnectionSocketMessageType.INVOKE;
-}
-export interface OnPiiHttpRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  requestId: string;
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-  url: string;
-  headers?: Record<string, string>;
-  params?: Record<string, any>;
-  data?: any;
-}
-
-export interface OnPiiHttpResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  requestId: string;
-  data?: any;
-  status?: number;
-  statusText?: string;
-  headers?: Record<string, string>;
-}
-
-export interface InterfaceFunctionCall extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  interfaceName: string;
-  functionName: string;
-  functionArgs: Record<string, any>;
-}
-
-export interface TimerResetRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  seconds: number;
-  timerName: string;
-  eventArgs: Record<string, any>;
-}
-
-export interface TimerResetResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  success?: boolean;
-}
-
-export interface TimerCancelRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  timerName: string;
-}
-
-export interface TimerCancelResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  success?: boolean;
-}
-
-export interface TimerTriggerRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  timerName: string;
-  eventArgs: Record<string, any>;
-}
-
-export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
-  sessionId: string;
-  checkpointId: string;
-}
-
-export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
-  success?: boolean;
-}

package/src/platform/piiGateway/gateway.ts

@@ -1,103 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import * as mindedConnection from '../mindedConnection';
-import { mindedConnectionSocketMessageType, OnPiiHttpRequest, OnPiiHttpResponse } from '../mindedConnectionTypes';
-import { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
-import { logger } from '../../utils/logger';
-
-export class PIIGateway implements PIIGatewayInstance {
-  constructor() {
-    // No longer needs mindedConnection as parameter
-  }
-
-  private async makeRequest<T = any>(
-    sessionId: string,
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS',
-    url: string,
-    data?: any,
-    config?: HttpRequestConfig,
-  ): Promise<HttpResponse<T>> {
-    if (!mindedConnection.isConnected()) {
-      throw new Error('Minded connection is not established. PII-secured HTTP requests require a connection to the Minded platform.');
-    }
-
-    try {
-      const requestId = uuidv4();
-      const requestPayload: OnPiiHttpRequest = {
-        type: mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
-        requestId,
-        method,
-        url,
-        headers: config?.headers as Record<string, string>,
-        params: config?.params,
-        data,
-        sessionId,
-      };
-
-      const response = await mindedConnection.awaitEmit<OnPiiHttpRequest, OnPiiHttpResponse>(
-        mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
-        requestPayload,
-        30000, // 30 second timeout for HTTP requests
-      );
-
-      if (response.error) {
-        throw new Error(`HTTP request failed: ${response.error}`);
-      }
-
-      // Verify that the response requestId matches our request
-      if (response.requestId && response.requestId !== requestId) {
-        logger.warn(`Response requestId (${response.requestId}) does not match request requestId (${requestId})`);
-      }
-
-      // Return generic HttpResponse format
-      return {
-        data: response.data,
-        status: response.status || 200,
-        statusText: response.statusText || 'OK',
-        headers: response.headers || {},
-        config: config || {},
-      };
-    } catch (error) {
-      logger.error({ msg: 'Secure HTTP request failed', error });
-      return {
-        data: undefined as T,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: {},
-        config: config || {},
-      };
-    }
-  }
-
-  async get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'GET', url, undefined, config);
-  }
-
-  async post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'POST', url, data, config);
-  }
-
-  async put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'PUT', url, data, config);
-  }
-
-  async delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'DELETE', url, undefined, config);
-  }
-
-  async patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'PATCH', url, data, config);
-  }
-
-  async head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'HEAD', url, undefined, config);
-  }
-
-  async options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'OPTIONS', url, undefined, config);
-  }
-
-  async request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>> {
-    const method = (config.method?.toUpperCase() || 'GET') as any;
-    return this.makeRequest<T>(sessionId, method, config.url || '', config.data, config);
-  }
-}

package/src/platform/piiGateway/index.ts

@@ -1,5 +0,0 @@
-// Export types
-export type { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
-
-// Export core gateway class and creation function
-export { PIIGateway } from './gateway';

package/src/platform/piiGateway/types.ts

@@ -1,29 +0,0 @@
-// Generic HTTP types (library-agnostic)
-export interface HttpRequestConfig {
-  method?: string;
-  url?: string;
-  headers?: Record<string, string>;
-  params?: Record<string, any>;
-  data?: any;
-  timeout?: number;
-  [key: string]: any; // Allow additional properties for extensibility
-}
-
-export interface HttpResponse<T = any> {
-  data: T;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-  config: HttpRequestConfig;
-}
-
-export interface PIIGatewayInstance {
-  get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>>;
-}