@agentxjs/core 1.9.9-dev → 2.0.0

package/dist/persistence/index.d.ts

@@ -1,155 +1,2 @@
-import { M as Message } from '../message-BMrMm1pq.js';
-import { McpServerConfig } from '../driver/index.js';
-
-/**
- * Persistence Types - Repository interfaces and record types
- *
- * Defines standard interfaces for data persistence.
- * Implementations are provided by platform packages (node, cloudflare).
- */
-
-/**
- * Container configuration (extensible)
- */
-interface ContainerConfig {
-    [key: string]: unknown;
-}
-/**
- * ContainerRecord - Persistent container data
- *
- * Represents a logical container (resource isolation unit).
- * Each container provides an isolated environment for running Agents.
- */
-interface ContainerRecord {
-    /** Unique container identifier */
-    containerId: string;
-    /** Container creation timestamp (Unix milliseconds) */
-    createdAt: number;
-    /** Last update timestamp (Unix milliseconds) */
-    updatedAt: number;
-    /** Container configuration (extensible) */
-    config?: ContainerConfig;
-}
-/**
- * Image metadata for storing provider-specific data
- */
-interface ImageMetadata {
-    /** Claude SDK session ID for conversation resume */
-    claudeSdkSessionId?: string;
-}
-/**
- * ImageRecord - Persistent representation of a conversation
- *
- * Image is the primary entity users interact with (displayed as "conversation").
- * Agent is a transient runtime instance created from Image.
- *
- * Lifecycle:
- * - image_create → ImageRecord (persistent)
- * - image_run → Agent (runtime, in-memory)
- * - image_stop / server restart → Agent destroyed, Image remains
- */
-interface ImageRecord {
-    /** Unique image identifier (pattern: `img_${nanoid()}`) */
-    imageId: string;
-    /** Container ID (user isolation boundary) */
-    containerId: string;
-    /** Session ID for message storage */
-    sessionId: string;
-    /** Conversation name (displayed to user) */
-    name: string;
-    /** Conversation description (optional) */
-    description?: string;
-    /** System prompt - controls agent behavior */
-    systemPrompt?: string;
-    /** Parent image ID (for fork/branch feature) */
-    parentImageId?: string;
-    /** MCP servers configuration */
-    mcpServers?: Record<string, McpServerConfig>;
-    /** Provider-specific metadata */
-    metadata?: ImageMetadata;
-    /** Creation timestamp (Unix milliseconds) */
-    createdAt: number;
-    /** Last update timestamp (Unix milliseconds) */
-    updatedAt: number;
-}
-/**
- * SessionRecord - Storage schema for Session persistence
- *
- * Session stores conversation messages for an Image.
- * Each Image has exactly one Session.
- */
-interface SessionRecord {
-    /** Unique session identifier */
-    sessionId: string;
-    /** Associated image ID (owner of this session) */
-    imageId: string;
-    /** Container this session belongs to */
-    containerId: string;
-    /** Creation timestamp (Unix milliseconds) */
-    createdAt: number;
-    /** Last update timestamp (Unix milliseconds) */
-    updatedAt: number;
-}
-/**
- * ContainerRepository - Storage operations for containers
- */
-interface ContainerRepository {
-    /** Save a container record (create or update) */
-    saveContainer(record: ContainerRecord): Promise<void>;
-    /** Find container by ID */
-    findContainerById(containerId: string): Promise<ContainerRecord | null>;
-    /** Find all containers */
-    findAllContainers(): Promise<ContainerRecord[]>;
-    /** Delete container by ID */
-    deleteContainer(containerId: string): Promise<void>;
-    /** Check if container exists */
-    containerExists(containerId: string): Promise<boolean>;
-}
-/**
- * ImageRepository - Storage operations for images
- */
-interface ImageRepository {
-    /** Save an image record (create or update) */
-    saveImage(record: ImageRecord): Promise<void>;
-    /** Find image by ID */
-    findImageById(imageId: string): Promise<ImageRecord | null>;
-    /** Find all images */
-    findAllImages(): Promise<ImageRecord[]>;
-    /** Find images by agent name */
-    findImagesByName(name: string): Promise<ImageRecord[]>;
-    /** Find images by container ID */
-    findImagesByContainerId(containerId: string): Promise<ImageRecord[]>;
-    /** Delete image by ID */
-    deleteImage(imageId: string): Promise<void>;
-    /** Check if image exists */
-    imageExists(imageId: string): Promise<boolean>;
-    /** Update image metadata (merges with existing) */
-    updateMetadata(imageId: string, metadata: Partial<ImageMetadata>): Promise<void>;
-}
-/**
- * SessionRepository - Storage operations for sessions
- */
-interface SessionRepository {
-    /** Save a session record (create or update) */
-    saveSession(record: SessionRecord): Promise<void>;
-    /** Find session by ID */
-    findSessionById(sessionId: string): Promise<SessionRecord | null>;
-    /** Find session by image ID */
-    findSessionByImageId(imageId: string): Promise<SessionRecord | null>;
-    /** Find all sessions for a container */
-    findSessionsByContainerId(containerId: string): Promise<SessionRecord[]>;
-    /** Find all sessions */
-    findAllSessions(): Promise<SessionRecord[]>;
-    /** Delete session by ID */
-    deleteSession(sessionId: string): Promise<void>;
-    /** Check if session exists */
-    sessionExists(sessionId: string): Promise<boolean>;
-    /** Add a message to a session */
-    addMessage(sessionId: string, message: Message): Promise<void>;
-    /** Get all messages for a session */
-    getMessages(sessionId: string): Promise<Message[]>;
-    /** Clear all messages for a session */
-    clearMessages(sessionId: string): Promise<void>;
-}
-
-export { type ContainerConfig, type ContainerRecord, type ContainerRepository, type ImageMetadata, type ImageRecord, type ImageRepository, McpServerConfig, type SessionRecord, type SessionRepository };
+export { e as ContainerConfig, C as ContainerRecord, d as ContainerRepository, g as ImageMetadata, f as ImageRecord, I as ImageRepository, M as McpServerConfig, b as SessionRecord, c as SessionRepository } from '../index-CuS1i5V-.js';
+import '../message-03TJzvIX.js';

