agentxjs 2.7.0 → 2.8.0

package/src/namespaces/containers.ts

@@ -1,68 +0,0 @@
-/**
- * Container namespace factories
- */
-
-import type { RpcClient } from "@agentxjs/core/network";
-import type { AgentXPlatform } from "@agentxjs/core/runtime";
-import type {
-  ContainerCreateResponse,
-  ContainerGetResponse,
-  ContainerListResponse,
-  ContainerNamespace,
-} from "../types";
-
-/**
- * Create local container namespace backed by embedded runtime
- */
-export function createLocalContainers(platform: AgentXPlatform): ContainerNamespace {
-  return {
-    async create(containerId: string): Promise<ContainerCreateResponse> {
-      const { getOrCreateContainer } = await import("@agentxjs/core/container");
-      const { containerRepository, imageRepository, sessionRepository } = platform;
-
-      const container = await getOrCreateContainer(containerId, {
-        containerRepository,
-        imageRepository,
-        sessionRepository,
-      });
-
-      return { containerId: container.containerId, requestId: "" };
-    },
-
-    async get(containerId: string): Promise<ContainerGetResponse> {
-      const exists = await platform.containerRepository.containerExists(containerId);
-      return { containerId, exists, requestId: "" };
-    },
-
-    async list(): Promise<ContainerListResponse> {
-      const containers = await platform.containerRepository.findAllContainers();
-      return { containerIds: containers.map((c) => c.containerId), requestId: "" };
-    },
-  };
-}
-
-/**
- * Create remote container namespace backed by RPC client
- */
-export function createRemoteContainers(rpcClient: RpcClient): ContainerNamespace {
-  return {
-    async create(containerId: string): Promise<ContainerCreateResponse> {
-      const result = await rpcClient.call<ContainerCreateResponse>("container.create", {
-        containerId,
-      });
-      return { ...result, requestId: "" };
-    },
-
-    async get(containerId: string): Promise<ContainerGetResponse> {
-      const result = await rpcClient.call<ContainerGetResponse>("container.get", {
-        containerId,
-      });
-      return { ...result, requestId: "" };
-    },
-
-    async list(): Promise<ContainerListResponse> {
-      const result = await rpcClient.call<ContainerListResponse>("container.list", {});
-      return { ...result, requestId: "" };
-    },
-  };
-}

package/src/namespaces/prototypes.ts

@@ -1,136 +0,0 @@
-/**
- * Prototype namespace factories
- */
-
-import type { RpcClient } from "@agentxjs/core/network";
-import type { AgentXPlatform } from "@agentxjs/core/runtime";
-import type {
-  BaseResponse,
-  PrototypeCreateResponse,
-  PrototypeGetResponse,
-  PrototypeListResponse,
-  PrototypeNamespace,
-  PrototypeUpdateResponse,
-} from "../types";
-
-/**
- * Create local prototype namespace backed by embedded runtime
- */
-export function createLocalPrototypes(platform: AgentXPlatform): PrototypeNamespace {
-  return {
-    async create(params): Promise<PrototypeCreateResponse> {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-
-      const now = Date.now();
-      const random = Math.random().toString(36).slice(2, 8);
-      const record = {
-        prototypeId: `proto_${now}_${random}`,
-        containerId: params.containerId,
-        name: params.name,
-        description: params.description,
-        contextId: params.contextId,
-        embody: params.embody,
-        customData: params.customData,
-        createdAt: now,
-        updatedAt: now,
-      };
-
-      await repo.savePrototype(record);
-      return { record, requestId: "" };
-    },
-
-    async get(prototypeId: string): Promise<PrototypeGetResponse> {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-
-      const record = await repo.findPrototypeById(prototypeId);
-      return { record, requestId: "" };
-    },
-
-    async list(containerId?: string): Promise<PrototypeListResponse> {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-
-      const records = containerId
-        ? await repo.findPrototypesByContainerId(containerId)
-        : await repo.findAllPrototypes();
-
-      return { records, requestId: "" };
-    },
-
-    async update(prototypeId, updates): Promise<PrototypeUpdateResponse> {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-
-      const existing = await repo.findPrototypeById(prototypeId);
-      if (!existing) {
-        throw new Error(`Prototype not found: ${prototypeId}`);
-      }
-
-      const { embody: embodyUpdates, ...otherUpdates } = updates;
-      const updatedRecord = {
-        ...existing,
-        ...otherUpdates,
-        embody: embodyUpdates ? { ...existing.embody, ...embodyUpdates } : existing.embody,
-        updatedAt: Date.now(),
-      };
-
-      await repo.savePrototype(updatedRecord);
-      return { record: updatedRecord, requestId: "" };
-    },
-
-    async delete(prototypeId: string): Promise<BaseResponse> {
-      const repo = platform.prototypeRepository;
-      if (!repo) {
-        throw new Error("Prototype repository not available");
-      }
-
-      await repo.deletePrototype(prototypeId);
-      return { requestId: "" };
-    },
-  };
-}
-
-/**
- * Create remote prototype namespace backed by RPC client
- */
-export function createRemotePrototypes(rpcClient: RpcClient): PrototypeNamespace {
-  return {
-    async create(params): Promise<PrototypeCreateResponse> {
-      const result = await rpcClient.call<PrototypeCreateResponse>("prototype.create", params);
-      return { ...result, requestId: "" };
-    },
-
-    async get(prototypeId: string): Promise<PrototypeGetResponse> {
-      const result = await rpcClient.call<PrototypeGetResponse>("prototype.get", { prototypeId });
-      return { ...result, requestId: "" };
-    },
-
-    async list(containerId?: string): Promise<PrototypeListResponse> {
-      const result = await rpcClient.call<PrototypeListResponse>("prototype.list", { containerId });
-      return { ...result, requestId: "" };
-    },
-
-    async update(prototypeId, updates): Promise<PrototypeUpdateResponse> {
-      const result = await rpcClient.call<PrototypeUpdateResponse>("prototype.update", {
-        prototypeId,
-        updates,
-      });
-      return { ...result, requestId: "" };
-    },
-
-    async delete(prototypeId: string): Promise<BaseResponse> {
-      const result = await rpcClient.call<BaseResponse>("prototype.delete", { prototypeId });
-      return { ...result, requestId: "" };
-    },
-  };
-}