@loomcycle/client 1.84.0 → 1.86.0

package/dist/types.d.ts

@@ -7,7 +7,7 @@
  * `client.ts` for the input shapes (RunOptions, CreateSnapshotOptions,
  * etc.) — those are translated to snake_case in the request body.
  */
-export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "steer" | "context_compaction" | "capability_inert" | "limit" | "override" | "_meta";
+export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "steer" | "context_compaction" | "capability_inert" | "limit" | "override" | "context_recap" | "context_state" | "context_distill_declined" | "context_exhausted" | "thinking" | "turn_cancelled" | "provider_fallback" | "fallback_suppressed" | "model_downgraded" | "cache_invalidated" | "reasoning_invalidated" | "channel_publish" | "channel_delivery" | "interruption_pending" | "spawn_child_started" | "spawn_child_result" | "_meta";
 export interface ToolUse {
     id: string;
     name: string;
@@ -140,6 +140,30 @@ export interface EffectiveConfigResponse {
     run_id: string;
     agent: string;
     fields: Record<string, EffectiveValue>;
+    /** Settings this run carries that CANNOT take effect — the advisory half of
+     *  the report, and the half a `fields` map structurally cannot express.
+     *
+     *  `fields` answers "what value is in force"; a setting can be in force and
+     *  still be inert, because a DIFFERENT setting disables it — a compaction
+     *  threshold under a mode that never consults compaction, a `memory_flush`
+     *  whose banking is gated on `harvest_to_memory`. An operator reading only
+     *  `fields` sees their value and concludes it is doing something.
+     *
+     *  Always present, `[]` when nothing is inert, so a consumer can tell "this
+     *  run has no traps" from "this server does not report them". */
+    inert: InertContextSetting[];
+}
+/** One entry in {@link EffectiveConfigResponse.inert}. */
+export interface InertContextSetting {
+    /** The yaml path that cannot take effect, e.g. `compaction.memory_flush`. */
+    setting: string;
+    /** Why — named in terms of the OTHER setting that disables it, because that
+     *  is the one the operator has to change their mind about. */
+    reason: string;
+    /** The setting that DOES do what they were reaching for. Absent when there
+     *  is no equivalent, which is itself the answer; an advisory without it
+     *  leaves the operator hunting for the live knob. */
+    fix?: string;
 }
 /** The reply from `retuneRun` — the run's MERGED configuration, not an echo of
  *  the request.
@@ -237,6 +261,151 @@ export interface LimitInfo {
     /** Human-readable banner string. Optional. */
     message?: string;
 }
+/** A tier's verdict inside {@link ContextExhaustedInfo} — what was tried and
+ *  why it refused. Carried verbatim from each decline rather than summarised,
+ *  because each already names its own fix. */
+export interface ContextTierVerdict {
+    /** "recap" | "compaction" | "stateful". */
+    mode: string;
+    /** Same vocabulary as {@link ContextDistillDeclinedInfo.reason}. */
+    reason?: string;
+    message?: string;
+}
+/** Payload on `context_distill_declined` — a distillation tier ran and refused.
+ *
+ *  The coarse branch is the event's existence: a run that distilled emits
+ *  `context_recap` / `context_compaction` instead. `reason` says which refusal,
+ *  and new values are ADDITIVE — a consumer that does not know one should fall
+ *  back to `message`, never drop the frame. */
+export interface ContextDistillDeclinedInfo {
+    /** Which tier declined: "recap" | "compaction". */
+    mode: string;
+    /** What opened the gate: "auto" | "self" | "manual". */
+    trigger?: string;
+    /** "split_declined" | "empty_summary" | "summary_error" | "not_smaller" |
+     *  "reasoning_keep" | "noop" | "noop_keep_spans_all" | "noop_not_smaller". */
+    reason: string;
+    used_tokens?: number;
+    window_tokens?: number;
+    /** Conversation length at the refusal. */
+    messages?: number;
+    keep_last_n?: number;
+    before_tokens?: number;
+    after_tokens?: number;
+    /** "info" | "warning". `warning` means this path cannot reclaim the window
+     *  and will decline identically again; `info` means the mechanism is healthy
+     *  and the refusal was correct for this input. */
+    severity?: string;
+    message?: string;
+}
+/** Payload on `context_exhausted` — every tier ran (or could not) and the
+ *  window is still full. Reported at most once per run per 10-point band, and
+ *  ONLY from a footprint a provider actually returned: before the first turn
+ *  the numbers are an estimate of a request that has not been sent, and the run
+ *  says nothing. */
+export interface ContextExhaustedInfo {
+    used_tokens: number;
+    window_tokens: number;
+    used_pct?: number;
+    /** Every tier's explanation, not just the last — a run can decline twice for
+     *  DIFFERENT reasons, and half the fix is not a fix. */
+    verdicts?: ContextTierVerdict[];
+    message?: string;
+}
+/** Payload on `context_compaction` — the L0 summarize-and-keep-tail form. */
+export interface ContextCompactionInfo {
+    summary: string;
+    before_tokens?: number;
+    after_tokens?: number;
+    keep_n?: number;
+    keep_first?: boolean;
+    trigger?: string;
+    /** Set when the evicted span was banked to persistent memory. */
+    memory_banked?: {
+        pending_id?: string;
+        messages?: number;
+        error?: string;
+    };
+}
+/** Payload on `context_recap` — the L1 form: the evicted span becomes a running
+ *  note and the last N turns stay verbatim. */
+export interface ContextRecapInfo {
+    recap: string;
+    before_tokens?: number;
+    after_tokens?: number;
+    keep_n?: number;
+    keep_first?: boolean;
+    trigger?: string;
+    /** "recap" | "drop" — what happened to the evicted reasoning. */
+    reasoning?: string;
+}
+/** Payload on `context_state` — the L2 stateful form, emitted once per step. */
+export interface ContextStateInfo {
+    /** Σ after the step's patch was merged. */
+    state: Record<string, unknown>;
+    /** What this step changed. */
+    patch?: Record<string, unknown>;
+    iter: number;
+    action?: string;
+    reasoning?: string;
+    /** A schema the model proposed. INERT — recorded for an operator to adopt by
+     *  forking the agent def, never applied to this run's validation. */
+    proposed_schema?: Record<string, unknown>;
+    /** Σ keys dropped by retention-class eviction this step. Banked to memory
+     *  before they went, so a later recall can fetch them back. */
+    evicted?: string[];
+}
+/** Payload on `provider_fallback` / `fallback_suppressed` / `model_downgraded` —
+ *  the runtime moved (or refused to move) the run after a failure. */
+export interface FallbackInfo {
+    failed_provider: string;
+    failed_model: string;
+    new_provider?: string;
+    new_model?: string;
+    attempt: number;
+    user_tier: string;
+    reason: string;
+    cause_error?: string;
+}
+/** Payload on `channel_publish` / `channel_delivery`. */
+export interface ChannelEventInfo {
+    channel: string;
+    message_id: string;
+    scope: string;
+    scope_id?: string;
+    payload_bytes: number;
+    payload_preview?: string;
+    dropped_oldest?: number;
+    cursor?: string;
+}
+/** Payload on `interruption_pending` — the run asked a human a question and is
+ *  waiting on the answer. */
+export interface InterruptionEventInfo {
+    interrupt_id: string;
+    kind: string;
+    question?: string;
+    options?: unknown;
+    context?: string;
+    priority: string;
+    expires_at?: string;
+}
+/** Payload on `turn_cancelled` (RFC BH). */
+export interface TurnCancelledInfo {
+    reason?: string;
+    since_turn: number;
+}
+/** Payload on `spawn_child_started` / `spawn_child_result` — the two-event
+ *  ledger a fan-out parent writes so an in-flight child survives a pause. */
+export interface SpawnChildInfo {
+    tool_use_id: string;
+    index: number;
+    run_id?: string;
+    agent?: string;
+    ok?: boolean;
+    output?: string;
+    error?: string;
+    state?: Record<string, unknown>;
+}
 export interface AgentEvent {
     type: EventType;
     text?: string;
@@ -284,6 +453,32 @@ export interface AgentEvent {
     session_id?: string;
     parent_agent_id?: string | null;
     parent_context?: ParentContext;
+    /** Payload on `context_compaction`. */
+    context_compaction?: ContextCompactionInfo;
+    /** Payload on `context_recap`. */
+    context_recap?: ContextRecapInfo;
+    /** Payload on `context_state`. */
+    context_state?: ContextStateInfo;
+    /** Payload on `context_distill_declined`. Named `context_distill` on the
+     *  wire, not `context_distill_declined` — the field is the server struct's
+     *  json tag and does not mirror the event name. */
+    context_distill?: ContextDistillDeclinedInfo;
+    /** Payload on `context_exhausted`. */
+    context_exhausted?: ContextExhaustedInfo;
+    /** Payload on `provider_fallback` / `fallback_suppressed` /
+     *  `model_downgraded`. */
+    fallback?: FallbackInfo;
+    /** Payload on `channel_publish` / `channel_delivery`. */
+    channel?: ChannelEventInfo;
+    /** Payload on `interruption_pending`. */
+    interruption?: InterruptionEventInfo;
+    /** Payload on `turn_cancelled`. */
+    turn_cancelled?: TurnCancelledInfo;
+    /** Payload on `spawn_child_started` / `spawn_child_result`. */
+    spawn_child?: SpawnChildInfo;
+    /** The assistant turn's accumulated reasoning trace, on `done`. Empty for
+     *  non-thinking models. */
+    reasoning?: string;
     meta_subtype?: "stream_open" | "stream_close";
     meta_reason?: string;
 }
@@ -564,8 +759,13 @@ export interface ContextOptions {
     /** What happens to the evicted span in recap mode.
      *  - `recap` (default) — summarise it into a running note.
      *  - `drop`            — discard it with no note.
-     *  - `keep`            — distil nothing (reported as a decline, so the
-     *                        run says why the window is not being reclaimed). */
+     *  - `keep`            — distil nothing. Reported as a `reasoning_keep`
+     *                        decline WHEN THE THRESHOLD IS REACHED, so the run
+     *                        says why the window is not being reclaimed. Below
+     *                        the threshold there is nothing to report and no
+     *                        frame is emitted — absence of a decline means the
+     *                        gate did not open, not that distillation is
+     *                        broken. */
     reasoning?: "recap" | "drop" | "keep";
     /** Character budget for the running recap note (default 512).
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.84.0",
+  "version": "1.86.0",
   "description": "TypeScript client for the loomcycle sidecar (HTTP+SSE). 71 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. v1.45.0 — RFC BL P5 subject erasure: erasureReport(subject, {tenant}) (GET /v1/_erasure — 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 — 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 — the returned object is the only durable record of what was not reached; persist it. New ErasureReport / ErasureResult / ErasureTier / ErasureResidue types. v1.47.0 — RFC BV memory-view SDK: memorySearch() (POST /v1/_memory/search — 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 — existing callers unchanged. v1.61.0 — 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 — the TeamDef version lifecycle: listTeamVersions(name) (op=list — every version of one team, newest first), promoteTeam(defId) (op=promote — 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 — reversible and version-scoped, unlike deleteTeam) and verifyTeam(name, contentSha256) (op=verify — 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",