package/dist/platform/index.d.ts

@@ -0,0 +1,76 @@
+import { d as ContainerRepository, I as ImageRepository, c as SessionRepository } from '../index-CuS1i5V-.js';
+import { E as EventBus } from '../bus-C9FLWIu8.js';
+import { B as BashProvider } from '../types-aE74Eo6G.js';
+import { W as WebSocketFactory } from '../RpcClient-BcJ_zAGu.js';
+import '../message-03TJzvIX.js';
+import '../base-m40r3Qgu.js';
+import 'jsonrpc-lite';
+
+/**
+ * Platform Types
+ *
+ * AgentXPlatform - Dependency injection container for platform capabilities.
+ * Platform packages (node-platform, etc.) provide implementations.
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                      AgentXPlatform                         │
+ * │  (Dependency Injection - Platform provides implementations) │
+ * │                                                             │
+ * │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐          │
+ * │  │ Repositories│ │  EventBus   │ │  Providers  │          │
+ * │  │  Container  │ │             │ │  Bash (opt) │          │
+ * │  │  Image      │ │             │ │             │          │
+ * │  │  Session    │ │             │ │             │          │
+ * │  └─────────────┘ └─────────────┘ └─────────────┘          │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ */
+
+/**
+ * AgentXPlatform - Collects all dependencies for runtime
+ *
+ * Platform packages provide implementations of these interfaces.
+ * The platform is passed to AgentXRuntime for integration.
+ *
+ * Required capabilities:
+ * - containerRepository, imageRepository, sessionRepository — persistence
+ * - eventBus — pub/sub
+ *
+ * Optional capabilities:
+ * - bashProvider — command execution (not all platforms support this)
+ */
+interface AgentXPlatform {
+    /**
+     * Container repository for persistence
+     */
+    readonly containerRepository: ContainerRepository;
+    /**
+     * Image repository for persistence
+     */
+    readonly imageRepository: ImageRepository;
+    /**
+     * Session repository for persistence
+     */
+    readonly sessionRepository: SessionRepository;
+    /**
+     * Event bus for pub/sub
+     */
+    readonly eventBus: EventBus;
+    /**
+     * Bash provider for command execution
+     *
+     * Optional — not all platforms support shell execution.
+     * Node.js platform provides child_process based implementation.
+     */
+    readonly bashProvider?: BashProvider;
+    /**
+     * WebSocket factory for creating client connections
+     *
+     * Optional — browser uses native WebSocket by default.
+     * Node.js platform provides ws-based implementation.
+     */
+    readonly webSocketFactory?: WebSocketFactory;
+}
+
+export type { AgentXPlatform };

