@loomcycle/client 1.13.0 → 1.16.0

package/README.md

@@ -297,7 +297,7 @@ const forked = (await client.agentDef({
 console.log(`forked def_id=${forked.def_id} hash=${forked.content_sha256}`);
 ```
 
-Operations on AgentDef: `create` / `fork` / `get` / `list` / `promote` / `retire` / **`verify`** (v0.9.x). SkillDef has the same set minus `retire`'s edge cases. See `internal/tools/builtin/agentdef.go` for the canonical input schema; each op enforces the agent's `agent_def_scopes` / `skill_def_scopes` capability gate from the operator yaml.
+Operations on AgentDef: `create` / `fork` / `get` / `list` / `promote` / `retire` / **`verify`** (v0.9.x). SkillDef has the same set minus `retire`'s edge cases. See `internal/tools/builtin/agentdef.go` for the canonical input schema; each op enforces the agent's capability gate from the operator yaml — `agent_def_scopes` for AgentDef, and (RFC BA / v1.14.0) the agent's `skills:` pattern allowlist for SkillDef (the former `skill_def_scopes` gate was removed).
 
 Refusals throw `SubstrateToolRefusedError` (a scope deny / empty body / allowed-tools widening); transport failures throw the usual typed errors (`AuthError`, `UnavailableError`, etc.).
 

package/dist/cjs/client-tools.js

@@ -0,0 +1,119 @@
+"use strict";
+// Client-tool host (RFC BC) — the client side of client-executed tools. Open a
+// persistent WebSocket to loomcycle, register the tools you can run on the
+// user's machine (browser DOM, local FS, shell), and answer the `invoke` frames
+// loomcycle routes to you when an agent of your principal calls one. loomcycle
+// returns your reply to the agent as an ordinary tool result — the agent follows
+// no protocol.
+//
+// Transport note: the adapter is otherwise fetch/SSE-only and takes no WebSocket
+// dependency. connectClientTools uses the global `WebSocket` (browsers, Node
+// 22+); on older Node pass `WebSocketImpl` (e.g. the `ws` package). The bearer
+// rides the `Sec-WebSocket-Protocol` subprotocol (browsers can't set an
+// Authorization header on a WebSocket).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientToolHost = exports.CLIENT_TOOL_SUBPROTOCOL = void 0;
+exports.clientToolsURL = clientToolsURL;
+/** The app-level subprotocol the server negotiates for /v1/client-tools. */
+exports.CLIENT_TOOL_SUBPROTOCOL = "loomcycle.client-tools.v1";
+/**
+ * ClientToolHost owns the WebSocket lifecycle: connect → hello → dispatch each
+ * invoke to onInvoke → reply with a result, with auto-reconnect. Protocol
+ * ping/pong is handled by the WebSocket layer, so there is no app heartbeat.
+ * Construct via LoomcycleClient.connectClientTools; call close() to stop.
+ */
+class ClientToolHost {
+    url;
+    authToken;
+    opts;
+    ws;
+    closed = false;
+    constructor(url, authToken, opts) {
+        this.url = url;
+        this.authToken = authToken;
+        this.opts = opts;
+    }
+    /** Open the connection (called for you by connectClientTools). */
+    start() {
+        this.connect();
+    }
+    /** Stop the host + close the socket; suppresses reconnect. */
+    close() {
+        this.closed = true;
+        this.ws?.close(1000, "client closed");
+    }
+    connect() {
+        if (this.closed)
+            return;
+        const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
+        if (!WS) {
+            throw new Error("connectClientTools: no WebSocket implementation available — pass WebSocketImpl (e.g. the `ws` package) on Node < 22");
+        }
+        const protocols = [exports.CLIENT_TOOL_SUBPROTOCOL];
+        if (this.authToken)
+            protocols.push("bearer." + this.authToken);
+        this.opts.onStatus?.("connecting");
+        const ws = new WS(this.url, protocols);
+        this.ws = ws;
+        ws.onopen = () => {
+            this.opts.onStatus?.("open");
+            this.sendJSON({ type: "hello", client: "@loomcycle/client", tools: this.opts.tools });
+        };
+        ws.onerror = (ev) => this.opts.onError?.(ev);
+        ws.onclose = () => {
+            this.opts.onStatus?.("closed");
+            this.scheduleReconnect();
+        };
+        ws.onmessage = (ev) => void this.onMessage(ev.data);
+    }
+    async onMessage(data) {
+        let frame;
+        try {
+            const text = typeof data === "string" ? data : String(data);
+            frame = JSON.parse(text);
+        }
+        catch {
+            return; // ignore unparseable frames
+        }
+        if (frame.type !== "invoke")
+            return; // hello_ok / anything else — ignore
+        const callId = String(frame.call_id ?? "");
+        try {
+            const output = await this.opts.onInvoke({
+                tool: String(frame.tool ?? ""),
+                input: frame.input,
+                callId,
+                runId: frame.run_id,
+                agentId: frame.agent_id,
+            });
+            this.sendJSON({ type: "result", call_id: callId, ok: true, output });
+        }
+        catch (e) {
+            this.sendJSON({
+                type: "result",
+                call_id: callId,
+                ok: false,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    sendJSON(v) {
+        try {
+            this.ws?.send(JSON.stringify(v));
+        }
+        catch (e) {
+            this.opts.onError?.(e);
+        }
+    }
+    scheduleReconnect() {
+        if (this.closed || this.opts.reconnect === false)
+            return;
+        const delay = this.opts.reconnectDelayMs ?? 2000;
+        setTimeout(() => this.connect(), delay);
+    }
+}
+exports.ClientToolHost = ClientToolHost;
+/** Build the ws(s):// URL for the client-tool endpoint from an http(s) base. */
+function clientToolsURL(baseUrl) {
+    return baseUrl.replace(/\/$/, "").replace(/^http/, "ws") + "/v1/client-tools";
+}

package/dist/cjs/client.js

@@ -29,6 +29,7 @@ exports.LoomcycleClient = void 0;
 const fetch_helpers_js_1 = require("./fetch-helpers.js");
 const stream_js_1 = require("./stream.js");
 const interactive_js_1 = require("./interactive.js");
+const client_tools_js_1 = require("./client-tools.js");
 /** samplingToWire maps the camelCase SamplingOptions to the snake_case wire
  *  object, omitting unset fields so they inherit the agent's value. */
 function samplingToWire(s) {
@@ -467,6 +468,16 @@ class LoomcycleClient {
     exportSnapshotURL(snapshotId) {
         return `${this.ctx.baseUrl}/v1/_snapshots/${encodeURIComponent(snapshotId)}/export`;
     }
+    /** Open a client-tool host (RFC BC): a persistent WebSocket over which this
+     *  client registers tools it runs on the user's machine + answers the
+     *  agent's tool calls. Returns a started {@link ClientToolHost}; call
+     *  `.close()` to stop. Uses the global WebSocket (browsers, Node 22+); pass
+     *  `WebSocketImpl` (e.g. the `ws` package) on older Node. */
+    connectClientTools(opts) {
+        const host = new client_tools_js_1.ClientToolHost((0, client_tools_js_1.clientToolsURL)(this.ctx.baseUrl), this.ctx.authToken, opts);
+        host.start();
+        return host;
+    }
     /** Restore from a same-instance snapshot id OR an inline
      *  envelope JSON. Idempotent: ON CONFLICT DO NOTHING per row;
      *  the returned counters reflect rows actually written.

package/dist/cjs/index.js

@@ -92,11 +92,15 @@
  * See `adapters/ts/README.md` for usage examples.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnavailableError = exports.SubstrateToolRefusedError = exports.SnapshotVersionError = exports.SnapshotTooLargeError = exports.SnapshotNotFoundError = exports.SessionNotFoundError = exports.SessionBusyError = exports.PerUserQuotaExhaustedError = exports.PauseNotConfiguredError = exports.NotPausedError = exports.LoomcycleError = exports.ChannelCursorRegressionError = exports.InvalidArgumentError = exports.NotFoundError = exports.HookNotFoundError = exports.BackpressureError = exports.AuthError = exports.AlreadyPausingError = exports.AgentNotFoundError = exports.AgentIDInUseError = exports.InteractiveSession = exports.LoomcycleClient = void 0;
+exports.UnavailableError = exports.SubstrateToolRefusedError = exports.SnapshotVersionError = exports.SnapshotTooLargeError = exports.SnapshotNotFoundError = exports.SessionNotFoundError = exports.SessionBusyError = exports.PerUserQuotaExhaustedError = exports.PauseNotConfiguredError = exports.NotPausedError = exports.LoomcycleError = exports.ChannelCursorRegressionError = exports.InvalidArgumentError = exports.NotFoundError = exports.HookNotFoundError = exports.BackpressureError = exports.AuthError = exports.AlreadyPausingError = exports.AgentNotFoundError = exports.AgentIDInUseError = exports.CLIENT_TOOL_SUBPROTOCOL = exports.clientToolsURL = exports.ClientToolHost = exports.InteractiveSession = exports.LoomcycleClient = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "LoomcycleClient", { enumerable: true, get: function () { return client_js_1.LoomcycleClient; } });
 var interactive_js_1 = require("./interactive.js");
 Object.defineProperty(exports, "InteractiveSession", { enumerable: true, get: function () { return interactive_js_1.InteractiveSession; } });
+var client_tools_js_1 = require("./client-tools.js");
+Object.defineProperty(exports, "ClientToolHost", { enumerable: true, get: function () { return client_tools_js_1.ClientToolHost; } });
+Object.defineProperty(exports, "clientToolsURL", { enumerable: true, get: function () { return client_tools_js_1.clientToolsURL; } });
+Object.defineProperty(exports, "CLIENT_TOOL_SUBPROTOCOL", { enumerable: true, get: function () { return client_tools_js_1.CLIENT_TOOL_SUBPROTOCOL; } });
 var errors_js_1 = require("./errors.js");
 Object.defineProperty(exports, "AgentIDInUseError", { enumerable: true, get: function () { return errors_js_1.AgentIDInUseError; } });
 Object.defineProperty(exports, "AgentNotFoundError", { enumerable: true, get: function () { return errors_js_1.AgentNotFoundError; } });

package/dist/client-tools.d.ts

@@ -0,0 +1,73 @@
+/** The app-level subprotocol the server negotiates for /v1/client-tools. */
+export declare const CLIENT_TOOL_SUBPROTOCOL = "loomcycle.client-tools.v1";
+/** A tool the client offers to run locally (advertised in the hello frame). */
+export interface ClientToolSchema {
+    name: string;
+    description?: string;
+    /** JSON Schema for the tool input (object). */
+    input_schema?: unknown;
+}
+/** An inbound tool call to execute on the user's machine. */
+export interface ClientToolInvocation {
+    tool: string;
+    input: unknown;
+    callId: string;
+    runId?: string;
+    agentId?: string;
+}
+/** A minimal structural WebSocket type so we don't depend on lib.dom or `ws`. */
+export interface WebSocketLike {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((ev: unknown) => void) | null;
+    onclose: ((ev: unknown) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+}
+export type WebSocketCtor = new (url: string, protocols?: string | string[]) => WebSocketLike;
+export interface ConnectClientToolsOptions {
+    /** The tools this client provides. */
+    tools: ClientToolSchema[];
+    /**
+     * Handler for an inbound invoke. Return the tool's output (any JSON value); a
+     * thrown error is reported to the agent as a tool error. Confirm mutating /
+     * destructive actions with the user before executing — loomcycle cannot.
+     */
+    onInvoke: (inv: ClientToolInvocation) => unknown | Promise<unknown>;
+    /** WebSocket implementation. Defaults to the global; pass `ws` on Node < 22. */
+    WebSocketImpl?: WebSocketCtor;
+    /** Auto-reconnect on drop (default true). */
+    reconnect?: boolean;
+    /** Reconnect backoff in ms (default 2000). */
+    reconnectDelayMs?: number;
+    /** Called on lifecycle transitions. */
+    onStatus?: (status: "connecting" | "open" | "closed") => void;
+    /** Called on a transport error (does not stop the host unless you close it). */
+    onError?: (err: unknown) => void;
+}
+/**
+ * ClientToolHost owns the WebSocket lifecycle: connect → hello → dispatch each
+ * invoke to onInvoke → reply with a result, with auto-reconnect. Protocol
+ * ping/pong is handled by the WebSocket layer, so there is no app heartbeat.
+ * Construct via LoomcycleClient.connectClientTools; call close() to stop.
+ */
+export declare class ClientToolHost {
+    private readonly url;
+    private readonly authToken;
+    private readonly opts;
+    private ws?;
+    private closed;
+    constructor(url: string, authToken: string | undefined, opts: ConnectClientToolsOptions);
+    /** Open the connection (called for you by connectClientTools). */
+    start(): void;
+    /** Stop the host + close the socket; suppresses reconnect. */
+    close(): void;
+    private connect;
+    private onMessage;
+    private sendJSON;
+    private scheduleReconnect;
+}
+/** Build the ws(s):// URL for the client-tool endpoint from an http(s) base. */
+export declare function clientToolsURL(baseUrl: string): string;

package/dist/client-tools.js

@@ -0,0 +1,114 @@
+// Client-tool host (RFC BC) — the client side of client-executed tools. Open a
+// persistent WebSocket to loomcycle, register the tools you can run on the
+// user's machine (browser DOM, local FS, shell), and answer the `invoke` frames
+// loomcycle routes to you when an agent of your principal calls one. loomcycle
+// returns your reply to the agent as an ordinary tool result — the agent follows
+// no protocol.
+//
+// Transport note: the adapter is otherwise fetch/SSE-only and takes no WebSocket
+// dependency. connectClientTools uses the global `WebSocket` (browsers, Node
+// 22+); on older Node pass `WebSocketImpl` (e.g. the `ws` package). The bearer
+// rides the `Sec-WebSocket-Protocol` subprotocol (browsers can't set an
+// Authorization header on a WebSocket).
+/** The app-level subprotocol the server negotiates for /v1/client-tools. */
+export const CLIENT_TOOL_SUBPROTOCOL = "loomcycle.client-tools.v1";
+/**
+ * ClientToolHost owns the WebSocket lifecycle: connect → hello → dispatch each
+ * invoke to onInvoke → reply with a result, with auto-reconnect. Protocol
+ * ping/pong is handled by the WebSocket layer, so there is no app heartbeat.
+ * Construct via LoomcycleClient.connectClientTools; call close() to stop.
+ */
+export class ClientToolHost {
+    url;
+    authToken;
+    opts;
+    ws;
+    closed = false;
+    constructor(url, authToken, opts) {
+        this.url = url;
+        this.authToken = authToken;
+        this.opts = opts;
+    }
+    /** Open the connection (called for you by connectClientTools). */
+    start() {
+        this.connect();
+    }
+    /** Stop the host + close the socket; suppresses reconnect. */
+    close() {
+        this.closed = true;
+        this.ws?.close(1000, "client closed");
+    }
+    connect() {
+        if (this.closed)
+            return;
+        const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
+        if (!WS) {
+            throw new Error("connectClientTools: no WebSocket implementation available — pass WebSocketImpl (e.g. the `ws` package) on Node < 22");
+        }
+        const protocols = [CLIENT_TOOL_SUBPROTOCOL];
+        if (this.authToken)
+            protocols.push("bearer." + this.authToken);
+        this.opts.onStatus?.("connecting");
+        const ws = new WS(this.url, protocols);
+        this.ws = ws;
+        ws.onopen = () => {
+            this.opts.onStatus?.("open");
+            this.sendJSON({ type: "hello", client: "@loomcycle/client", tools: this.opts.tools });
+        };
+        ws.onerror = (ev) => this.opts.onError?.(ev);
+        ws.onclose = () => {
+            this.opts.onStatus?.("closed");
+            this.scheduleReconnect();
+        };
+        ws.onmessage = (ev) => void this.onMessage(ev.data);
+    }
+    async onMessage(data) {
+        let frame;
+        try {
+            const text = typeof data === "string" ? data : String(data);
+            frame = JSON.parse(text);
+        }
+        catch {
+            return; // ignore unparseable frames
+        }
+        if (frame.type !== "invoke")
+            return; // hello_ok / anything else — ignore
+        const callId = String(frame.call_id ?? "");
+        try {
+            const output = await this.opts.onInvoke({
+                tool: String(frame.tool ?? ""),
+                input: frame.input,
+                callId,
+                runId: frame.run_id,
+                agentId: frame.agent_id,
+            });
+            this.sendJSON({ type: "result", call_id: callId, ok: true, output });
+        }
+        catch (e) {
+            this.sendJSON({
+                type: "result",
+                call_id: callId,
+                ok: false,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    sendJSON(v) {
+        try {
+            this.ws?.send(JSON.stringify(v));
+        }
+        catch (e) {
+            this.opts.onError?.(e);
+        }
+    }
+    scheduleReconnect() {
+        if (this.closed || this.opts.reconnect === false)
+            return;
+        const delay = this.opts.reconnectDelayMs ?? 2000;
+        setTimeout(() => this.connect(), delay);
+    }
+}
+/** Build the ws(s):// URL for the client-tool endpoint from an http(s) base. */
+export function clientToolsURL(baseUrl) {
+    return baseUrl.replace(/\/$/, "").replace(/^http/, "ws") + "/v1/client-tools";
+}

package/dist/client.d.ts

@@ -24,6 +24,7 @@
  * full mapping table.
  */
 import { InteractiveSession } from "./interactive.js";
+import { ClientToolHost, type ConnectClientToolsOptions } from "./client-tools.js";
 import type { Agent, AgentEvent, AgentStatus, CancelAgentResult, ClientOptions, ContinueOptions, CreateSnapshotOptions, EnsureCodeAgentOptions, EnsureCodeAgentResult, EnsureMcpServerOptions, EnsureMcpServerResult, HealthResponse, Hook, InterruptListResponse, InterruptStatus, AckChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAckResult, ChannelAwaitResult, ChannelBroadcastResult, ChannelDescriptor, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelSubscribeResult, CreateChannelOptions, ListChannelsResponse, PeekChannelOptions, PublishChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, SubscribeChannelOptions, UpdateChannelOptions, LibraryAgentDefinition, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, ListUsersResponse, LLMChatOptions, LLMChatResponse, LLMChatStreamItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, MCPServerDefVerifyResult, MemoryEntriesResponse, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopesResponse, PauseResult, PersistentVolumesResponse, EphemeralVolumesResponse, RegisterHookOptions, RegisterHookResponse, ResolveInterruptOptions, ResumeResult, ResolverMatrix, CompactRunResult, RunBatchOptions, RunBatchResult, RunOptions, RunStateStreamItem, RuntimeStateResponse, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotRestoreResponse, StreamUserRunStatesOptions, SubstrateToolInput, SubstrateToolResponse, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, TranscriptResponse, WhoamiResponse, UsageDimension, UsageReportResponse, TokenLimit, TokenLimitsResponse, SetTokenLimitRequest } from "./types.js";
 export declare class LoomcycleClient {
     private ctx;
@@ -287,6 +288,12 @@ export declare class LoomcycleClient {
      *  URL (e.g. `curl -H "Authorization: Bearer $TOKEN" ...`).
      *  There is no token query-param fallback. */
     exportSnapshotURL(snapshotId: string): string;
+    /** Open a client-tool host (RFC BC): a persistent WebSocket over which this
+     *  client registers tools it runs on the user's machine + answers the
+     *  agent's tool calls. Returns a started {@link ClientToolHost}; call
+     *  `.close()` to stop. Uses the global WebSocket (browsers, Node 22+); pass
+     *  `WebSocketImpl` (e.g. the `ws` package) on older Node. */
+    connectClientTools(opts: ConnectClientToolsOptions): ClientToolHost;
     /** Restore from a same-instance snapshot id OR an inline
      *  envelope JSON. Idempotent: ON CONFLICT DO NOTHING per row;
      *  the returned counters reflect rows actually written.

package/dist/client.js

@@ -26,6 +26,7 @@
 import { authHeaders, deleteRequest, jsonFetch, patchJSON, postJSON, putJSON, raiseFromResponse, } from "./fetch-helpers.js";
 import { parseSSE } from "./stream.js";
 import { InteractiveSession } from "./interactive.js";
+import { ClientToolHost, clientToolsURL, } from "./client-tools.js";
 /** samplingToWire maps the camelCase SamplingOptions to the snake_case wire
  *  object, omitting unset fields so they inherit the agent's value. */
 function samplingToWire(s) {
@@ -464,6 +465,16 @@ export class LoomcycleClient {
     exportSnapshotURL(snapshotId) {
         return `${this.ctx.baseUrl}/v1/_snapshots/${encodeURIComponent(snapshotId)}/export`;
     }
+    /** Open a client-tool host (RFC BC): a persistent WebSocket over which this
+     *  client registers tools it runs on the user's machine + answers the
+     *  agent's tool calls. Returns a started {@link ClientToolHost}; call
+     *  `.close()` to stop. Uses the global WebSocket (browsers, Node 22+); pass
+     *  `WebSocketImpl` (e.g. the `ws` package) on older Node. */
+    connectClientTools(opts) {
+        const host = new ClientToolHost(clientToolsURL(this.ctx.baseUrl), this.ctx.authToken, opts);
+        host.start();
+        return host;
+    }
     /** Restore from a same-instance snapshot id OR an inline
      *  envelope JSON. Idempotent: ON CONFLICT DO NOTHING per row;
      *  the returned counters reflect rows actually written.

package/dist/index.d.ts

@@ -93,5 +93,7 @@
 export { LoomcycleClient } from "./client.js";
 export { InteractiveSession } from "./interactive.js";
 export type { InteractiveSessionOps } from "./interactive.js";
+export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./client-tools.js";
+export type { ClientToolSchema, ClientToolInvocation, ConnectClientToolsOptions, WebSocketLike, WebSocketCtor, } from "./client-tools.js";
 export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ToolUse, Usage, Agent, AgentStatus, AgentUsage, CancelAgentResult, ListAgentsResponse, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, Hook, HookFailMode, HookPhase, HookToolCall, HookToolResult, ListHooksResponse, PostHookCall, PostHookResult, PreHookCall, PreHookResult, RegisterHookOptions, RegisterHookResponse, SubstrateToolInput, SubstrateToolResponse, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, UpdateChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, AgentDefRowResponse, AgentDefVerifyResult, SkillDefVerifyResult, EnsureMcpServerOptions, EnsureMcpServerResult, MCPServerDefRowResponse, MCPServerDefVerifyResult, AgentDefOverlay, EnsureCodeAgentOptions, EnsureCodeAgentResult, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageAggregate, UsageReportResponse, LimitInfo, TokenLimit, TokenLimitsResponse, SetTokenLimitRequest, } from "./types.js";
 export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";

package/dist/index.js

@@ -92,4 +92,5 @@
  */
 export { LoomcycleClient } from "./client.js";
 export { InteractiveSession } from "./interactive.js";
+export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./client-tools.js";
 export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, HookNotFoundError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";

package/dist/types.d.ts

@@ -1448,6 +1448,9 @@ export interface LibraryAgentDefinition {
     tools?: string[];
     skills?: string[];
     providers?: string[];
+    /** RFC BB: per-agent web-search fallback list — the ordered providers the
+     *  WebSearch tool tries (empty = the global search_priority default). */
+    search_providers?: string[];
     /** Per-tier candidate list. Server-side opaque shape — kept as
      *  Record<string, unknown> for forward-compat. */
     models?: Record<string, unknown>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.13.0",
-  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 63 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe — issue #88 operator escape hatch), operator-token admin (operatorTokenDef — RFC L OSS multi-tenant auth) + whoami (RFC L authoritative principal, v0.17.0) + tenant-scoped listUsers / listUserAgents, dynamic MCP registration (mcpServerDef + v0.18.0 typed mcpServerDefVerify + ensureMcpServer idempotent register-if-changed), snapshot lifecycle, memory admin (incl. v0.9.0 Vector Memory embed_stats + reembed AND v0.11.5 setMemoryEntry + deleteMemoryEntry), interruption resolve, hook management, v0.8.22 substrate admin (agentDef + skillDef), v0.9.x n8n Phase 0 (listChannels + streamUserRunStates), v0.9.x Channel CRUD (publishChannel + subscribeChannel + peekChannel + ackChannel), v0.11.5 Channel admin CRUD (createChannel + updateChannel + deleteChannel — runtime substrate; yaml channels refuse mutation with HTTP 409), v0.9.x content_sha256 verify, v0.9.1 transcript first-cycle, v0.9.x dynamic MCP server registration (mcpServerDef + MCPServerDefVerifyResult), v0.10.3 Library v2 enumeration (listLibraryAgents + listLibrarySkills + listLibraryMcpServers), and v0.11.0 LLM Gateway (llmChat + llmStream — direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 — dual ESM + CommonJS distribution (additive — ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 — typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent — register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 — ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 — run/continue accept optional non-secret `metadata` (repo name, review policy, …) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 — version-aligned lockstep release; no client-surface change (RFC N tenant isolation of the agent/skill/MCP/Schedule/Webhook definition plane + real op-schemas on the builtin MCP meta-tools are both server-side). v0.23.0 — version-aligned lockstep release; no client-surface change (RFCs O/P/R MCP-server hardening + thin client and the RFC Q DeepSeek tool-content fix are all server-side / MCP-transport-side). v0.24.0 — purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel — F20); AgentDefOverlay gains channels / evaluation_scopes / interruption so a COMPLETE interactive/multi-agent agent round-trips over the substrate (F14). (Consolidates the interim 0.24/0.25 package bumps, which were never tag-published, back into lockstep with the loomcycle v0.24.0 tag.) v0.25.0 — adds the RFC S channel fan-in/fan-out client twins: awaitChannels() (wait for any/all/at_least N messages across channels, or a timeout — non-committing) + broadcastChannels() (publish one payload to N channels in one atomic-pre-flight call), the client-facing counterparts of the in-band Channel.await / Channel.broadcast tool ops (the rest of v0.25.0 — the manual-management Web UI console + Context op=time + max_fires self-retiring schedules — is server-side / in-band, no client-surface change). v0.29.1 — Usage gains optional `max_context_tokens` (the serving model's context-window ceiling, stamped by the loop from Provider.Capabilities() on each usage event) so a consumer can render a 'context used / max' gauge without a hard-coded per-model table; additive + optional, no behavior change. (Lockstep catch-up: the field landed in loomcycle v0.29.0 but the adapter publish skipped on a version mismatch; v0.29.1 realigns the package version with the release tag so it publishes.) v0.33.0 — gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch — spawn up to 32 fresh runs concurrently in one call, combined index-aligned envelope, per-child failures in-envelope) + compactRun(runId) (POST /v1/runs/{run_id}/compact — summarize a parked run's context); plus per-run sampling + compaction overrides now accepted on runStreaming / continueSession (an explicit temperature 0 is preserved as deterministic, not dropped as falsy). (The gRPC half adds the matching SpawnRunBatch / CompactRun RPCs + the sampling/compaction fields on RunRequest/ContinueRequest — server-side.) v0.34.0 — version-aligned lockstep release; no client-surface change (context-transform plugins / RFC Z Phase 1a are server-side config; the exp7 hardening pass is server-side; the R2 cross-provider thinking-model downgrade surfaces a new `model_downgraded` SSE event the generic stream passes through unchanged). v0.35.0 — RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef — op-discriminated create/get/list/delete/purge; a Volume is flat, so delete unmaps + purge RemoveAll's, no retire/promote/fork) + listVolumes() / listEphemeralVolumes() (GET /v1/_volumes[/ephemeral] — tenant-scoped; host paths redacted for non-operator callers). Tenant-confined; the runtime derives the path inside an operator-blessed dynamic_root, so callers pass name + mode, never a host path. v1.1.1 — RFC AI interactive agentic sessions: an `interactive: true` flag on runStreaming/continueSession (a run that parks at end_turn for steering) + sendRunInput(runId, text) (POST /v1/runs/{id}/input — steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream — re-attach by run_id; the operator's prior turns replay as `steer` events so a cold client reconstructs the whole conversation) + a high-level InteractiveSession driver (client.interactiveSession / attachInteractiveSession — events()/send()/cancel(), the adapter port of the Web UI run terminal). The AgentEvent union gains awaiting_input/steer/context_compaction frames. Version-aligned with the loomcycle v1.1.x line so the v1.1.1 tag publishes it (also carrying the previously-unpublished v0.35.0 volume surface). v1.4.0 — RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path — a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document — chunked-graph documents; 13 ops, needs SQL Memory on the sidecar). Scope (agent/user/tenant) + tenant are resolved server-side from the authenticated principal, never the wire; an off-run scope:'user' op keys on the principal subject so it interoperates with that user's agent runs. New PathToolInput / DocumentToolInput types; responses are op-varying (unknown — narrow as needed). v1.7.0 — RFC AT image/vision input: the PromptContent union gains an `image` variant ({ type:'image'; media_type: ImageMediaType; data: base64-no-prefix }) accepted in a user segment by runStreaming / continueSession (segments pass through unchanged — no method change). The model must be vision-capable or the run errors before the call. New ImageMediaType type (image/png|jpeg|gif|webp). v1.12.1 — Path/Document browse-by-subject + the full Document op set (RFC AS/AK): path(input, opts) / document(input, opts) accept optional scopeId / tenant browse overrides sent as ?scope_id= / ?tenant= query params (server reads them from the URL, re-checks authorization; omit both to browse your own subject — byte-identical to the pre-RFC-AS request), and DocumentToolInput.op now covers all 16 backend ops (adds set_path, export_md, import_md) with the matching include_metadata / markdown fields. Additive — existing path() / document() callers are unchanged.",
+  "version": "1.16.0",
+  "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 64 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe — issue #88 operator escape hatch), operator-token admin (operatorTokenDef — RFC L OSS multi-tenant auth) + whoami (RFC L authoritative principal, v0.17.0) + tenant-scoped listUsers / listUserAgents, dynamic MCP registration (mcpServerDef + v0.18.0 typed mcpServerDefVerify + ensureMcpServer idempotent register-if-changed), snapshot lifecycle, memory admin (incl. v0.9.0 Vector Memory embed_stats + reembed AND v0.11.5 setMemoryEntry + deleteMemoryEntry), interruption resolve, hook management, v0.8.22 substrate admin (agentDef + skillDef), v0.9.x n8n Phase 0 (listChannels + streamUserRunStates), v0.9.x Channel CRUD (publishChannel + subscribeChannel + peekChannel + ackChannel), v0.11.5 Channel admin CRUD (createChannel + updateChannel + deleteChannel — runtime substrate; yaml channels refuse mutation with HTTP 409), v0.9.x content_sha256 verify, v0.9.1 transcript first-cycle, v0.9.x dynamic MCP server registration (mcpServerDef + MCPServerDefVerifyResult), v0.10.3 Library v2 enumeration (listLibraryAgents + listLibrarySkills + listLibraryMcpServers), and v0.11.0 LLM Gateway (llmChat + llmStream — direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 — dual ESM + CommonJS distribution (additive — ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 — typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent — register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 — ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 — run/continue accept optional non-secret `metadata` (repo name, review policy, …) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 — version-aligned lockstep release; no client-surface change (RFC N tenant isolation of the agent/skill/MCP/Schedule/Webhook definition plane + real op-schemas on the builtin MCP meta-tools are both server-side). v0.23.0 — version-aligned lockstep release; no client-surface change (RFCs O/P/R MCP-server hardening + thin client and the RFC Q DeepSeek tool-content fix are all server-side / MCP-transport-side). v0.24.0 — purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel — F20); AgentDefOverlay gains channels / evaluation_scopes / interruption so a COMPLETE interactive/multi-agent agent round-trips over the substrate (F14). (Consolidates the interim 0.24/0.25 package bumps, which were never tag-published, back into lockstep with the loomcycle v0.24.0 tag.) v0.25.0 — adds the RFC S channel fan-in/fan-out client twins: awaitChannels() (wait for any/all/at_least N messages across channels, or a timeout — non-committing) + broadcastChannels() (publish one payload to N channels in one atomic-pre-flight call), the client-facing counterparts of the in-band Channel.await / Channel.broadcast tool ops (the rest of v0.25.0 — the manual-management Web UI console + Context op=time + max_fires self-retiring schedules — is server-side / in-band, no client-surface change). v0.29.1 — Usage gains optional `max_context_tokens` (the serving model's context-window ceiling, stamped by the loop from Provider.Capabilities() on each usage event) so a consumer can render a 'context used / max' gauge without a hard-coded per-model table; additive + optional, no behavior change. (Lockstep catch-up: the field landed in loomcycle v0.29.0 but the adapter publish skipped on a version mismatch; v0.29.1 realigns the package version with the release tag so it publishes.) v0.33.0 — gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch — spawn up to 32 fresh runs concurrently in one call, combined index-aligned envelope, per-child failures in-envelope) + compactRun(runId) (POST /v1/runs/{run_id}/compact — summarize a parked run's context); plus per-run sampling + compaction overrides now accepted on runStreaming / continueSession (an explicit temperature 0 is preserved as deterministic, not dropped as falsy). (The gRPC half adds the matching SpawnRunBatch / CompactRun RPCs + the sampling/compaction fields on RunRequest/ContinueRequest — server-side.) v0.34.0 — version-aligned lockstep release; no client-surface change (context-transform plugins / RFC Z Phase 1a are server-side config; the exp7 hardening pass is server-side; the R2 cross-provider thinking-model downgrade surfaces a new `model_downgraded` SSE event the generic stream passes through unchanged). v0.35.0 — RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef — op-discriminated create/get/list/delete/purge; a Volume is flat, so delete unmaps + purge RemoveAll's, no retire/promote/fork) + listVolumes() / listEphemeralVolumes() (GET /v1/_volumes[/ephemeral] — tenant-scoped; host paths redacted for non-operator callers). Tenant-confined; the runtime derives the path inside an operator-blessed dynamic_root, so callers pass name + mode, never a host path. v1.1.1 — RFC AI interactive agentic sessions: an `interactive: true` flag on runStreaming/continueSession (a run that parks at end_turn for steering) + sendRunInput(runId, text) (POST /v1/runs/{id}/input — steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream — re-attach by run_id; the operator's prior turns replay as `steer` events so a cold client reconstructs the whole conversation) + a high-level InteractiveSession driver (client.interactiveSession / attachInteractiveSession — events()/send()/cancel(), the adapter port of the Web UI run terminal). The AgentEvent union gains awaiting_input/steer/context_compaction frames. Version-aligned with the loomcycle v1.1.x line so the v1.1.1 tag publishes it (also carrying the previously-unpublished v0.35.0 volume surface). v1.4.0 — RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path — a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document — chunked-graph documents; 13 ops, needs SQL Memory on the sidecar). Scope (agent/user/tenant) + tenant are resolved server-side from the authenticated principal, never the wire; an off-run scope:'user' op keys on the principal subject so it interoperates with that user's agent runs. New PathToolInput / DocumentToolInput types; responses are op-varying (unknown — narrow as needed). v1.7.0 — RFC AT image/vision input: the PromptContent union gains an `image` variant ({ type:'image'; media_type: ImageMediaType; data: base64-no-prefix }) accepted in a user segment by runStreaming / continueSession (segments pass through unchanged — no method change). The model must be vision-capable or the run errors before the call. New ImageMediaType type (image/png|jpeg|gif|webp). v1.12.1 — Path/Document browse-by-subject + the full Document op set (RFC AS/AK): path(input, opts) / document(input, opts) accept optional scopeId / tenant browse overrides sent as ?scope_id= / ?tenant= query params (server reads them from the URL, re-checks authorization; omit both to browse your own subject — byte-identical to the pre-RFC-AS request), and DocumentToolInput.op now covers all 16 backend ops (adds set_path, export_md, import_md) with the matching include_metadata / markdown fields. Additive — existing path() / document() callers are unchanged. v1.16.0 — RFC BC client-executed tools (local tool host): connectClientTools({tools,onInvoke}) opens a persistent WebSocket to /v1/client-tools, registers tools this client runs on the user's machine (browser DOM / files / shell), and answers the invoke frames loomcycle routes when an agent of your principal calls a client:<tool> — returning your reply as an ordinary tool result. Returns a ClientToolHost driver (.close() to stop; auto-reconnect); dependency-free (global WebSocket in browsers / Node 22+, or an injected WebSocketImpl like the ws package on older Node); the bearer rides the Sec-WebSocket-Protocol subprotocol (browsers can't set an Authorization header on a WebSocket). The runtime's first WebSocket surface.",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {