agentxjs 1.9.0 → 1.9.2-dev

package/build.ts

@@ -0,0 +1,26 @@
+/**
+ * Build script for agentxjs
+ *
+ * Generates dist/ with JS and .d.ts files
+ */
+
+import { $ } from "bun";
+
+console.log("Building agentxjs...");
+
+// Clean dist
+await $`rm -rf dist`;
+
+// Generate .d.ts using tsc
+await $`tsc --emitDeclarationOnly --outDir dist`;
+
+// Build with bun
+await Bun.build({
+  entrypoints: ["./src/index.ts"],
+  outdir: "./dist",
+  format: "esm",
+  target: "node",
+  sourcemap: "external",
+});
+
+console.log("Build complete!");

package/package.json

@@ -1,49 +1,30 @@
 {
   "name": "agentxjs",
-  "version": "1.9.0",
-  "description": "Unified API for AI Agents - Server and Browser",
+  "version": "1.9.2-dev",
+  "description": "AgentX Client SDK - Connect to AgentX servers",
   "license": "MIT",
-  "engines": {
-    "node": ">=22.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Deepractice/AgentX.git"
-  },
-  "homepage": "https://github.com/Deepractice/AgentX",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "browser": "./dist/browser.js",
-      "node": "./dist/index.js",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
     }
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "bun run build.ts",
-    "clean": "rm -rf dist test-results",
-    "lint": "eslint .",
     "typecheck": "tsc --noEmit",
