@agent-play/sdk 3.0.1 → 3.1.0

package/dist/index.d.ts

@@ -1,251 +1,33 @@
-/**
- * Domain types for sessions, journeys, agents, and the shared world map exposed by the SDK and server.
- */
-/** Role for a single line in the interaction log / chat stream. */
-type WorldInteractionRole = "user" | "assistant" | "tool";
-/**
- * Payload for {@link import("./lib/remote-play-world.js").RemotePlayWorld.recordInteraction}.
- *
- * @property playerId - Player id returned from `addPlayer`.
- * @property role - Who "spoke" the line.
- * @property text - Plain text; may be truncated for display server-side.
- */
-type RecordInteractionInput = {
-    playerId: string;
-    role: WorldInteractionRole;
-    text: string;
-};
-/**
- * Metadata for a tool whose name starts with `assist_`, shown as assist actions on the watch UI.
- *
- * @property parameters - Derived from Zod object `schema` when present; placeholder hints otherwise.
- */
-type AssistToolSpec = {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-};
-/**
- * Serializable shape returned by {@link import("./platforms/langchain.js").langchainRegistration} for `addPlayer`.
- *
- * @property type - Always `"langchain"` for this adapter.
- * @property toolNames - All tool names from the agent (must include `chat_tool`).
- * @property assistTools - Subset of tools with `assist_` prefix, for UI buttons.
- */
-type LangChainAgentRegistration = {
-    type: "langchain";
-    toolNames: string[];
-    assistTools?: AssistToolSpec[];
-};
-/** Minimal player identity in the SDK (without preview URL). */
-type PlayAgentInformation = {
-    id: string;
-    name: string;
-    sid: string;
-    createdAt: Date;
-    updatedAt: Date;
-};
-/** Input fields for `addPlayer` before `agent` is attached. */
-type PlatformAgentInformation = {
-    name: string;
-    type: string;
-    version?: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-};
-/**
- * Register a player (agent) in the world.
- *
- * Use **`langchainRegistration(agent)`** for `agent` (requires a **`chat_tool`** tool; `assist_*`
- * tools are indexed for the watch UI).
- *
- * **`agentId`** is required: use an id from **`agent-play create`** when the server uses a repository
- * (with **`apiKey`** from **`RemotePlayWorld`**), or any stable string for local dev without Redis.
- */
-type AddPlayerInput = PlatformAgentInformation & {
-    /** Registration from {@link import("./platforms/langchain.js").langchainRegistration}. */
-    agent: LangChainAgentRegistration;
-    /** Registered agent id (or session-local id without Redis). */
-    agentId: string;
-};
-/** Zone counter event surfaced on snapshots and signals. */
-type ZoneEventInfo = {
-    zoneCount: number;
-    flagged?: boolean;
-    at: string;
-};
-/** Yield counter event surfaced on snapshots and signals. */
-type YieldEventInfo = {
-    yieldCount: number;
-    at: string;
-};
-/** Repository-backed summary returned with `addPlayer` when the agent is (or maps to) a stored registration. */
-type RegisteredAgentSummary = {
-    agentId: string;
-    name: string;
-    toolNames: string[];
-    zoneCount: number;
-    yieldCount: number;
-    flagged: boolean;
-};
-/** Result of `addPlayer` including watch URL and registered-agent metadata from the server. */
-type RegisteredPlayer = PlayAgentInformation & {
-    previewUrl: string;
-    registeredAgent: RegisteredAgentSummary;
-};
-/** First step of a journey: user message origin. */
-type OriginJourneyStep = {
-    type: "origin";
-    content: string;
-    messageId: string;
-};
-/** Middle step: tool invocation on the map. */
-type StructureJourneyStep = {
-    type: "structure";
-    toolName: string;
-    toolCallId: string;
-    args: Record<string, unknown>;
-    result?: string;
-};
-/** Final step: assistant reply. */
-type DestinationJourneyStep = {
-    type: "destination";
-    content: string;
-    messageId: string;
-};
-/** Union of journey step shapes. */
-type JourneyStep = OriginJourneyStep | StructureJourneyStep | DestinationJourneyStep;
-/**
- * Ordered journey with timestamps; sent to the server via `recordJourney`.
- *
- * @property steps - Ordered path from origin through tool steps to destination.
- * @property startedAt, completedAt - Wall times for the run (client or server).
- */
-type Journey = {
-    steps: JourneyStep[];
-    startedAt: Date;
-    completedAt: Date;
-};
-/** Journey step after server assigns coordinates (and optional structure id). */
-type PositionedStep = JourneyStep & {
-    x?: number;
-    y?: number;
-    structureId?: string;
-};
-type AgentPlayWorldMapBounds = {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-/**
- * One agent on the world map. Coordinates are grid positions; the server enforces unique `(x,y)` per occupant.
- */
-type AgentPlayWorldMapAgentOccupant = {
-    kind: "agent";
-    agentId: string;
-    name: string;
-    x: number;
-    y: number;
-    /**
-     * Integration label from addPlayer `type` (e.g. `langchain`). Populated from the snapshot field `platform`. The legacy wire field `agentType` is deprecated and accepted only for backward compatibility when parsing JSON.
-     */
-    platform?: string;
-    toolNames?: string[];
-    assistToolNames?: string[];
-    assistTools?: AssistToolSpec[];
-    hasChatTool?: boolean;
-    stationary?: boolean;
-    lastUpdate?: unknown;
-    recentInteractions?: Array<{
-        role: WorldInteractionRole;
-        text: string;
-        at: string;
-        seq: number;
-    }>;
-    zoneCount?: number;
-    yieldCount?: number;
-    flagged?: boolean;
-    onZone?: ZoneEventInfo;
-    onYield?: YieldEventInfo;
-};
-/** MCP server shown as a separate map occupant (distinct from LangChain agents). */
-type AgentPlayWorldMapMcpOccupant = {
-    kind: "mcp";
-    id: string;
-    name: string;
-    x: number;
-    y: number;
-    url?: string;
-};
-/** Spatial index: axis-aligned bounds plus every agent and MCP registration placed on the grid. */
-type AgentPlayWorldMap = {
-    bounds: AgentPlayWorldMapBounds;
-    occupants: (AgentPlayWorldMapAgentOccupant | AgentPlayWorldMapMcpOccupant)[];
-};
-/**
- * Session snapshot from {@link import("./lib/remote-play-world.js").RemotePlayWorld.getWorldSnapshot}.
- * Agents and MCP servers appear only under **`worldMap.occupants`** (no separate `players` list).
- */
-type AgentPlaySnapshot = {
-    sid: string;
-    worldMap: AgentPlayWorldMap;
-    mcpServers?: Array<{
-        id: string;
-        name: string;
-        url?: string;
-    }>;
-};
-type PlayerChainNotifyNodeRef = {
-    stableKey: string;
-    leafIndex: number;
-    removed?: boolean;
-    updatedAt?: string;
-};
-type PlayerChainFanoutNotify = {
-    updatedAt: string;
-    nodes: PlayerChainNotifyNodeRef[];
-};
-type PlayerChainGenesisStableKey = "__genesis__";
-type PlayerChainHeaderStableKey = "__header__";
-type PlayerChainGenesisNode = {
-    kind: "genesis";
-    stableKey: PlayerChainGenesisStableKey;
-    text: string;
-};
-type PlayerChainHeaderNode = {
-    kind: "header";
-    stableKey: PlayerChainHeaderStableKey;
-    sid: string;
-    bounds: AgentPlayWorldMapBounds;
-};
-type PlayerChainOccupantRemovedNode = {
-    kind: "occupant";
-    stableKey: string;
-    removed: true;
-};
-type PlayerChainOccupantPresentNode = {
-    kind: "occupant";
-    stableKey: string;
-    removed: false;
-    occupant: AgentPlayWorldMapAgentOccupant | AgentPlayWorldMapMcpOccupant;
-};
-type PlayerChainNodeResponse = PlayerChainGenesisNode | PlayerChainHeaderNode | PlayerChainOccupantRemovedNode | PlayerChainOccupantPresentNode;
-/** Full journey + path update (SSE `world:journey`); coordinates are embedded in `path` steps. */
-type WorldJourneyUpdate = {
-    playerId: string;
-    journey: Journey;
-    path: PositionedStep[];
-};
+import { W as WorldInteractionRole, L as LangChainAgentRegistration, A as AgentPlaySnapshot, P as PlayerChainNodeResponse, a as AddAgentInput, R as RegisteredPlayer, b as AddPlayerInput, c as RecordInteractionInput, J as Journey } from './browser-C8UKcztD.js';
+export { d as AgentPlayWorldMap, e as AgentPlayWorldMapAgentOccupant, f as AgentPlayWorldMapBounds, g as AgentPlayWorldMapMcpOccupant, h as AssistToolFieldType, i as AssistToolParameterSpec, j as AssistToolSpec, D as DestinationJourneyStep, k as JourneyStep, O as OriginJourneyStep, l as PLAYER_CHAIN_GENESIS_STABLE_KEY, m as PLAYER_CHAIN_HEADER_STABLE_KEY, n as PlatformAgentInformation, o as PlayAgentInformation, p as PlayerChainFanoutNotify, q as PlayerChainGenesisNode, r as PlayerChainHeaderNode, s as PlayerChainNotifyNodeRef, t as PlayerChainOccupantPresentNode, u as PlayerChainOccupantRemovedNode, v as PositionedStep, w as RegisteredAgentSummary, S as StructureJourneyStep, x as WorldBounds, y as WorldJourneyUpdate, Y as YieldEventInfo, Z as ZoneEventInfo, z as boundsContain, B as clampWorldPosition, C as mergeSnapshotWithPlayerChainNode, E as parsePlayerChainFanoutNotify, F as parsePlayerChainFanoutNotifyFromSsePayload, G as parsePlayerChainNodeRpcBody, H as sortNodeRefsForSerializedFetch } from './browser-C8UKcztD.js';
+import { WorldIntercomEventPayload, IntercomResponsePayload } from '@agent-play/intercom';
+export { AgentPlayAgentNodeEntry, AgentPlayCredentialsFile, loadAgentPlayCredentialsFileFromPath, loadAgentPlayCredentialsFileFromPathSync, loadRootKey, nodeCredentialsMaterialFromHumanPassphrase, parseAgentPlayCredentialsJson, resolveAgentPlayCredentialsPath } from '@agent-play/node-tools';
 
 /**
  * String constants and payload shapes for SSE and in-process world events.
  *
  * @remarks **Emitters:** server `PlayWorld` and Redis fanout. **Consumers:** watch UI `EventSource`,
  * integration tests, and any host that forwards `POST` events.
+ *
+ * **Session vs world:** names prefixed with **`session:`** concern the HTTP/SDK session (`sid`) and
+ * transport; names prefixed with **`world:`** concern occupants, chat, and map-visible state.
  */
 
-/** Fired when `addPlayer` completes; payload includes snapshot row for the new player. */
+/** After `RemotePlayWorld.connect()` assigns a `sid` (and optional detail such as `sid`). */
+declare const SESSION_CONNECTED_EVENT = "session:connected";
+/** RPC or transport rejected the session (e.g. 401/403); optional `detail.status`. */
+declare const SESSION_INVALID_EVENT = "session:invalid";
+/** After `RemotePlayWorld.close()` completes teardown. */
+declare const SESSION_CLOSED_EVENT = "session:closed";
+/** SSE subscription opened (optional; emitted when wired). */
+declare const SESSION_SSE_OPEN_EVENT = "session:sse_open";
+/** SSE subscription error (optional; emitted when wired). */
+declare const SESSION_SSE_ERROR_EVENT = "session:sse_error";
+type RemotePlayWorldSessionEvent = {
+    name: string;
+    detail?: Record<string, unknown>;
+};
+/** Fired when `addAgent` / `addPlayer` completes; payload includes snapshot row for the new player. */
 declare const PLAYER_ADDED_EVENT = "world:player_added";
 /** Fired for each new chat/interaction line. */
 declare const WORLD_INTERACTION_EVENT = "world:interaction";
@@ -278,49 +60,6 @@ type WorldInteractionPayload = {
     seq: number;
 };
 
-/**
- * Axis-aligned rectangle in world coordinates (grid units). Used by the server to clamp paths
- * and by the watch UI to clamp joystick-driven movement.
- *
- * @remarks **Consumers:** {@link clampWorldPosition}, {@link boundsContain}; server `PlayWorld` and
- * play-ui canvas both import these helpers from `@agent-play/sdk`.
- */
-type WorldBounds = {
-    /** Inclusive minimum X. */
-    minX: number;
-    /** Inclusive minimum Y. */
-    minY: number;
-    /** Inclusive maximum X. */
-    maxX: number;
-    /** Inclusive maximum Y. */
-    maxY: number;
-};
-/**
- * Clamps a point to lie inside `bounds` along both axes.
- *
- * @param p - Position with `x` and `y` in world units.
- * @param bounds - Valid rectangle (`min` ≤ `max` per axis).
- * @returns Same point if inside, otherwise clamped to the nearest edge.
- *
- * @remarks **Callers:** server `PlayWorld` path enrichment; play-ui joystick and preview. **Callees:** `Math.min/Math.max`.
- */
-declare function clampWorldPosition(p: {
-    x: number;
-    y: number;
-}, bounds: WorldBounds): {
-    x: number;
-    y: number;
-};
-/**
- * @returns Whether `p` lies inside or on the border of `bounds`.
- *
- * @remarks **Callers:** optional UI checks. **Callees:** none.
- */
-declare function boundsContain(bounds: WorldBounds, p: {
-    x: number;
-    y: number;
-}): boolean;
-
 /**
  * Optional structured `console.debug` for SDK internals; gated by {@link configureAgentPlayDebug} or `AGENT_PLAY_DEBUG=1`.
  */
@@ -331,7 +70,7 @@ type DebugConfigure = {
 /**
  * Sets whether SDK debug logging is enabled regardless of `AGENT_PLAY_DEBUG`.
  *
- * @param opts.debug - `true` / `false` to force; omit to clear override.
+ * @param opts - Optional `{ debug }`: `true` / `false` forces logging; omit `debug` to clear override.
  *
  * @remarks **Callers:** tests and user code. **Callees:** none.
  */
@@ -353,51 +92,116 @@ declare function isAgentPlayDebugEnabled(): boolean;
  *
  * @param scope - Short label (e.g. `"langchain"`).
  * @param message - Human-readable message.
- * @param detail - Optional object serialized by {@link safeSerialize}.
+ * @param detail - Optional object serialized by the internal truncation helper (see source).
  *
- * @remarks **Callers:** {@link langchainRegistration} and other SDK modules. **Callees:** {@link isAgentPlayDebugEnabled}, {@link safeSerialize}.
+ * @remarks **Callers:** {@link langchainRegistration} and other SDK modules. **Callees:** {@link isAgentPlayDebugEnabled} and the internal serializer.
  */
 declare function agentPlayDebug(scope: string, message: string, detail?: unknown): void;
 
 /**
  * Validates a LangChain-style agent exposes tools (including required `chat_tool`) and returns
- * a {@link LangChainAgentRegistration} for `addPlayer`.
+ * a {@link LangChainAgentRegistration} for `RemotePlayWorld.addAgent`.
  *
  * @param agent - Return value from `createAgent` (or equivalent) with a `tools` array.
  * @throws Error if tools are missing or `chat_tool` is not present.
  *
- * @remarks **Callers:** user code before `RemotePlayWorld.addPlayer`. **Callees:** {@link extractToolsArray},
- * {@link formatMissingAgentToolsError}, {@link formatMissingChatToolError}, {@link describeTool}, {@link agentPlayDebug}.
+ * @remarks **Callers:** user code before `RemotePlayWorld.addAgent`. **Callees:** internal validation helpers and {@link agentPlayDebug}.
  */
 declare function langchainRegistration(agent: unknown): LangChainAgentRegistration;
 
+/**
+ * Root key (from `.root`) plus **human** passphrase as stored in **`~/.agent-play/credentials.json`**
+ * after **`agent-play create-main-node`**. Material for node id and wire auth is
+ * **`nodeCredentialsMaterialFromHumanPassphrase(passw)`** (SHA-256 hex; same as CLI **`hashNodePassword`**).
+ */
+type RemotePlayWorldNodeCredentials = {
+    rootKey: string;
+    passw: string;
+};
+type RemotePlayWorldLogging = "off" | "on";
 type RemotePlayWorldOptions = {
-    baseUrl: string;
-    apiKey: string;
-    authToken?: string;
+    baseUrl?: string;
+    /**
+     * `rootKey` from `.root` and **`passw`** human phrase from **`credentials.json`** (see **`loadAgentPlayCredentialsFileFromPathSync`** in **@agent-play/node-tools**).
+     */
+    nodeCredentials?: RemotePlayWorldNodeCredentials;
+    /** Called for session lifecycle events (`session:connected`, `session:closed`; see `world-events`). */
+    onSessionEvent?: (event: RemotePlayWorldSessionEvent) => void;
+    /**
+     * When **`"on"`**, prints **`console.info`** lines for session events, SSE messages, intercom command matching/skips, and **`sendIntercomResponse`** payloads (for request tracing). Default **`"off"`**.
+     */
+    logging?: RemotePlayWorldLogging;
+};
+/** Options for {@link RemotePlayWorld.connect}. */
+type RemotePlayWorldConnectOptions = {
+    /**
+     * Parent **main** node id. When set, `connect` runs `POST /api/nodes/validate` first, then `GET /api/agent-play/session`.
+     * When omitted, only `GET /api/agent-play/session` runs.
+     */
+    mainNodeId?: string;
 };
 type RemotePlayWorldHold = {
     for: (seconds: number) => Promise<void>;
 };
+type IntercomToolExecutor = (input: {
+    toolName: string;
+    args: Record<string, unknown>;
+}) => Record<string, unknown> | Promise<Record<string, unknown>>;
+type SubscribeIntercomChatAgents = {
+    /**
+     * Same LangChain agent instances passed to **`langchainRegistration`** (e.g. **`createAgent`** return values).
+     * For **`kind: chat`**, **`invoke({ messages: [HumanMessage(text)] })`** is called with **`.call(agent, input)`** (no wrapping).
+     */
+    chatAgentsByPlayerId?: ReadonlyMap<string, unknown>;
+};
+type SubscribeIntercomCommandsOptions = ({
+    playerId: string;
+    executeTool: IntercomToolExecutor;
+} & SubscribeIntercomChatAgents) | ({
+    playerIds: readonly string[];
+    executeTool: IntercomToolExecutor;
+} & SubscribeIntercomChatAgents);
 /**
  * HTTP client for the Agent Play web UI: session, snapshot RPC, mutating RPC with `sid`, and optional SSE subscription.
  *
+ * Authenticates like the CLI: **`x-node-id`** (derived node id) and **`x-node-passw`** (hashed passphrase material) on every request.
+ *
+ * Register automation agents with {@link RemotePlayWorld.addAgent} (`nodeId` is the agent node id; the server stores it as `agentId`).
+ *
  * Incremental updates: {@link RemotePlayWorld.subscribeWorldState} listens for **`playerChainNotify`** in SSE `data`, then fetches each changed leaf via {@link RemotePlayWorld.getPlayerChainNode} and merges with {@link mergeSnapshotWithPlayerChainNode}.
+ *
+ * Human→agent intercom (Assist/Chat from the watch UI) is delivered as SSE **`world:intercom`** payloads with status **`forwarded`**. Call {@link RemotePlayWorld.subscribeIntercomCommands} with **`playerId`** or **`playerIds`** (one SSE stream; routes **`forwarded`** commands by **`toPlayerId`**) so your process runs tools and posts **`intercomResponse`** via {@link RemotePlayWorld.sendIntercomResponse} (the subscription does this when **`executeTool`** resolves).
+ *
+ * Set **`logging: "on"`** to trace **`forwarded`** commands for subscribed ids and **`sendIntercomResponse`** HTTP results.
  */
 declare class RemotePlayWorld {
     private readonly apiBase;
-    private readonly apiKey;
-    private readonly authToken;
+    private readonly rootKey;
+    /** Node id derived from hashed passphrase material + root (main or agent node id). */
+    private readonly derivedNodeId;
+    /** Hex password material (`hashNodePassword` on normalized human phrase); sent as `password` for repository addAgent. */
+    private readonly password;
+    private readonly onSessionEvent;
+    private readonly transportLog;
     private sid;
     private closed;
     private readonly closeListeners;
-    constructor(options: RemotePlayWorldOptions);
+    private readonly playerConnectionInfo;
+    constructor(options?: RemotePlayWorldOptions);
+    private logTransport;
+    private truncateForLog;
+    private emitSessionEvent;
     onClose(handler: () => void): () => void;
     hold(): RemotePlayWorldHold;
     private authHeaders;
     private jsonHeaders;
     private mergeAuthFetch;
-    connect(): Promise<void>;
+    private validateNodeIdentity;
+    /**
+     * Establishes the HTTP session via `GET /api/agent-play/session`. With {@link RemotePlayWorldConnectOptions.mainNodeId},
+     * validates node identity with `POST /api/nodes/validate` first.
+     */
+    connect(options?: RemotePlayWorldConnectOptions): Promise<void>;
     close(): Promise<void>;
     getSessionId(): string;
     getPreviewUrl(): string;
@@ -412,30 +216,41 @@ declare class RemotePlayWorld {
     subscribeWorldState(callbacks: {
         onSnapshot: (snapshot: AgentPlaySnapshot) => void;
         onError?: (err: Error) => void;
+        onIntercomEvent?: (payload: WorldIntercomEventPayload) => void;
     }): {
         close: () => void;
     };
+    /**
+     * Registers an automation agent using **agent node id** (`nodeId`), sent to the server as `agentId`.
+     */
+    addAgent(input: AddAgentInput): Promise<RegisteredPlayer>;
+    /**
+     * @deprecated Use {@link addAgent} with `nodeId` (agent node id) for integrations and automation.
+     */
     addPlayer(input: AddPlayerInput): Promise<RegisteredPlayer>;
     recordInteraction(input: RecordInteractionInput): Promise<void>;
     recordJourney(playerId: string, journey: Journey): Promise<void>;
+    sendIntercomResponse(payload: IntercomResponsePayload): Promise<void>;
+    /**
+     * Subscribes to the session SSE stream and handles **`forwarded`** intercom commands whose **`toPlayerId`** is in **`playerId`** or **`playerIds`**, invoking **`executeTool`** and posting **`intercomResponse`** (**`completed`** / **`failed`**).
+     * Uses a **single** SSE connection when **`playerIds`** lists multiple automation agents (recommended for several agents in one process).
+     * Not invoked automatically by {@link RemotePlayWorld.addAgent}.
+     */
+    subscribeIntercomCommands(options: SubscribeIntercomCommandsOptions): {
+        close: () => void;
+    };
     registerMcp(options: {
         name: string;
         url?: string;
     }): Promise<string>;
     private rpc;
+    private heartbeatPlayerConnection;
+    private disconnectPlayerConnection;
 }
 
 /**
- * Parses **`playerChainNotify`** envelopes and merges {@link PlayerChainNodeResponse} slices into {@link AgentPlaySnapshot} (pure functions + fetch ordering for serialized RPC).
+ * Maps a LangChain agent **`invoke`** result to a plain object suitable for **`intercomResponse`** **`result`**.
  */
+declare function intercomResultRecordFromLangChainInvokeOutput(output: unknown): Record<string, unknown>;
 
-declare function sortNodeRefsForSerializedFetch(nodes: ReadonlyArray<PlayerChainNotifyNodeRef>): PlayerChainNotifyNodeRef[];
-declare function parsePlayerChainFanoutNotify(raw: unknown): PlayerChainFanoutNotify | undefined;
-declare function parsePlayerChainFanoutNotifyFromSsePayload(sseData: unknown): PlayerChainFanoutNotify | undefined;
-declare function parsePlayerChainNodeRpcBody(json: unknown): PlayerChainNodeResponse;
-declare function mergeSnapshotWithPlayerChainNode(snapshot: AgentPlaySnapshot, node: PlayerChainNodeResponse): AgentPlaySnapshot;
-
-declare const PLAYER_CHAIN_GENESIS_STABLE_KEY: "__genesis__";
-declare const PLAYER_CHAIN_HEADER_STABLE_KEY: "__header__";
-
-export { type AddPlayerInput, type AgentPlaySnapshot, type AgentPlayWorldMap, type AgentPlayWorldMapAgentOccupant, type AgentPlayWorldMapBounds, type AgentPlayWorldMapMcpOccupant, type AssistToolSpec, type DestinationJourneyStep, type Journey, type JourneyStep, type LangChainAgentRegistration, type OriginJourneyStep, PLAYER_ADDED_EVENT, PLAYER_CHAIN_GENESIS_STABLE_KEY, PLAYER_CHAIN_HEADER_STABLE_KEY, type PlatformAgentInformation, type PlayAgentInformation, type PlayerChainFanoutNotify, type PlayerChainGenesisNode, type PlayerChainHeaderNode, type PlayerChainNodeResponse, type PlayerChainNotifyNodeRef, type PlayerChainOccupantPresentNode, type PlayerChainOccupantRemovedNode, type PositionedStep, type RecordInteractionInput, type RegisteredAgentSummary, type RegisteredPlayer, RemotePlayWorld, type RemotePlayWorldHold, type RemotePlayWorldOptions, type StructureJourneyStep, WORLD_AGENT_SIGNAL_EVENT, WORLD_INTERACTION_EVENT, WORLD_JOURNEY_EVENT, type WorldAgentSignalPayload, type WorldBounds, type WorldInteractionPayload, type WorldInteractionRole, type WorldJourneyUpdate, type YieldEventInfo, type ZoneEventInfo, agentPlayDebug, boundsContain, clampWorldPosition, configureAgentPlayDebug, isAgentPlayDebugEnabled, langchainRegistration, mergeSnapshotWithPlayerChainNode, parsePlayerChainFanoutNotify, parsePlayerChainFanoutNotifyFromSsePayload, parsePlayerChainNodeRpcBody, resetAgentPlayDebug, sortNodeRefsForSerializedFetch };
+export { AddAgentInput, AddPlayerInput, AgentPlaySnapshot, type IntercomToolExecutor, Journey, LangChainAgentRegistration, PLAYER_ADDED_EVENT, PlayerChainNodeResponse, RecordInteractionInput, RegisteredPlayer, RemotePlayWorld, type RemotePlayWorldConnectOptions, type RemotePlayWorldHold, type RemotePlayWorldLogging, type RemotePlayWorldNodeCredentials, type RemotePlayWorldOptions, type RemotePlayWorldSessionEvent, SESSION_CLOSED_EVENT, SESSION_CONNECTED_EVENT, SESSION_INVALID_EVENT, SESSION_SSE_ERROR_EVENT, SESSION_SSE_OPEN_EVENT, type SubscribeIntercomCommandsOptions, WORLD_AGENT_SIGNAL_EVENT, WORLD_INTERACTION_EVENT, WORLD_JOURNEY_EVENT, type WorldAgentSignalPayload, type WorldInteractionPayload, WorldInteractionRole, agentPlayDebug, configureAgentPlayDebug, intercomResultRecordFromLangChainInvokeOutput, isAgentPlayDebugEnabled, langchainRegistration, resetAgentPlayDebug };