package/dist/platform/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime/index.d.ts

@@ -1,34 +1,28 @@
-import { ContainerRepository, ImageRepository, SessionRepository } from '../persistence/index.js';
-import { CreateDriver } from '../driver/index.js';
-import { c as UserContentPart } from '../message-BMrMm1pq.js';
-import { WorkspaceProvider } from '../workspace/index.js';
+import { AgentXPlatform } from '../platform/index.js';
+import { b as UserContentPart } from '../message-03TJzvIX.js';
 import { B as BusEvent } from '../base-m40r3Qgu.js';
-import { E as EventBus } from '../bus-uF1DM2ox.js';
+import { h as CreateDriver } from '../index-CuS1i5V-.js';
+import '../bus-C9FLWIu8.js';
+import '../types-aE74Eo6G.js';
+import '../RpcClient-BcJ_zAGu.js';
+import 'jsonrpc-lite';
 
 /**
  * Runtime Types
  *
- * AgentXProvider - Dependency injection container
  * AgentXRuntime - Runtime integration layer
  *
  * Architecture:
  * ```
  * ┌─────────────────────────────────────────────────────────────┐
- * │                      AgentXProvider                         │
- * │  (Dependency Injection - Platform provides implementations) │
- * │                                                             │
- * │  ┌─────────────┐ ┌─────────────┐ ┌───────────────┐         │
- * │  │ Repositories│ │  Workspace  │ │ DriverFactory │         │
- * │  │  Container  │ │  Provider   │ │ (per-Agent)   │         │
- * │  │  Image      │ │             │ │             │           │
- * │  │  Session    │ │             │ │             │           │
- * │  └─────────────┘ └─────────────┘ └─────────────┘           │
+ * │                      AgentXPlatform                         │
+ * │           (see @agentxjs/core/platform)                     │
  * └─────────────────────────────────────────────────────────────┘
  *                              │
  *                              ▼
  * ┌─────────────────────────────────────────────────────────────┐
  * │                      AgentXRuntime                          │
- * │           (Integration - Uses Provider dependencies)        │
+ * │           (Integration - Uses Platform dependencies)        │
  * │                                                             │
  * │  ┌─────────────────────────────────────────────────────┐   │
  * │  │  Agent Lifecycle: create / get / destroy            │   │
@@ -55,38 +49,6 @@ interface RuntimeAgent {
     readonly lifecycle: AgentLifecycle;
     readonly createdAt: number;
 }
-/**
- * AgentXProvider - Collects all dependencies for runtime
- *
- * Platform packages provide implementations of these interfaces.
- * The provider is passed to AgentXRuntime for integration.
- */
-interface AgentXProvider {
-    /**
-     * Container repository for persistence
-     */
-    readonly containerRepository: ContainerRepository;
-    /**
-     * Image repository for persistence
-     */
-    readonly imageRepository: ImageRepository;
-    /**
-     * Session repository for persistence
-     */
-    readonly sessionRepository: SessionRepository;
-    /**
-     * Workspace provider for isolated environments
-     */
-    readonly workspaceProvider: WorkspaceProvider;
-    /**
-     * LLM Driver factory function - creates Driver per Agent
-     */
-    readonly createDriver: CreateDriver;
-    /**
-     * Event bus for pub/sub
-     */
-    readonly eventBus: EventBus;
-}
 /**
  * Agent creation options
  */
