agentxjs 1.9.2-dev → 1.9.4-dev

package/dist/presentation/Presentation.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Presentation Class
+ *
+ * High-level API for UI integration.
+ * Wraps AgentX client and provides presentation state management.
+ */
+import type { AgentX } from "../types";
+import type { Unsubscribe } from "@agentxjs/core/event";
+import type { PresentationState } from "./types";
+/**
+ * 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 declare class Presentation {
+    private agentx;
+    private agentId;
+    private state;
+    private updateHandlers;
+    private errorHandlers;
+    private eventUnsubscribe;
+    constructor(agentx: AgentX, agentId: string, options?: PresentationOptions);
+    /**
+     * Get current state
+     */
+    getState(): PresentationState;
+    /**
+     * Subscribe to state updates
+     */
+    onUpdate(handler: PresentationUpdateHandler): Unsubscribe;
+    /**
+     * Subscribe to errors
+     */
+    onError(handler: PresentationErrorHandler): Unsubscribe;
+    /**
+     * Send a message
+     */
+    send(content: string): Promise<void>;
+    /**
+     * Interrupt current response
+     */
+    interrupt(): Promise<void>;
+    /**
+     * Reset state
+     */
+    reset(): void;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): void;
+    private subscribeToEvents;
+    private notify;
+    private notifyError;
+}

package/dist/presentation/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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";

package/dist/presentation/reducer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Presentation Reducer
+ *
+ * Aggregates stream events into PresentationState.
+ * Pure function: (state, event) => newState
+ */
+import type { BusEvent } from "@agentxjs/core/event";
+import type { PresentationState } from "./types";
+/**
+ * Reduce a stream event into presentation state
+ */
+export declare function presentationReducer(state: PresentationState, event: BusEvent): PresentationState;
+/**
+ * Add a user conversation to state
+ */
+export declare function addUserConversation(state: PresentationState, content: string): PresentationState;
+/**
+ * Create initial state
+ */
+export declare function createInitialState(): PresentationState;

package/dist/presentation/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Presentation Types
+ *
+ * UI-friendly data model aggregated from stream events.
+ * This implements the Presentation Model pattern.
+ */
+/**
+ * Text block
+ */
+export interface TextBlock {
+    type: "text";
+    content: string;
+}
+/**
+ * Tool block - represents a tool call and its result
+ */
+export interface ToolBlock {
+    type: "tool";
+    toolUseId: string;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolResult?: string;
+    status: "pending" | "running" | "completed" | "error";
+}
+/**
+ * Image block
+ */
+export interface ImageBlock {
+    type: "image";
+    url: string;
+    alt?: string;
+}
+/**
+ * All block types
+ */
+export type Block = TextBlock | ToolBlock | ImageBlock;
+/**
+ * User conversation
+ */
+export interface UserConversation {
+    role: "user";
+    blocks: Block[];
+}
+/**
+ * Assistant conversation
+ */
+export interface AssistantConversation {
+    role: "assistant";
+    blocks: Block[];
+    isStreaming: boolean;
+}
+/**
+ * Error conversation
+ */
+export interface ErrorConversation {
+    role: "error";
+    message: string;
+}
+/**
+ * All conversation types
+ */
+export type Conversation = UserConversation | AssistantConversation | ErrorConversation;
+/**
+ * Presentation state - the complete UI state
+ */
+export interface PresentationState {
+    /**
+     * All completed conversations
+     */
+    conversations: Conversation[];
+    /**
+     * Current streaming conversation (null if not streaming)
+     */
+    streaming: AssistantConversation | null;
+    /**
+     * Current status
+     */
+    status: "idle" | "thinking" | "responding" | "executing";
+}
+/**
+ * Initial presentation state
+ */
+export declare const initialPresentationState: PresentationState;

package/dist/types.d.ts