-    "test": "bun test",
-    "test:watch": "bun test --watch"
+    "test": "bun test"
   },
   "dependencies": {
-    "@agentxjs/common": "^1.9.0",
-    "@agentxjs/network": "^1.9.0",
-    "@agentxjs/types": "^1.9.0",
+    "@agentxjs/core": "workspace:*",
     "reconnecting-websocket": "^4.4.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
-    "@agentxjs/persistence": "^1.9.0",
-    "@agentxjs/queue": "^1.9.0",
-    "@agentxjs/runtime": "^1.9.0"
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.3"
   },
   "publishConfig": {
     "access": "public"

package/src/RemoteClient.ts

@@ -0,0 +1,221 @@
+/**
+ * RemoteClient - AgentX client for remote server
+ *
+ * Uses RpcClient from @agentxjs/core/network for JSON-RPC communication.
+ * This class focuses on business logic, not protocol details.
+ */
+
+import type { BusEvent, EventBus, BusEventHandler, Unsubscribe } from "@agentxjs/core/event";
+import { EventBusImpl } from "@agentxjs/core/event";
+import { RpcClient, type RpcMethod } from "@agentxjs/core/network";
+import { createLogger } from "commonxjs/logger";
+import type {
+  AgentX,
+  AgentXConfig,
+  AgentCreateResponse,
+  AgentGetResponse,
+  AgentListResponse,
+  ImageCreateResponse,
+  ImageGetResponse,
+  ImageListResponse,
+  ContainerCreateResponse,
+  ContainerGetResponse,
+  ContainerListResponse,
+  MessageSendResponse,
+  BaseResponse,
+} from "./types";
+import { Presentation, type PresentationOptions } from "./presentation";
+
+const logger = createLogger("agentx/RemoteClient");
+
+/**
+ * RemoteClient implementation using JSON-RPC 2.0
+ */
+export class RemoteClient implements AgentX {
+  private readonly config: AgentXConfig;
+  private readonly eventBus: EventBus;
+  private readonly rpcClient: RpcClient;
+
+  constructor(config: AgentXConfig) {
+    this.config = config;
+    this.eventBus = new EventBusImpl();
+
+    // Create RPC client
+    this.rpcClient = new RpcClient({
+      url: config.serverUrl,
+      timeout: config.timeout ?? 30000,
+      autoReconnect: config.autoReconnect ?? true,
+      headers: config.headers as Record<string, string> | undefined,
+      debug: false,
+    });
+
+    // Forward stream events to internal event bus
+    this.rpcClient.onStreamEvent((topic, event) => {
+      logger.debug("Received stream event", { topic, type: event.type });
+      this.eventBus.emit(event as BusEvent);
+    });
+  }
+
+  // ==================== Properties ====================
+
+  get connected(): boolean {
+    return this.rpcClient.connected;
+  }
+
+  get events(): EventBus {
+    return this.eventBus;
+  }
+
+  // ==================== Connection ====================
+
+  async connect(): Promise<void> {
+    await this.rpcClient.connect();
+    logger.info("Connected to server", { url: this.config.serverUrl });
+  }
+
+  async disconnect(): Promise<void> {
+    this.rpcClient.disconnect();
+    logger.info("Disconnected from server");
+  }
+
+  async dispose(): Promise<void> {
+    this.rpcClient.dispose();
+    this.eventBus.destroy();
+    logger.info("RemoteClient disposed");
+  }
+
+  // ==================== Container Operations ====================
+
+  async createContainer(containerId: string): Promise<ContainerCreateResponse> {
+    const result = await this.rpcClient.call<ContainerCreateResponse>("container.create", {
+      containerId,
+    });
+    return { ...result, requestId: "" };
+  }
+
+  async getContainer(containerId: string): Promise<ContainerGetResponse> {
+    const result = await this.rpcClient.call<ContainerGetResponse>("container.get", {
+      containerId,
+    });
+    return { ...result, requestId: "" };
+  }
+
+  async listContainers(): Promise<ContainerListResponse> {
+    const result = await this.rpcClient.call<ContainerListResponse>("container.list", {});
+    return { ...result, requestId: "" };
+  }
+
+  // ==================== Image Operations ====================
+
+  async createImage(params: {
+    containerId: string;
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+    mcpServers?: Record<string, unknown>;
+  }): Promise<ImageCreateResponse> {
+    const result = await this.rpcClient.call<ImageCreateResponse>("image.create", params);
+
+    // Auto subscribe to session events
+    if (result.__subscriptions) {
+      for (const sessionId of result.__subscriptions) {
+        this.subscribe(sessionId);
+      }
+    }
+
+    return { ...result, requestId: "" };
+  }
+
+  async getImage(imageId: string): Promise<ImageGetResponse> {
+    const result = await this.rpcClient.call<ImageGetResponse>("image.get", { imageId });
+
+    // Auto subscribe
+    if (result.__subscriptions) {
+      for (const sessionId of result.__subscriptions) {
+        this.subscribe(sessionId);
+      }
+    }
+
+    return { ...result, requestId: "" };
+  }
+
+  async listImages(containerId?: string): Promise<ImageListResponse> {
+    const result = await this.rpcClient.call<ImageListResponse>("image.list", { containerId });
+
+    // Auto subscribe
+    if (result.__subscriptions) {
+      for (const sessionId of result.__subscriptions) {
+        this.subscribe(sessionId);
+      }
+    }
+
+    return { ...result, requestId: "" };
+  }
+
+  async deleteImage(imageId: string): Promise<BaseResponse> {
+    const result = await this.rpcClient.call<BaseResponse>("image.delete", { imageId });
+    return { ...result, requestId: "" };
+  }
+
+  // ==================== Agent Operations ====================
+
+  async createAgent(params: { imageId: string; agentId?: string }): Promise<AgentCreateResponse> {
+    // Agent creation via image.run RPC
+    const result = await this.rpcClient.call<AgentCreateResponse>("image.run" as RpcMethod, {
+      imageId: params.imageId,
+      agentId: params.agentId,
+    });
+    return { ...result, requestId: "" };
+  }
+
+  async getAgent(agentId: string): Promise<AgentGetResponse> {
+    const result = await this.rpcClient.call<AgentGetResponse>("agent.get", { agentId });
+    return { ...result, requestId: "" };
+  }
+
+  async listAgents(containerId?: string): Promise<AgentListResponse> {
+    const result = await this.rpcClient.call<AgentListResponse>("agent.list", { containerId });
+    return { ...result, requestId: "" };
+  }
+
+  async destroyAgent(agentId: string): Promise<BaseResponse> {
+    const result = await this.rpcClient.call<BaseResponse>("agent.destroy", { agentId });
+    return { ...result, requestId: "" };
+  }
+
+  // ==================== Message Operations ====================
+
+  async sendMessage(agentId: string, content: string | unknown[]): Promise<MessageSendResponse> {
+    const result = await this.rpcClient.call<MessageSendResponse>("message.send", {
+      agentId,
+      content,
+    });
+    return { ...result, requestId: "" };
+  }
+
+  async interrupt(agentId: string): Promise<BaseResponse> {
+    const result = await this.rpcClient.call<BaseResponse>("agent.interrupt", { agentId });
+    return { ...result, requestId: "" };
+  }
+
+  // ==================== Event Subscription ====================
+
+  on<T extends string>(type: T, handler: BusEventHandler<BusEvent & { type: T }>): Unsubscribe {
+    return this.eventBus.on(type, handler);
+  }
+
+  onAny(handler: BusEventHandler): Unsubscribe {
+    return this.eventBus.onAny(handler);
+  }
+
+  subscribe(sessionId: string): void {
+    this.rpcClient.subscribe(sessionId);
+    logger.debug("Subscribed to session", { sessionId });
+  }
+
+  // ==================== Presentation ====================
+
+  presentation(agentId: string, options?: PresentationOptions): Presentation {
+    return new Presentation(this, agentId, options);
+  }
+}

package/src/index.ts

@@ -0,0 +1,118 @@
+/**
+ * agentxjs - AgentX Client SDK
+ *
+ * Connect to AgentX servers from Node.js and browsers.
+ *
+ * @example
+ * ```typescript
+ * import { createAgentX } from "agentxjs";
+ *
+ * // Connect to server
+ * const agentx = await createAgentX({
+ *   serverUrl: "ws://localhost:5200",
+ *   headers: { Authorization: "Bearer sk-xxx" },
+ *   context: { userId: "123", tenantId: "abc" },
+ * });
+ *
+ * // Create container and image
+ * await agentx.createContainer("my-container");
+ * const { record: image } = await agentx.createImage({
+ *   containerId: "my-container",
+ *   name: "Assistant",
+ *   systemPrompt: "You are a helpful assistant",
+ * });
+ *
+ * // Create agent and send message
+ * const { agentId } = await agentx.createAgent({ imageId: image.imageId });
+ *
+ * // Subscribe to events
+ * agentx.on("text_delta", (event) => {
+ *   process.stdout.write(event.data.text);
+ * });
+ *
+ * agentx.on("assistant_message", (event) => {
+ *   console.log("Complete:", event.data.content);
+ * });
+ *
+ * // Send message
+ * await agentx.sendMessage(agentId, "Hello!");
+ *
+ * // Cleanup
+ * await agentx.dispose();
+ * ```
+ *
+ * @example Dynamic headers and context
+ * ```typescript
+ * const agentx = await createAgentX({
+ *   serverUrl: "ws://localhost:5200",
+ *   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
+ *   context: async () => ({
+ *     userId: await getUserId(),
+ *     permissions: await getPermissions(),
+ *   }),
+ * });
+ * ```
+ */
+
+import { RemoteClient } from "./RemoteClient";
+import type { AgentX, AgentXConfig } from "./types";
+
+/**
+ * Create an AgentX client
+ *
+ * @param config - Client configuration
+ * @returns Connected AgentX client
+ */
+export async function createAgentX(config: AgentXConfig): Promise<AgentX> {
+  const client = new RemoteClient(config);
+  await client.connect();
+  return client;
+}
+
+// Re-export types
+export type {
+  AgentX,
+  AgentXConfig,
+  MaybeAsync,
+  AgentInfo,
+  ImageRecord,
+  ContainerInfo,
+  AgentCreateResponse,
+  AgentGetResponse,
+  AgentListResponse,
+  ImageCreateResponse,
+  ImageGetResponse,
+  ImageListResponse,
+  ContainerCreateResponse,
+  ContainerGetResponse,
+  ContainerListResponse,
+  MessageSendResponse,
+  BaseResponse,
+} from "./types";
+
+// Re-export RemoteClient for advanced use
+export { RemoteClient } from "./RemoteClient";
+
+// Re-export Presentation types and classes
+export type {
+  Block,
+  TextBlock,
+  ToolBlock,
+  ImageBlock,
+  Conversation,
+  UserConversation,
+  AssistantConversation,
+  ErrorConversation,
+  PresentationState,
+  PresentationOptions,
+  PresentationUpdateHandler,
+  PresentationErrorHandler,
+} from "./presentation";
+
+export {
+  Presentation,
+  presentationReducer,
+  addUserConversation,
+  createInitialState,
+  initialPresentationState,
+} from "./presentation";

package/src/presentation/Presentation.ts

@@ -0,0 +1,189 @@
+/**
+ * Presentation Class
+ *
+ * High-level API for UI integration.
+ * Wraps AgentX client and provides presentation state management.
+ */
+
+import type { AgentX } from "../types";
+import type { Unsubscribe, BusEvent } from "@agentxjs/core/event";
+import type { PresentationState } from "./types";
+import {
+  presentationReducer,
+  addUserConversation,
+  createInitialState,
+} from "./reducer";
+
+/**
+ * Presentation update handler
+ */
+export type PresentationUpdateHandler = (state: PresentationState) => void;
+
+/**
+ * Presentation error handler
+ */
+export type PresentationErrorHandler = (error: Error) => void;
+
+/**
+ * Presentation options
+ */
+export interface PresentationOptions {
+  /**
+   * Called on every state update
+   */
+  onUpdate?: PresentationUpdateHandler;
+
+  /**
+   * Called on errors
+   */
+  onError?: PresentationErrorHandler;
+}
+
+/**
+ * Presentation - UI-friendly wrapper for AgentX
+ */
+export class Presentation {
+  private agentx: AgentX;
+  private agentId: string;
+  private state: PresentationState;
+  private updateHandlers: Set<PresentationUpdateHandler> = new Set();
+  private errorHandlers: Set<PresentationErrorHandler> = new Set();
+  private eventUnsubscribe: Unsubscribe | null = null;
+
+  constructor(agentx: AgentX, agentId: string, options?: PresentationOptions) {
+    this.agentx = agentx;
+    this.agentId = agentId;
+    this.state = createInitialState();
+
+    // Register initial handlers
+    if (options?.onUpdate) {
+      this.updateHandlers.add(options.onUpdate);
+    }
+    if (options?.onError) {
+      this.errorHandlers.add(options.onError);
+    }
+
+    // Subscribe to all events
+    this.subscribeToEvents();
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): PresentationState {
+    return this.state;
+  }
+
+  /**
+   * Subscribe to state updates
+   */
+  onUpdate(handler: PresentationUpdateHandler): Unsubscribe {
+    this.updateHandlers.add(handler);
+    // Immediately call with current state
+    handler(this.state);
+    return () => {
+      this.updateHandlers.delete(handler);
+    };
+  }
+
+  /**
+   * Subscribe to errors
+   */
+  onError(handler: PresentationErrorHandler): Unsubscribe {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+
+  /**
+   * Send a message
+   */
+  async send(content: string): Promise<void> {
+    // Add user conversation
+    this.state = addUserConversation(this.state, content);
+    this.notify();
+
+    try {
+      // Send message via agentx
+      await this.agentx.sendMessage(this.agentId, content);
+    } catch (error) {
+      this.notifyError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Interrupt current response
+   */
+  async interrupt(): Promise<void> {
+    try {
+      await this.agentx.interrupt(this.agentId);
+    } catch (error) {
+      this.notifyError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Reset state
+   */
+  reset(): void {
+    this.state = createInitialState();
+    this.notify();
+  }
+
+  /**
+   * Dispose and cleanup
+   */
+  dispose(): void {
+    if (this.eventUnsubscribe) {
+      this.eventUnsubscribe();
+      this.eventUnsubscribe = null;
+    }
+    this.updateHandlers.clear();
+    this.errorHandlers.clear();
+  }
+
+  // ==================== Private ====================
+
+  private subscribeToEvents(): void {
+    // Subscribe to all events and filter by agentId
+    this.eventUnsubscribe = this.agentx.onAny((event: BusEvent) => {
+      // Filter events for this agent (if context is available)
+      // Note: Events from server may or may not include context with agentId
+      const eventWithContext = event as BusEvent & { context?: { agentId?: string } };
+      const eventAgentId = eventWithContext.context?.agentId;
+
+      // Only filter if event has agentId and it doesn't match
+      if (eventAgentId && eventAgentId !== this.agentId) {
+        return;
+      }
+
+      // Reduce event into state
+      const newState = presentationReducer(this.state, event);
+      if (newState !== this.state) {
+        this.state = newState;
+        this.notify();
+      }
+    });
+  }
+
+  private notify(): void {
+    for (const handler of this.updateHandlers) {
+      try {
+        handler(this.state);
+      } catch (error) {
+        console.error("Presentation update handler error:", error);
+      }
+    }
+  }
+
+  private notifyError(error: Error): void {
+    for (const handler of this.errorHandlers) {
+      try {
+        handler(error);
+      } catch (e) {
+        console.error("Presentation error handler error:", e);
+      }
+    }
+  }
+}

package/src/presentation/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Presentation Module
+ *
+ * UI-friendly data model and state management.
+ */
+
+export type {
+  Block,
+  TextBlock,
+  ToolBlock,
+  ImageBlock,
+  Conversation,
+  UserConversation,
+  AssistantConversation,
+  ErrorConversation,
+  PresentationState,
+} from "./types";
+
+export { initialPresentationState } from "./types";
+
+export {
+  presentationReducer,
+  addUserConversation,
+  createInitialState,
+} from "./reducer";
+
+export {
+  Presentation,
+  type PresentationOptions,
+  type PresentationUpdateHandler,
+  type PresentationErrorHandler,
+} from "./Presentation";