@standardagents/builder 0.26.0 → 0.27.1

package/dist/runtime.d.ts

@@ -204,6 +204,8 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
     private messageSockets;
     private bridgeSockets;
     private bridgeLastSeen;
+    private bridgeClientInfo;
+    private executionOwnerCache;
     private pendingClientCalls;
     private alarmQueue;
     private alarmQueueRearmed;
@@ -992,6 +994,29 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
      * user's own machine.
      */
     private handleBridgeWebSocketUpgrade;
+    /** Parse a raw KV value into an {@link ExecutionOwner}, or null. */
+    private parseExecutionOwner;
+    /** Load (and cache) the thread's persisted execution-owner record. */
+    private getExecutionOwner;
+    /** Owner id from the in-memory mirror only (for sync paths); null when
+     *  unloaded or unowned — both degrade to the historical any-socket rule. */
+    private currentExecutionOwnerId;
+    /** Persist + cache the execution-owner record (null releases ownership). */
+    private setExecutionOwner;
+    /** Whether the given client id has a live bridge socket (excluding `except`). */
+    private hasLiveBridgeSocketForClient;
+    /** Tell every other bridge socket that execution ownership moved. */
+    private broadcastOwnerChanged;
+    /** Whether any forwarded call is mid-flight (blocking await or parked). */
+    hasInFlightClientCalls(): Promise<boolean>;
+    /**
+     * Ownership moved away from a dead client: settle everything that was
+     * dispatched to it. In-memory blocking calls fail immediately; parked
+     * durable calls get an error result and the turn resumes — re-sending them
+     * to the NEW owner would silently re-run the operation on a different
+     * machine's filesystem, which is worse than an honest retryable error.
+     */
+    private failStalePendingWork;
     /**
      * Forward a tool operation to a connected bridge client and await its result.
      *
@@ -1005,23 +1030,31 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
     /** Close and forget a bridge socket we've deemed dead, failing remaining calls. */
     private markBridgeDead;
     /**
-     * Return the first bridge socket that is open AND still proving liveness,
-     * pruning dead ones. A half-open client (idle NAT/proxy drop) keeps a
+     * Return the bridge socket a forwarded call should be dispatched to, pruning
+     * dead ones. A half-open client (idle NAT/proxy drop) keeps a
      * `readyState === OPEN` socket that never fires close/error, so we also treat
      * a socket we haven't heard from within {@link BRIDGE_LIVENESS_TIMEOUT_MS} as
      * dead. The CLI heartbeats every few seconds, so this only trips on a truly
      * gone client — and it means we won't dispatch a forwarded call into the void.
+     *
+     * With an execution owner recorded, only the owner's socket (or, as a
+     * back-compat fallback, an unidentified legacy socket) is eligible; with no
+     * owner, the first live socket wins as it always has.
      */
     private getOpenBridgeSocket;
     /** Resolve an in-flight forwarded tool call from a client `tool_response`. */
     private resolveClientCall;
     /**
-     * When the last bridge client disconnects, fail any in-flight forwarded tool
-     * calls so the agent loop doesn't hang waiting on a client that is gone.
+     * When the last bridge client that could serve forwarded calls disconnects,
+     * fail any in-flight ones so the agent loop doesn't hang waiting on a client
+     * that is gone. Uses the in-memory owner mirror (sync path); when the mirror
+     * isn't loaded this degrades to the historical any-socket check, and the
+     * per-call liveness interval still catches a dead dispatch target.
      */
     private failPendingClientCallsIfNoBridge;
-    /** Whether a bridge client is connected right now (used to decide durable park). */
-    hasBridge(): boolean;
+    /** Whether a bridge client that can execute forwarded calls is connected
+     *  right now (used to decide durable park). */
+    hasBridge(): Promise<boolean>;
     private ensurePendingClientTable;
     /**
      * Durably dispatch a forwarded tool call WITHOUT blocking the agent loop.
@@ -1032,7 +1065,13 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
     dispatchClientTool(request: ClientToolRequest, toolCallId: string, side: "a" | "b"): Promise<{
         dispatched: boolean;
     }>;
-    /** Send one durable `tool_request` frame to the bridge if a client is connected. */
+    /**
+     * Send one durable `tool_request` frame to the bridge if a client is
+     * connected — and stamp the pending row with the identity+generation it was
+     * dispatched to, fencing the eventual HTTP delivery to that client. A
+     * legacy (unidentified) executor leaves the row unstamped, keeping the
+     * historical accept-anything delivery for old CLIs.
+     */
     private sendClientToolRequest;
     /** Still-pending durable forwarded calls (for re-sending after a reconnect). */
     getPendingClientCalls(): Promise<Array<{
@@ -1050,7 +1089,7 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
      * call resolved. Returns the side to continue, or null if there is no pending
      * call (unknown id or already resolved — the delivery is idempotent).
      */
-    deliverClientToolResult(toolCallId: string, ok: boolean, result?: string, error?: string): Promise<{
+    deliverClientToolResult(toolCallId: string, ok: boolean, result?: string, error?: string, deliveredByClientId?: string, deliveredGeneration?: number): Promise<{
         side: "a" | "b";
     } | null>;
     /**
@@ -1855,6 +1894,27 @@ declare class DurableAgentBuilder<Env extends AgentBuilderEnv = AgentBuilderEnv>
         env_type_patch?: Record<string, unknown> | null;
         env_delete?: string[] | null;
     }): Promise<void>;
+    private assertValidUserValueKey;
+    private assertValidUserValueUserId;
+    /** Read one JSON value from a user's account-wide key-value store. */
+    getUserValue(userId: string, key: string): Promise<unknown | null>;
+    /** Write one JSON value to a user's account-wide store; null/undefined deletes. */
+    setUserValue(userId: string, key: string, value: unknown): Promise<void>;
+    /** List a user's account-wide values, optionally filtered by key prefix. */
+    listUserValues(userId: string, options?: {
+        prefix?: string | null;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        entries: Array<{
+            key: string;
+            value: unknown;
+            updated_at: number;
+        }>;
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
     getMissingRequiredScopedSubagentEnv(params: {
         parent_thread_id: string;
         agent_name: string;