@@ -118,9 +80,9 @@ interface Subscription {
  */
 interface AgentXRuntime {
     /**
-     * The provider containing all dependencies
+     * The platform containing all dependencies
      */
-    readonly provider: AgentXProvider;
+    readonly platform: AgentXPlatform;
     /**
      * Create and start an agent from an image
      */
@@ -176,7 +138,7 @@ interface AgentXRuntime {
  * Configuration for creating AgentXRuntime
  */
 interface AgentXRuntimeConfig {
-    provider: AgentXProvider;
+    platform: AgentXPlatform;
 }
 /**
  * Factory function type for creating AgentXRuntime
@@ -187,23 +149,25 @@ type CreateAgentXRuntime = (config: AgentXRuntimeConfig) => AgentXRuntime;
  * AgentXRuntimeImpl - Runtime integration implementation
  *
  * Integrates all components to provide agent lifecycle management.
- * Uses Provider dependencies to coordinate Session, Image, Container, etc.
+ * Uses Platform dependencies to coordinate Session, Image, Container, etc.
  *
- * New Design:
+ * Architecture:
  * - Driver.receive() returns AsyncIterable<DriverStreamEvent>
- * - Runtime processes events and emits to EventBus
- * - No more EventBus-based communication with Driver
+ * - Runtime emits raw stream events to EventBus
+ * - Runtime pushes events through AgentEngine (MealyMachine → Presenter)
+ * - Presenter emits message/state/turn events and persists messages
  */
 
 /**
  * AgentXRuntimeImpl - Runtime implementation
  */
 declare class AgentXRuntimeImpl implements AgentXRuntime {
-    readonly provider: AgentXProvider;
+    readonly platform: AgentXPlatform;
+    private readonly createDriver;
     private agents;
     private globalSubscriptions;
     private isShutdown;
-    constructor(provider: AgentXProvider);
+    constructor(platform: AgentXPlatform, createDriver: CreateDriver);
     createAgent(options: CreateAgentOptions): Promise<RuntimeAgent>;
     getAgent(agentId: string): RuntimeAgent | undefined;
     getAgents(): RuntimeAgent[];
@@ -234,7 +198,10 @@ declare class AgentXRuntimeImpl implements AgentXRuntime {
 }
 /**
  * Create an AgentXRuntime instance
+ *
+ * @param platform - AgentXPlatform with repositories and event bus
+ * @param createDriver - Factory function for creating Driver instances per Agent
  */
-declare function createAgentXRuntime(provider: AgentXProvider): AgentXRuntime;
+declare function createAgentXRuntime(platform: AgentXPlatform, createDriver: CreateDriver): AgentXRuntime;
 
-export { type AgentEventHandler, type AgentLifecycle, type AgentXProvider, type AgentXRuntime, type AgentXRuntimeConfig, AgentXRuntimeImpl, type CreateAgentOptions, type CreateAgentXRuntime, type RuntimeAgent, type Subscription, createAgentXRuntime };
+export { type AgentEventHandler, type AgentLifecycle, AgentXPlatform, type AgentXRuntime, type AgentXRuntimeConfig, AgentXRuntimeImpl, type CreateAgentOptions, type CreateAgentXRuntime, type RuntimeAgent, type Subscription, createAgentXRuntime };

package/dist/runtime/index.js

@@ -1,15 +1,30 @@
-import "../chunk-7D4SUZUM.js";
+import {
+  createSession
+} from "../chunk-BHOD5PKR.js";
+import {
+  createAgent
+} from "../chunk-JTKCV7IS.js";
+import "../chunk-DEAR6N3O.js";
+import "../chunk-EKHT54KN.js";
+import "../chunk-23UUBQXR.js";
+import {
+  createBashTool
+} from "../chunk-FI7WQFGV.js";
+import "../chunk-7ZDX3O6I.js";
+import "../chunk-LTVNPHST.js";
 
 // src/runtime/AgentXRuntime.ts
 import { createLogger } from "commonxjs/logger";
 var logger = createLogger("runtime/AgentXRuntime");
 var AgentXRuntimeImpl = class {
-  provider;
+  platform;
+  createDriver;
   agents = /* @__PURE__ */ new Map();
   globalSubscriptions = /* @__PURE__ */ new Set();
   isShutdown = false;
-  constructor(provider) {
-    this.provider = provider;
+  constructor(platform, createDriver) {
+    this.platform = platform;
+    this.createDriver = createDriver;
     logger.info("AgentXRuntime initialized");
   }
   // ==================== Agent Lifecycle ====================
@@ -18,36 +33,85 @@ var AgentXRuntimeImpl = class {
       throw new Error("Runtime is shutdown");
     }
     const { imageId } = options;
-    const imageRecord = await this.provider.imageRepository.findImageById(imageId);
+    const imageRecord = await this.platform.imageRepository.findImageById(imageId);
     if (!imageRecord) {
       throw new Error(`Image not found: ${imageId}`);
     }
     const agentId = options.agentId ?? this.generateAgentId();
-    const containerExists = await this.provider.containerRepository.containerExists(
+    const containerExists = await this.platform.containerRepository.containerExists(
       imageRecord.containerId
     );
     if (!containerExists) {
       throw new Error(`Container not found: ${imageRecord.containerId}`);
     }
-    const workspace = await this.provider.workspaceProvider.create({
+    const session = createSession({
+      sessionId: imageRecord.sessionId,
+      imageId,
       containerId: imageRecord.containerId,
-      imageId
+      repository: this.platform.sessionRepository
     });
-    await workspace.initialize();
+    const defaultTools = [];
+    if (this.platform.bashProvider) {
+      defaultTools.push(createBashTool(this.platform.bashProvider));
+    }
     const driverConfig = {
-      apiKey: process.env.ANTHROPIC_API_KEY ?? "",
-      baseUrl: process.env.ANTHROPIC_BASE_URL,
+      apiKey: "",
       agentId,
       systemPrompt: imageRecord.systemPrompt,
-      cwd: workspace.path,
       mcpServers: imageRecord.mcpServers,
-      resumeSessionId: imageRecord.metadata?.claudeSdkSessionId,
-      onSessionIdCaptured: async (claudeSdkSessionId) => {
-        await this.provider.imageRepository.updateMetadata(imageId, { claudeSdkSessionId });
+      tools: defaultTools.length > 0 ? defaultTools : void 0,
+      session,
+      // Inject Session for stateless drivers
+      resumeSessionId: imageRecord.metadata?.driverSessionId,
+      onSessionIdCaptured: async (driverSessionId) => {
+        await this.platform.imageRepository.updateMetadata(imageId, { driverSessionId });
       }
     };
-    const driver = this.provider.createDriver(driverConfig);
+    const driver = this.createDriver(driverConfig);
     await driver.initialize();
+    const noopSource = {
+      name: "RuntimeSource",
+      connect: () => {
+      },
+      disconnect: () => {
+      }
+    };
+    const sessionId = imageRecord.sessionId;
+    const sessionRepository = this.platform.sessionRepository;
+    const eventBus = this.platform.eventBus;
+    const runtimePresenter = {
+      name: "RuntimePresenter",
+      present: (_agentId, output) => {
+        const category = categorizeAgentOutput(output.type);
+        if (category === "stream") return;
+        eventBus.emit({
+          type: output.type,
+          timestamp: output.timestamp,
+          source: "agent",
+          category,
+          intent: "notification",
+          data: output.data,
+          context: {
+            agentId,
+            imageId,
+            containerId: imageRecord.containerId,
+            sessionId
+          }
+        });
+        if (category === "message" && output.type !== "user_message") {
+          const message = output.data;
+          sessionRepository.addMessage(sessionId, message).catch((err) => {
+            logger.error("Failed to persist message", { type: output.type, error: err });
+          });
+        }
+      }
+    };
+    const engine = createAgent({
+      agentId,
+      bus: this.platform.eventBus,
+      source: noopSource,
+      presenter: runtimePresenter
+    });
     const agent = {
       agentId,
       imageId,
@@ -62,10 +126,11 @@ var AgentXRuntimeImpl = class {
       lifecycle: "running",
       subscriptions: /* @__PURE__ */ new Set(),
       driver,
+      engine,
       isReceiving: false
     };
     this.agents.set(agentId, state);
-    this.provider.eventBus.emit({
+    this.platform.eventBus.emit({
       type: "agent_created",
       timestamp: Date.now(),
       source: "runtime",
@@ -109,7 +174,7 @@ var AgentXRuntimeImpl = class {
       throw new Error(`Agent already destroyed: ${agentId}`);
     }
     state.lifecycle = "stopped";
-    this.provider.eventBus.emit({
+    this.platform.eventBus.emit({
       type: "agent_stopped",
       timestamp: Date.now(),
       source: "runtime",
@@ -134,7 +199,7 @@ var AgentXRuntimeImpl = class {
       throw new Error(`Cannot resume destroyed agent: ${agentId}`);
     }
     state.lifecycle = "running";
-    this.provider.eventBus.emit({
+    this.platform.eventBus.emit({
       type: "agent_resumed",
       timestamp: Date.now(),
       source: "runtime",
@@ -156,12 +221,13 @@ var AgentXRuntimeImpl = class {
       throw new Error(`Agent not found: ${agentId}`);
     }
     await state.driver.dispose();
+    await state.engine.destroy();
     for (const unsub of state.subscriptions) {
       unsub();
     }
     state.subscriptions.clear();
     state.lifecycle = "destroyed";
-    this.provider.eventBus.emit({
+    this.platform.eventBus.emit({
       type: "agent_destroyed",
       timestamp: Date.now(),
       source: "runtime",
@@ -198,12 +264,12 @@ var AgentXRuntimeImpl = class {
       content,
       timestamp: Date.now()
     };
-    await this.provider.sessionRepository.addMessage(state.agent.sessionId, userMessage);
+    await this.platform.sessionRepository.addMessage(state.agent.sessionId, userMessage);
     this.emitEvent(state, "user_message", userMessage, actualRequestId);
     logger.debug("User message sent", {
       agentId,
       requestId: actualRequestId,
-      contentPreview: typeof content === "string" ? content.substring(0, 50) : `[${content.length} parts]`
+      contentPreview: typeof content === "string" ? content.substring(0, 50) : Array.isArray(content) ? `[${content.length} parts]` : `[${typeof content}]`
     });
     state.isReceiving = true;
     try {
@@ -231,12 +297,7 @@ var AgentXRuntimeImpl = class {
       throw new Error(`Agent not found: ${agentId}`);
     }
     state.driver.interrupt();
-    this.emitEvent(
-      state,
-      "interrupt",
-      { agentId },
-      requestId ?? this.generateRequestId()
-    );
+    this.emitEvent(state, "interrupt", { agentId }, requestId ?? this.generateRequestId());
     logger.debug("Interrupt sent", { agentId, requestId });
   }
   // ==================== Event Subscription ====================
@@ -245,7 +306,7 @@ var AgentXRuntimeImpl = class {
     if (!state) {
       throw new Error(`Agent not found: ${agentId}`);
     }
-    const unsub = this.provider.eventBus.onAny((event) => {
+    const unsub = this.platform.eventBus.onAny((event) => {
       const context = event.context;
       if (context?.agentId === agentId) {
         handler(event);
@@ -260,7 +321,7 @@ var AgentXRuntimeImpl = class {
     };
   }
   subscribeAll(handler) {
-    const unsub = this.provider.eventBus.onAny(handler);
+    const unsub = this.platform.eventBus.onAny(handler);
     this.globalSubscriptions.add(unsub);
     return {
       unsubscribe: () => {
@@ -290,12 +351,14 @@ var AgentXRuntimeImpl = class {
    */
   handleDriverEvent(state, event, requestId) {
     this.emitEvent(state, event.type, event.data, requestId);
+    const streamEvent = toStreamEvent(event);
+    state.engine.handleStreamEvent(streamEvent);
   }
   /**
    * Emit an event to the EventBus
    */
   emitEvent(state, type, data, requestId) {
-    this.provider.eventBus.emit({
+    this.platform.eventBus.emit({
       type,
       timestamp: Date.now(),
       source: "runtime",
@@ -337,8 +400,29 @@ var AgentXRuntimeImpl = class {
     return `msg_${timestamp}_${random}`;
   }
 };
-function createAgentXRuntime(provider) {
-  return new AgentXRuntimeImpl(provider);
+function toStreamEvent(event) {
+  const type = event.type === "error" ? "error_received" : event.type;
+  return { type, data: event.data, timestamp: Date.now() };
+}
+function categorizeAgentOutput(type) {
+  const streamTypes = [
+    "message_start",
+    "message_delta",
+    "message_stop",
+    "text_delta",
+    "tool_use_start",
+    "input_json_delta",
+    "tool_use_stop",
+    "tool_result",
+    "error_received"
+  ];
+  if (streamTypes.includes(type)) return "stream";
+  if (type.endsWith("_message")) return "message";
+  if (type.startsWith("turn_")) return "turn";
+  return "state";
+}
+function createAgentXRuntime(platform, createDriver) {
+  return new AgentXRuntimeImpl(platform, createDriver);
 }
 export {
   AgentXRuntimeImpl,