@@ -0,0 +1,264 @@
+/**
+ * AgentX Client SDK Types
+ */
+import type { BusEvent, EventBus, Unsubscribe, BusEventHandler } from "@agentxjs/core/event";
+import type { Presentation, PresentationOptions } from "./presentation";
+/**
+ * Static or dynamic value
+ */
+export type MaybeAsync<T> = T | (() => T) | (() => Promise<T>);
+/**
+ * AgentX client configuration
+ */
+export interface AgentXConfig {
+    /**
+     * WebSocket server URL
+     */
+    serverUrl: string;
+    /**
+     * Headers for authentication (static or dynamic)
+     * In Node.js: sent during WebSocket handshake
+     * In browsers: sent as first auth message (WebSocket API limitation)
+     */
+    headers?: MaybeAsync<Record<string, string>>;
+    /**
+     * Business context injected into all requests
+     * Useful for passing userId, tenantId, permissions, etc.
+     */
+    context?: MaybeAsync<Record<string, unknown>>;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Auto reconnect on connection loss (default: true)
+     */
+    autoReconnect?: boolean;
+}
+/**
+ * Agent info returned from server
+ */
+export interface AgentInfo {
+    agentId: string;
+    imageId: string;
+    containerId: string;
+    sessionId: string;
+    lifecycle?: string;
+}
+/**
+ * Image record from server
+ */
+export interface ImageRecord {
+    imageId: string;
+    containerId: string;
+    sessionId: string;
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Container info
+ */
+export interface ContainerInfo {
+    containerId: string;
+}
+/**
+ * Base response with requestId
+ */
+export interface BaseResponse {
+    requestId: string;
+    error?: string;
+}
+/**
+ * Agent create response
+ */
+export interface AgentCreateResponse extends BaseResponse {
+    agentId: string;
+    imageId: string;
+    containerId: string;
+    sessionId: string;
+}
+/**
+ * Agent get response
+ */
+export interface AgentGetResponse extends BaseResponse {
+    agent: AgentInfo | null;
+    exists: boolean;
+}
+/**
+ * Agent list response
+ */
+export interface AgentListResponse extends BaseResponse {
+    agents: AgentInfo[];
+}
+/**
+ * Image create response
+ */
+export interface ImageCreateResponse extends BaseResponse {
+    record: ImageRecord;
+    __subscriptions?: string[];
+}
+/**
+ * Image get response
+ */
+export interface ImageGetResponse extends BaseResponse {
+    record: ImageRecord | null;
+    __subscriptions?: string[];
+}
+/**
+ * Image list response
+ */
+export interface ImageListResponse extends BaseResponse {
+    records: ImageRecord[];
+    __subscriptions?: string[];
+}
+/**
+ * Container create response
+ */
+export interface ContainerCreateResponse extends BaseResponse {
+    containerId: string;
+}
+/**
+ * Container get response
+ */
+export interface ContainerGetResponse extends BaseResponse {
+    containerId: string;
+    exists: boolean;
+}
+/**
+ * Container list response
+ */
+export interface ContainerListResponse extends BaseResponse {
+    containerIds: string[];
+}
+/**
+ * Message send response
+ */
+export interface MessageSendResponse extends BaseResponse {
+    agentId: string;
+}
+/**
+ * AgentX Client SDK
+ */
+export interface AgentX {
+    /**
+     * Check if connected to server
+     */
+    readonly connected: boolean;
+    /**
+     * Event bus for subscribing to events
+     */
+    readonly events: EventBus;
+    /**
+     * Create a new agent
+     */
+    createAgent(params: {
+        imageId: string;
+        agentId?: string;
+    }): Promise<AgentCreateResponse>;
+    /**
+     * Get agent by ID
+     */
+    getAgent(agentId: string): Promise<AgentGetResponse>;
+    /**
+     * List agents
+     */
+    listAgents(containerId?: string): Promise<AgentListResponse>;
+    /**
+     * Destroy an agent
+     */
+    destroyAgent(agentId: string): Promise<BaseResponse>;
+    /**
+     * Send message to agent
+     */
+    sendMessage(agentId: string, content: string | unknown[]): Promise<MessageSendResponse>;
+    /**
+     * Interrupt agent
+     */
+    interrupt(agentId: string): Promise<BaseResponse>;
+    /**
+     * Create a new image
+     */
+    createImage(params: {
+        containerId: string;
+        name?: string;
+        description?: string;
+        systemPrompt?: string;
+        mcpServers?: Record<string, unknown>;
+    }): Promise<ImageCreateResponse>;
+    /**
+     * Get image by ID
+     */
+    getImage(imageId: string): Promise<ImageGetResponse>;
+    /**
+     * List images
+     */
+    listImages(containerId?: string): Promise<ImageListResponse>;
+    /**
+     * Delete image
+     */
+    deleteImage(imageId: string): Promise<BaseResponse>;
+    /**
+     * Create or get container
+     */
+    createContainer(containerId: string): Promise<ContainerCreateResponse>;
+    /**
+     * Get container
+     */
+    getContainer(containerId: string): Promise<ContainerGetResponse>;
+    /**
+     * List containers
+     */
+    listContainers(): Promise<ContainerListResponse>;
+    /**
+     * Subscribe to specific event type
+     */
+    on<T extends string>(type: T, handler: BusEventHandler<BusEvent & {
+        type: T;
+    }>): Unsubscribe;
+    /**
+     * Subscribe to all events
+     */
+    onAny(handler: BusEventHandler): Unsubscribe;
+    /**
+     * Subscribe to session events
+     */
+    subscribe(sessionId: string): void;
+    /**
+     * Create a presentation for UI integration
+     *
+     * @example
+     * ```typescript
+     * const presentation = agentx.presentation(agentId);
+     *
+     * presentation.onUpdate((state) => {
+     *   render(state.conversations);
+     * });
+     *
+     * await presentation.send("Hello!");
+     * ```
+     */
+    presentation(agentId: string, options?: PresentationOptions): Presentation;
+    /**
+     * Disconnect from server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Dispose and cleanup
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Pending request entry
+ */
+export interface PendingRequest {
+    resolve: (response: BusEvent) => void;
+    reject: (error: Error) => void;
+    timeout: ReturnType<typeof setTimeout>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxjs",
-  "version": "1.9.2-dev",
+  "version": "1.9.4-dev",
   "description": "AgentX Client SDK - Connect to AgentX servers",
   "license": "MIT",
   "type": "module",
@@ -8,17 +8,22 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
     "build": "bun run build.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   },
   "dependencies": {
-    "@agentxjs/core": "workspace:*",
+    "@agentxjs/core": "1.9.3-dev",
     "reconnecting-websocket": "^4.4.0",
     "ws": "^8.18.0"
   },

package/src/index.ts

@@ -90,9 +90,6 @@ export type {
   BaseResponse,
 } from "./types";
 
-// Re-export RemoteClient for advanced use
-export { RemoteClient } from "./RemoteClient";
-
 // Re-export Presentation types and classes
 export type {
   Block,

package/build.ts

@@ -1,26 +0,0 @@
-/**
- * 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/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "lib": ["ESNext", "DOM"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}