@loomcycle/client 1.77.0 → 1.78.0

package/README.md

@@ -335,7 +335,7 @@ Two substrate-side surfaces added in the n8n integration's Phase 0 wire-API work
 | Method | Returns | Notes |
 |---|---|---|
 | `listChannels()` | `Promise<ListChannelsResponse>` | Operator-declared channels + aggregate stats (`message_count`, `oldest_visible_at`, `newest_visible_at`). Mirrors `GET /v1/_channels`. |
-| `streamUserRunStates(userId, opts?)` | `AsyncIterable<RunStateStreamItem>` | SSE stream of run state transitions for one user. Yields one `{ kind: "open", ... }` frame then one `{ kind: "event", payload: RunStateEvent }` per matching transition until close. |
+| `streamUserRunStates(userId, opts?)` | `AsyncIterable<RunStateStreamItem>` | SSE stream of run state transitions for one user. Yields one `{ kind: "open", ... }` frame then one `{ kind: "event", payload: RunStateEvent }` per matching transition until close. `opts.walkId` (v1.78.0) narrows it server-side to one team walk's agents. |
 
 **Streaming run-state events** — for orchestration UIs that want to react when an agent run completes / fails / cancels:
 
@@ -537,6 +537,31 @@ for await (const item of client.streamUserRunStates(userId, {
 
 `streamUserRunStates` holds ONE connection per user regardless of how many concurrent runs that user has. Server-enforced 30-minute timeout; reconnect on close.
 
+### `walkId` — watching ONE team walk's agents (v1.78.0)
+
+A detached team walk returns a `run_id`, and that id **is** the walk id every run it spawns carries in `parent_context.walk_id`. Pass it back as `walkId` and the server filters the stream to that workflow — no second identifier, nothing to map:
+
+```ts
+const { run_id } = await client.runTeam({ team: "triage", detach: true });
+
+for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+  if (item.kind === "open") {
+    // The server echoes the filter it applied. Check it: a filter that matched
+    // nothing and a filter the server did not understand are both a quiet
+    // stream, and only this tells them apart.
+    if (item.payload.filter_walk_id !== run_id) throw new Error("walk filter not applied");
+    continue;
+  }
+  if (item.kind !== "event") continue;
+  const pc = item.payload.parent_context;
+  // wave_id groups one fan-out; wave_index is the position inside it, so a
+  // live view can place an agent WITHIN the walk, not merely inside it.
+  render(item.payload.agent, item.payload.status, pc?.wave_id, pc?.wave_index);
+}
+```
+
+Unlike `parentAgentId`, which the adapter applies after parsing each frame, `walkId` is applied by the server — it reduces what crosses the wire, not just what your callback sees.
+
 ### `debug: true` — synthetic open/close frames
 
 All three streaming methods (`runStreaming`, `continueSession`, `streamUserRunStates`) accept `debug?: boolean`. Default off; behaviour is exactly the pre-v0.9.x shape.

package/dist/cjs/client.js

@@ -1918,6 +1918,18 @@ class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.
@@ -1936,6 +1948,9 @@ class LoomcycleClient {
         if (opts?.agent) {
             params.set("agent", opts.agent);
         }
+        if (opts?.walkId) {
+            params.set("walk_id", opts.walkId);
+        }
         const qs = params.toString();
         const path = `/v1/users/${encodeURIComponent(userId)}/agents/stream` +
             (qs ? `?${qs}` : "");

package/dist/client.d.ts

@@ -1270,6 +1270,18 @@ export declare class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.

package/dist/client.js

@@ -1915,6 +1915,18 @@ export class LoomcycleClient {
      *  Errors during the stream throw — they do NOT surface as items.
      *  Pass an AbortSignal to terminate cleanly from the consumer side.
      *
+     *  v1.78.0 — `walkId` is a SERVER-side filter: only the runs one team
+     *  walk spawned. A walk's own run_id IS its walk id, so a caller that
+     *  started a team with `detach: true` passes back the handle it already
+     *  holds and gets a live view of that workflow's agents:
+     *
+     *  ```ts
+     *  const { run_id } = await client.runTeam({ team: "triage", detach: true });
+     *  for await (const item of client.streamUserRunStates(userId, { walkId: run_id })) {
+     *    if (item.kind === "event") place(item.payload.parent_context?.wave_index);
+     *  }
+     *  ```
+     *
      *  v0.9.x options:
      *  - `parentAgentId` — client-side filter: only `kind: "event"`
      *    items whose payload's `parent_agent_id` matches are yielded.
@@ -1933,6 +1945,9 @@ export class LoomcycleClient {
         if (opts?.agent) {
             params.set("agent", opts.agent);
         }
+        if (opts?.walkId) {
+            params.set("walk_id", opts.walkId);
+        }
         const qs = params.toString();
         const path = `/v1/users/${encodeURIComponent(userId)}/agents/stream` +
             (qs ? `?${qs}` : "");

package/dist/types.d.ts

@@ -295,6 +295,22 @@ export interface ParentContext {
     board_scope?: string;
     board_chunk_id?: string;
     board_document_id?: string;
+    /** Team-walk correlation (loomcycle v1.78.0). A run spawned by a team walk
+     *  carries the walk's own run_id here, plus which WAVE of that walk it
+     *  belongs to and its index within the wave.
+     *
+     *  `walk_id` is what {@link StreamUserRunStatesOptions.walkId} filters on
+     *  server-side; `wave_id` + `wave_index` are what let a live view place an
+     *  agent within the walk rather than merely inside it — a fan-out of N
+     *  agents shares one `wave_id` and differs only by `wave_index`.
+     *
+     *  Absent on any run no team walk spawned. */
+    walk_id?: string;
+    wave_id?: string;
+    /** Position within the wave, 0-based. Sent even when 0 (unlike the string
+     *  fields, which are omitted when empty), so an index of 0 is a real first
+     *  position and not an absent one. */
+    wave_index?: number;
 }
 export interface ContinueOptions {
     /** Required — the session to continue. */
@@ -1878,6 +1894,13 @@ export interface RunStateStreamOpen {
     user_id: string;
     filter_status: string[] | null;
     filter_agent: string;
+    /** v1.78.0 — the walk filter the server actually applied, echoed back.
+     *
+     *  Worth reading rather than assuming: a filter that matched nothing and a
+     *  filter the server never understood look identical from the outside — both
+     *  are a stream that stays quiet. Comparing this to what you sent tells the
+     *  two apart before you wait on an empty stream. Empty when unfiltered. */
+    filter_walk_id?: string;
     keepalive_interval: number;
 }
 /** Yielded by {@link LoomcycleClient.streamUserRunStates}.
@@ -1903,12 +1926,28 @@ export interface StreamUserRunStatesOptions {
     statuses?: string[];
     /** Filter to one agent name. Empty means any. */
     agent?: string;
+    /** v1.78.0 — SERVER-side filter: only the runs one team walk spawned,
+     *  matched against each event's `parent_context.walk_id`.
+     *
+     *  A team walk's own run_id IS its walk id, so a caller that started a team
+     *  with `detach: true` passes back exactly the handle it already holds —
+     *  there is no second identifier and nothing to map. That is what makes a
+     *  live view of one running workflow's agents a filter rather than a
+     *  feature.
+     *
+     *  Unlike {@link StreamUserRunStatesOptions.parentAgentId}, this is applied
+     *  by the server, so it reduces what crosses the wire and not just what your
+     *  callback sees. The server echoes it back on the open frame as
+     *  {@link RunStateStreamOpen.filter_walk_id}. */
+    walkId?: string;
     /** v0.9.x — client-side filter on the run's parent_agent_id.
      *  Useful for "show me only the sub-runs spawned by agent X."
      *  The filter is applied AFTER the SSE frame is parsed, so this
      *  shrinks what your callback sees but doesn't reduce server-side
-     *  load. Server-side filtering is a separate (future) request.
-     *  Pass the empty string to opt out (default). */
+     *  load. Pass the empty string to opt out (default).
+     *
+     *  For the one case that HAS a server-side filter, prefer it: see
+     *  {@link StreamUserRunStatesOptions.walkId}. */
     parentAgentId?: string;
     /** v0.9.x — opt-in observability: when true, the iterator yields a
      *  client-synthesized `{ kind: "close", payload: { reason } }` item

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.77.0",
+  "version": "1.78.0",
   "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 71 methods covering run streaming, agent metadata, pause/resume/state, resolver re-probe (resolveProbe \u2014 issue #88 operator escape hatch), operator-token admin (operatorTokenDef \u2014 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 \u2014 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 \u2014 direct provider routing without agent overhead; primary target is n8n's LoomCycleChatModel AI Agent sub-node and any LangChain-compatible consumer). v0.10.1 \u2014 dual ESM + CommonJS distribution (additive \u2014 ESM consumers unchanged; CJS consumers like n8n's community-node loader now work). v0.19.0 \u2014 typed inline code-js agent ingestion (AgentDefOverlay.code_body + ensureCodeAgent \u2014 register a deterministic code agent through the substrate with no host filesystem bind; RFC J). v0.20.0 \u2014 ensureMcpServer surfaces discoveredToolCount straight from create (loomcycle now auto-discovers MCP tools at ingestion); rediscover is now an explicit force-refresh. v0.21.0 \u2014 run/continue accept optional non-secret `metadata` (repo name, review policy, \u2026) passed to the agent, symmetric with the WebHook/Schedule trigger paths. v0.22.0 \u2014 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 \u2014 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 \u2014 purgeChannel clears a channel's buffered messages without deleting its definition (allowed on yaml-declared channels too, unlike deleteChannel \u2014 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 \u2014 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 \u2014 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 \u2014 the manual-management Web UI console + Context op=time + max_fires self-retiring schedules \u2014 is server-side / in-band, no client-surface change). v0.29.1 \u2014 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 \u2014 gRPC + TS client parity for the RFC Y external fan-out and the compaction surface: spawnRunBatch() (POST /v1/runs:batch \u2014 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 \u2014 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 \u2014 server-side.) v0.34.0 \u2014 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 \u2014 RFC AH dynamic filesystem volumes: volumeDef() (POST /v1/_volumedef \u2014 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] \u2014 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 \u2014 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 \u2014 steer a live run) + streamRunByID(runId, {fromSeq}) (GET /v1/runs/{id}/stream \u2014 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 \u2014 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 \u2014 RFC AL Path VFS + RFC AK Document on the wire: path(input) (POST /v1/_path \u2014 a Unix-like filesystem over Memory/Volumes/Documents; resolve/ls/stat/mkdir/mv/rm) + document(input) (POST /v1/_document \u2014 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 \u2014 narrow as needed). v1.7.0 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 existing path() / document() callers are unchanged. v1.16.0 \u2014 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> \u2014 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. v1.45.0 \u2014 RFC BL P5 subject erasure: erasureReport(subject, {tenant}) (GET /v1/_erasure \u2014 what this deployment holds about one subject, in three tiers: deletable with existing primitives, subject-keyed but not deletable, and facts ABOUT the subject in scopes they do not own) + erasureExecute(subject, {dryRun, confirm, tenant}) (POST /v1/_erasure \u2014 removes tiers 1 and 2). DEFAULTS TO A DRY RUN: dryRun defaults true and a live run also requires confirm === subject. The tier-3 residue is traceable only through the subject's chats, which a live run deletes, so a report afterwards shows rows: 0 while those facts remain \u2014 the returned object is the only durable record of what was not reached; persist it. New ErasureReport / ErasureResult / ErasureTier / ErasureResidue types. v1.47.0 \u2014 RFC BV memory-view SDK: memorySearch() (POST /v1/_memory/search \u2014 off-run unified semantic search spanning k/v entries AND document-chunk bodies in one ranked list, each hit tagged kind memory|document with chunk_id on document hits) + memoryEmbedStats(scope) + reembedMemory(scope, scopeId, {dryRun,limit}) (the Vector Memory embed-admin reads the memory-view console needs; dry_run defaults true). Fact reads (list_facts + get_chunk's entity block) ride the existing document() passthrough. Additive \u2014 existing callers unchanged. v1.61.0 \u2014 RFC CJ per-run context-window override: runStreaming / continueSession accept an optional maxContextTokens (integer tokens) that wins over the agent's own max_context_tokens; omitted inherits it (which defers to the provider/driver default). Distinct from a model's output cap; primarily for local inference (Ollama num_ctx). Serialized as the snake_case max_context_tokens field on POST /v1/runs + the continuation body; additive, existing callers unchanged. v1.72.1 \u2014 the TeamDef version lifecycle: listTeamVersions(name) (op=list \u2014 every version of one team, newest first), promoteTeam(defId) (op=promote \u2014 point the active pointer, which is what a run BY NAME executes; forkTeam defaults to promote:false, so authoring and putting in force stay two steps), retireTeam(defId, retired) (op=retire \u2014 reversible and version-scoped, unlike deleteTeam) and verifyTeam(name, contentSha256) (op=verify \u2014 the drift check for a workflow kept in source control and pushed to several deployments; an absent team answers deployed:false rather than raising). The ops existed on the substrate and over HTTP; a client that could author a team could not put one in force.",
   "license": "Apache-2.0",
   "type": "module",