agentxjs 0.0.0-dev-20260312143810

package/src/namespaces/images.ts

@@ -0,0 +1,192 @@
+/**
+ * Image namespace factories
+ */
+
+import type { Message } from "@agentxjs/core/agent";
+import type { RpcClient } from "@agentxjs/core/network";
+import type { AgentXPlatform } from "@agentxjs/core/runtime";
+import type {
+  BaseResponse,
+  ImageCreateResponse,
+  ImageGetResponse,
+  ImageListResponse,
+  ImageNamespace,
+  ImageUpdateResponse,
+} from "../types";
+
+/**
+ * Create local image namespace backed by embedded runtime
+ */
+export function createLocalImages(platform: AgentXPlatform): ImageNamespace {
+  return {
+    async create(params: {
+      containerId: string;
+      name?: string;
+      description?: string;
+      systemPrompt?: string;
+      mcpServers?: Record<string, unknown>;
+      customData?: Record<string, unknown>;
+    }): Promise<ImageCreateResponse> {
+      const { imageRepository, sessionRepository } = platform;
+      const { createImage } = await import("@agentxjs/core/image");
+
+      const image = await createImage(
+        {
+          containerId: params.containerId,
+          name: params.name,
+          description: params.description,
+          systemPrompt: params.systemPrompt,
+          mcpServers: params.mcpServers as any,
+          customData: params.customData,
+        },
+        { imageRepository, sessionRepository }
+      );
+
+      return {
+        record: image.toRecord(),
+        __subscriptions: [image.sessionId],
+        requestId: "",
+      };
+    },
+
+    async get(imageId: string): Promise<ImageGetResponse> {
+      const record = await platform.imageRepository.findImageById(imageId);
+      return {
+        record,
+        __subscriptions: record?.sessionId ? [record.sessionId] : undefined,
+        requestId: "",
+      };
+    },
+
+    async list(containerId?: string): Promise<ImageListResponse> {
+      const records = containerId
+        ? await platform.imageRepository.findImagesByContainerId(containerId)
+        : await platform.imageRepository.findAllImages();
+
+      return {
+        records,
+        __subscriptions: records.map((r) => r.sessionId),
+        requestId: "",
+      };
+    },
+
+    async update(
+      imageId: string,
+      updates: {
+        name?: string;
+        description?: string;
+        customData?: Record<string, unknown>;
+      }
+    ): Promise<ImageUpdateResponse> {
+      const { loadImage } = await import("@agentxjs/core/image");
+      const { imageRepository, sessionRepository } = platform;
+
+      const image = await loadImage(imageId, { imageRepository, sessionRepository });
+      if (!image) {
+        throw new Error(`Image not found: ${imageId}`);
+      }
+
+      const updated = await image.update(updates);
+      return { record: updated.toRecord(), requestId: "" };
+    },
+
+    async delete(imageId: string): Promise<BaseResponse> {
+      const { loadImage } = await import("@agentxjs/core/image");
+      const { imageRepository, sessionRepository } = platform;
+
+      const image = await loadImage(imageId, { imageRepository, sessionRepository });
+      if (image) {
+        await image.delete();
+      }
+
+      return { requestId: "" };
+    },
+
+    async getMessages(imageId: string): Promise<Message[]> {
+      const imageRecord = await platform.imageRepository.findImageById(imageId);
+      if (!imageRecord) return [];
+      return platform.sessionRepository.getMessages(imageRecord.sessionId);
+    },
+  };
+}
+
+/**
+ * Create remote image namespace backed by RPC client
+ */
+export function createRemoteImages(
+  rpcClient: RpcClient,
+  subscribeFn: (sessionId: string) => void
+): ImageNamespace {
+  return {
+    async create(params: {
+      containerId: string;
+      name?: string;
+      description?: string;
+      systemPrompt?: string;
+      mcpServers?: Record<string, unknown>;
+      customData?: Record<string, unknown>;
+    }): Promise<ImageCreateResponse> {
+      const result = await rpcClient.call<ImageCreateResponse>("image.create", params);
+
+      // Auto subscribe to session events
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+
+      return { ...result, requestId: "" };
+    },
+
+    async get(imageId: string): Promise<ImageGetResponse> {
+      const result = await rpcClient.call<ImageGetResponse>("image.get", { imageId });
+
+      // Auto subscribe
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+
+      return { ...result, requestId: "" };
+    },
+
+    async list(containerId?: string): Promise<ImageListResponse> {
+      const result = await rpcClient.call<ImageListResponse>("image.list", { containerId });
+
+      // Auto subscribe
+      if (result.__subscriptions) {
+        for (const sessionId of result.__subscriptions) {
+          subscribeFn(sessionId);
+        }
+      }
+
+      return { ...result, requestId: "" };
+    },
+
+    async update(
+      imageId: string,
+      updates: {
+        name?: string;
+        description?: string;
+        customData?: Record<string, unknown>;
+      }
+    ): Promise<ImageUpdateResponse> {
+      const result = await rpcClient.call<ImageUpdateResponse>("image.update", {
+        imageId,
+        updates,
+      });
+      return { ...result, requestId: "" };
+    },
+
+    async delete(imageId: string): Promise<BaseResponse> {
+      const result = await rpcClient.call<BaseResponse>("image.delete", { imageId });
+      return { ...result, requestId: "" };
+    },
+
+    async getMessages(imageId: string): Promise<Message[]> {
+      const result = await rpcClient.call<{ messages: Message[] }>("image.messages", { imageId });
+      return result.messages ?? [];
+    },
+  };
+}

package/src/namespaces/llm.ts

@@ -0,0 +1,140 @@
+/**
+ * LLM Provider namespace factories
+ */
+
+import type { RpcClient } from "@agentxjs/core/network";
+import type { LLMProviderRecord } from "@agentxjs/core/persistence";
+import type { AgentXPlatform } from "@agentxjs/core/runtime";
+import { generateId } from "@deepracticex/id";
+import type {
+  BaseResponse,
+  LLMNamespace,
+  LLMProviderCreateResponse,
+  LLMProviderDefaultResponse,
+  LLMProviderGetResponse,
+  LLMProviderListResponse,
+  LLMProviderUpdateResponse,
+} from "../types";
+
+/**
+ * Create local LLM namespace backed by platform repository
+ */
+export function createLocalLLM(platform: AgentXPlatform): LLMNamespace {
+  const repo = platform.llmProviderRepository;
+  if (!repo) {
+    throw new Error("LLM provider repository not available on this platform");
+  }
+
+  return {
+    async create(params): Promise<LLMProviderCreateResponse> {
+      const now = Date.now();
+      const record: LLMProviderRecord = {
+        id: generateId("llm"),
+        containerId: params.containerId,
+        name: params.name,
+        vendor: params.vendor,
+        protocol: params.protocol,
+        apiKey: params.apiKey,
+        baseUrl: params.baseUrl,
+        model: params.model,
+        isDefault: false,
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      await repo.saveLLMProvider(record);
+      return { record, requestId: "" };
+    },
+
+    async get(id: string): Promise<LLMProviderGetResponse> {
+      const record = await repo.findLLMProviderById(id);
+      return { record, requestId: "" };
+    },
+
+    async list(containerId: string): Promise<LLMProviderListResponse> {
+      const records = await repo.findLLMProvidersByContainerId(containerId);
+      return { records, requestId: "" };
+    },
+
+    async update(id, updates): Promise<LLMProviderUpdateResponse> {
+      const existing = await repo.findLLMProviderById(id);
+      if (!existing) {
+        throw new Error(`LLM provider not found: ${id}`);
+      }
+
+      const updated: LLMProviderRecord = {
+        ...existing,
+        ...updates,
+        id: existing.id,
+        containerId: existing.containerId,
+        createdAt: existing.createdAt,
+        updatedAt: Date.now(),
+      };
+
+      await repo.saveLLMProvider(updated);
+      return { record: updated, requestId: "" };
+    },
+
+    async delete(id: string): Promise<BaseResponse> {
+      await repo.deleteLLMProvider(id);
+      return { requestId: "" };
+    },
+
+    async setDefault(id: string): Promise<BaseResponse> {
+      await repo.setDefaultLLMProvider(id);
+      return { requestId: "" };
+    },
+
+    async getDefault(containerId: string): Promise<LLMProviderDefaultResponse> {
+      const record = await repo.findDefaultLLMProvider(containerId);
+      return { record, requestId: "" };
+    },
+  };
+}
+
+/**
+ * Create remote LLM namespace backed by RPC client
+ */
+export function createRemoteLLM(rpcClient: RpcClient): LLMNamespace {
+  return {
+    async create(params): Promise<LLMProviderCreateResponse> {
+      const result = await rpcClient.call<LLMProviderCreateResponse>("llm.create", params);
+      return { ...result, requestId: "" };
+    },
+
+    async get(id: string): Promise<LLMProviderGetResponse> {
+      const result = await rpcClient.call<LLMProviderGetResponse>("llm.get", { id });
+      return { ...result, requestId: "" };
+    },
+
+    async list(containerId: string): Promise<LLMProviderListResponse> {
+      const result = await rpcClient.call<LLMProviderListResponse>("llm.list", { containerId });
+      return { ...result, requestId: "" };
+    },
+
+    async update(id, updates): Promise<LLMProviderUpdateResponse> {
+      const result = await rpcClient.call<LLMProviderUpdateResponse>("llm.update", {
+        id,
+        updates,
+      });
+      return { ...result, requestId: "" };
+    },
+
+    async delete(id: string): Promise<BaseResponse> {
+      const result = await rpcClient.call<BaseResponse>("llm.delete", { id });
+      return { ...result, requestId: "" };
+    },
+
+    async setDefault(id: string): Promise<BaseResponse> {
+      const result = await rpcClient.call<BaseResponse>("llm.default", { id });
+      return { ...result, requestId: "" };
+    },
+
+    async getDefault(containerId: string): Promise<LLMProviderDefaultResponse> {
+      const result = await rpcClient.call<LLMProviderDefaultResponse>("llm.default", {
+        containerId,
+      });
+      return { ...result, requestId: "" };
+    },
+  };
+}

package/src/namespaces/presentations.ts

@@ -0,0 +1,22 @@
+/**
+ * Presentation namespace factory
+ *
+ * Single factory for both local and remote modes —
+ * Presentation only depends on the AgentX interface.
+ */
+
+import { messagesToConversations, Presentation, type PresentationOptions } from "../presentation";
+import type { AgentX, PresentationNamespace } from "../types";
+
+/**
+ * Create presentation namespace backed by any AgentX client
+ */
+export function createPresentations(agentx: AgentX): PresentationNamespace {
+  return {
+    async create(agentId: string, options?: PresentationOptions): Promise<Presentation> {
+      const messages = await agentx.session.getMessages(agentId);
+      const conversations = messagesToConversations(messages);
+      return new Presentation(agentx, agentId, options, conversations);
+    },
+  };
+}

package/src/namespaces/sessions.ts

@@ -0,0 +1,60 @@
+/**
+ * Session namespace factories (messaging)
+ */
+
+import type { Message, UserContentPart } from "@agentxjs/core/agent";
+import type { RpcClient } from "@agentxjs/core/network";
+import type { AgentXRuntime } from "@agentxjs/core/runtime";
+import type { AgentInfo, BaseResponse, MessageSendResponse, SessionNamespace } from "../types";
+
+/**
+ * Create local session namespace backed by embedded runtime
+ */
+export function createLocalSessions(runtime: AgentXRuntime): SessionNamespace {
+  return {
+    async send(agentId: string, content: string | unknown[]): Promise<MessageSendResponse> {
+      await runtime.receive(agentId, content as string | UserContentPart[]);
+      return { agentId, requestId: "" };
+    },
+
+    async interrupt(agentId: string): Promise<BaseResponse> {
+      runtime.interrupt(agentId);
+      return { requestId: "" };
+    },
+
+    async getMessages(agentId: string): Promise<Message[]> {
+      const agent = runtime.getAgent(agentId);
+      if (!agent) return [];
+      return runtime.platform.sessionRepository.getMessages(agent.sessionId);
+    },
+  };
+}
+
+/**
+ * Create remote session namespace backed by RPC client
+ */
+export function createRemoteSessions(rpcClient: RpcClient): SessionNamespace {
+  return {
+    async send(agentId: string, content: string | unknown[]): Promise<MessageSendResponse> {
+      const result = await rpcClient.call<MessageSendResponse>("message.send", {
+        agentId,
+        content,
+      });
+      return { ...result, requestId: "" };
+    },
+
+    async interrupt(agentId: string): Promise<BaseResponse> {
+      const result = await rpcClient.call<BaseResponse>("agent.interrupt", { agentId });
+      return { ...result, requestId: "" };
+    },
+
+    async getMessages(agentId: string): Promise<Message[]> {
+      const agentRes = await rpcClient.call<{ agent: AgentInfo | null }>("agent.get", { agentId });
+      if (!agentRes.agent) return [];
+      const msgRes = await rpcClient.call<{ messages: Message[] }>("image.messages", {
+        imageId: agentRes.agent.imageId,
+      });
+      return msgRes.messages ?? [];
+    },
+  };
+}

package/src/presentation/Presentation.ts

@@ -0,0 +1,193 @@
+/**
+ * Presentation Class
+ *
+ * High-level API for UI integration.
+ * Wraps AgentX client and provides presentation state management.
+ */
+
+import type { BusEvent, Unsubscribe } from "@agentxjs/core/event";
+import type { AgentX } from "../types";
+import { addUserConversation, createInitialState, presentationReducer } from "./reducer";
+import type { Conversation, PresentationState } from "./types";
+import { initialPresentationState } 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 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,
+    initialConversations?: Conversation[]
+  ) {
+    this.agentx = agentx;
+    this.agentId = agentId;
+    this.state = initialConversations?.length
+      ? { ...initialPresentationState, conversations: initialConversations }
+      : 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.session.send(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.session.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,31 @@
+/**
+ * Presentation Module
+ *
+ * UI-friendly data model and state management.
+ */
+
+export {
+  Presentation,
+  type PresentationErrorHandler,
+  type PresentationOptions,
+  type PresentationUpdateHandler,
+} from "./Presentation";
+export {
+  addUserConversation,
+  createInitialState,
+  messagesToConversations,
+  presentationReducer,
+} from "./reducer";
+export type {
+  AssistantConversation,
+  Block,
+  Conversation,
+  ErrorConversation,
+  ImageBlock,
+  PresentationState,
+  TextBlock,
+  TokenUsage,
+  ToolBlock,
+  UserConversation,
+} from "./types";
+export { initialPresentationState } from "./types";