@loomcycle/client 1.121.0 → 1.122.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" | "awaiting_review" | "subagent_hold" | "awaiting_children" | "children_note" | "steer" | "context_compaction" | "capability_inert" | "hook_decision" | "limit" | "override" | "context_recap" | "context_state" | "context_distill_declined" | "context_exhausted" | "thinking" | "team_decision" | "turn_cancelled" | "provider_fallback" | "fallback_suppressed" | "model_downgraded" | "cache_invalidated" | "reasoning_invalidated" | "channel_publish" | "channel_delivery" | "interruption_pending" | "spawn_child_started" | "spawn_child_result" | "spawn_child_read" | "prompt_snapshot" | "queued" | "admitted" | "call_queued" | "call_admitted" | "_meta";
+export type EventType = "started" | "text" | "tool_call" | "tool_result" | "usage" | "done" | "error" | "retry" | "host_widened" | "session" | "agent" | "awaiting_input" | "awaiting_review" | "subagent_hold" | "awaiting_children" | "children_note" | "steer" | "context_compaction" | "capability_inert" | "hook_decision" | "limit" | "file_captured" | "override" | "context_recap" | "context_state" | "context_distill_declined" | "context_exhausted" | "thinking" | "team_decision" | "turn_cancelled" | "provider_fallback" | "fallback_suppressed" | "model_downgraded" | "cache_invalidated" | "reasoning_invalidated" | "channel_publish" | "channel_delivery" | "interruption_pending" | "spawn_child_started" | "spawn_child_result" | "spawn_child_read" | "prompt_snapshot" | "queued" | "admitted" | "call_queued" | "call_admitted" | "_meta";
 export interface ToolUse {
     id: string;
     name: string;
@@ -445,6 +445,23 @@ export interface AdmissionInfo {
     /** On `call_queued` / `call_admitted`: the call lane's model kind (`"chat"`). */
     kind?: string;
 }
+/** Payload on `event: file_captured`: a file a tool returned, as the runtime
+ *  kept it in the run's inbox volume. Never the bytes, never a URL's query. */
+export interface FileCapturedInfo {
+    /** The file's reference, `volume:inbox:<dir>/<name>`. */
+    ref: string;
+    media_type: string;
+    /** Length in bytes. */
+    size: number;
+    /** Hex SHA-256 of the bytes. */
+    sha256: string;
+    /** Which producer returned it: `mcp:<server>/<tool>`, `http`, `webfetch` or
+     *  `download:<host>`. */
+    origin: string;
+    /** The run whose tool call returned it (a sub-agent's capture is reported
+     *  on the tree's stream). */
+    run_id?: string;
+}
 export interface LimitInfo {
     /** Which axis tripped: "operator" | "tenant" | "user". */
     scope: string;
@@ -685,6 +702,9 @@ export interface AgentEvent {
     /** Payload on `event: limit` (RFC AW) — a per-scope token-budget crossing.
      *  Nil on all other event types. */
     limit?: LimitInfo;
+    /** Payload on `event: file_captured` — a file a tool returned, kept in the
+     *  run's inbox. Nil on all other event types. */
+    file?: FileCapturedInfo;
     /** Payload on `event: queued` (why the run waits, and its place) and
      *  `event: admitted` (how long it waited), and on `event: call_queued` /
      *  `event: call_admitted` (the same for one model call, with its provider
@@ -1499,6 +1519,15 @@ export interface RunSpec {
          *  own `crypto_scopes` were narrowed to, and are narrowed to again on
          *  resume. Absent: the parent held none. */
         crypto_scopes?: string[];
+        /** The parent run's shell-credential narrowing at spawn (RFC EW): the
+         *  names the child's own `shell_credentials` were narrowed to, and are
+         *  narrowed to again on resume. Absent: the parent narrowed nothing. `[]`:
+         *  the parent allowed none. */
+        shell_credentials?: string[];
+        /** The parent run's Git network grant at spawn (RFC FB): the operations
+         *  the child's own `git_remote` was narrowed to, and is narrowed to again
+         *  on resume. Absent: the parent had none. */
+        git_remote?: Array<'fetch' | 'push'>;
         /** The override offer the child passes on to its own children: its
          *  parent's, unchanged, so a resume offers what the live child did. Only
          *  a child of the offering run's definition (`def_id`, else `agent_name`)
@@ -1801,6 +1830,22 @@ export interface ErasureResidue {
     sessions_examined: number;
     truncated: boolean;
 }
+/** One bearer token an erasure names: its def id and name, never the bearer. */
+export interface ErasureTokenRef {
+    def_id: string;
+    name: string;
+}
+/**
+ * What an erasure removes from the subject's authority — in a report or a dry
+ * run, what it would: the groups the subject leaves, the lists its bindings
+ * (and its tokens' bindings) named, and the member tokens revoked.
+ * Config-declared rows are not listed; the store cannot remove them.
+ */
+export interface ErasureAccess {
+    groups: string[];
+    lists: string[];
+    tokens: ErasureTokenRef[];
+}
 /** Result of {@link LoomcycleClient.erasureReport} (RFC BL P5). */
 export interface ErasureReport {
     tenant: string;
@@ -1808,6 +1853,7 @@ export interface ErasureReport {
     tier1_covered: ErasureTier;
     tier2_uncovered: ErasureTier;
     tier3_residue: ErasureResidue;
+    access: ErasureAccess;
     notes: string[];
     /** Planes that could not be READ. Non-empty means every count is a lower bound. */
     errors?: string[];
@@ -1821,6 +1867,8 @@ export interface ErasureResult {
     /** Plane -> why it was kept. Never empty. */
     retained: Record<string, string>;
     residue: ErasureResidue;
+    /** The groups, lists and member tokens removed (or, in a dry run, that would be). */
+    access: ErasureAccess;
     errors?: string[];
     notes: string[];
 }
@@ -2059,6 +2107,26 @@ export interface WhoamiResponse {
     is_admin: boolean;
     legacy: boolean;
     open_mode?: boolean;
+    /** The deployment's access-control rollout mode: `compat`, `shadow` or
+     *  `enforce`. Absent on a server that predates access-control lists. */
+    acl_mode?: AclMode;
+    /** The caller's groups, transitive. Absent when none were resolved. */
+    groups?: string[];
+    /** The version of the caller's compiled access-control set. Absent in open
+     *  mode and when the set could not be resolved. */
+    acl_version?: number;
+    /** What the caller may reach, as the server's own gates would answer it.
+     *  Absent on a server that predates the summary. */
+    effective?: WhoamiEffective;
+}
+/** GET /v1/_me's capability summary. Bounded and non-secret: a fixed list of
+ *  Web UI pages, no per-instance data. */
+export interface WhoamiEffective {
+    /** Per Web UI page id (`run`, `runs`, `channels`, `access`, `users`, …),
+     *  whether a request to the route the page loads first would pass the
+     *  route's scope gate and its access-control question in the current mode.
+     *  Every page is true in open mode. */
+    surfaces: Record<string, boolean>;
 }
 export type RuntimeStateStatus = "running" | "pausing" | "paused";
 /** A timed override of an agent's no-trace mode: until `until`, runs of
@@ -3928,6 +3996,15 @@ export interface EnsureMcpServerOptions {
      *  loomcycle's idempotent create dedup the re-registration. */
     headers?: Record<string, string>;
     description?: string;
+    /** How the server's text results reach the model. `"passthrough"` (the
+     *  default) hands them over as they came. `"capture"` keeps a file the
+     *  server returns as base64 inside a text block — the whole block, or a
+     *  JSON string field such as Microsoft Graph's `contentBytes` — in the
+     *  run's inbox and hands the model a one-line reference instead. Opt in
+     *  only for a server that returns files that way: a long opaque token
+     *  could otherwise look like one. Part of the registration's content, so
+     *  changing it mints a new version. Sent as the overlay's `binary_results`. */
+    binaryResults?: "passthrough" | "capture";
     /** Force a `tools/list` refresh after registering. Default false.
      *
      *  You usually do NOT need this: registration auto-discovers the upstream's
@@ -4186,6 +4263,19 @@ export interface AgentDefOverlay {
      *  only. Held to the author's own grant; a sub-agent holds only what its
      *  parent run also holds. */
     crypto_scopes?: string[];
+    /** Which operator-listed credentials the agent's `Bash` and Bashbox host
+     *  commands receive (RFC EW): only these names of
+     *  `LOOMCYCLE_BASH_ALLOWED_CREDS` / `LOOMCYCLE_BASHBOX_FALLBACK_ALLOWED_CREDS`.
+     *  Unset = every credential the operator lists; `[]` = none; never adds one.
+     *  Held to the author's own narrowing; a sub-agent gets only the names its
+     *  parent run also allows. */
+    shell_credentials?: string[];
+    /** Which network operations the agent's `Git` tool may perform (RFC FB):
+     *  `['fetch']` (clone, fetch, pull, ls_remote) or `['fetch', 'push']`.
+     *  Unset or `[]` = none, local repositories only; `push` needs `fetch`.
+     *  Held to the author's own grant; a sub-agent may perform an operation
+     *  only when its parent run also may. */
+    git_remote?: Array<'fetch' | 'push'>;
     /** Channel tool ACL (default-deny until set). */
     channels?: AgentChannelACL;
     /** Interruption tool gate — `enabled: true` REQUIRED for the tool to work. */
@@ -4881,6 +4971,10 @@ export interface LibraryEntry<T = unknown> {
     active_def_id?: string;
     latest_version?: number;
     last_updated?: string;
+    /** /v1/_library/agents only: the context window, in tokens, a run of
+     *  this agent starts with — the resolved provider's window, lowered by
+     *  the agent's own max_context_tokens. Omitted when unknown. */
+    context_window?: number;
     /** Static-side definition body. Omitted when in_static is false
      *  (dynamic-only entries have no static body — query the substrate
      *  via AgentDef/SkillDef/MCPServerDef tools to fetch the active
@@ -5732,16 +5826,20 @@ export interface DefNameSummary {
 export interface DefNamesResponse {
     names: DefNameSummary[];
 }
-/** One token name's summary from {@link LoomcycleClient.listOperatorTokenDefNames}.
- *  Carries no secret material. */
+/** One (tenant, token name) summary from {@link LoomcycleClient.listOperatorTokenDefNames}.
+ *  A per-user (`u-`) name repeats across tenants, so it can appear once per
+ *  tenant. Carries no secret material. */
 export interface OperatorTokenDefNameSummary {
     name: string;
     tenant_id: string;
     subject: string;
-    /** Every token minted under the name, rotated and retired ones included. */
+    /** Every token minted under the name in this tenant, rotated and retired ones included. */
     token_count: number;
-    /** A non-retired token exists. */
+    /** A non-retired, unexpired token exists. */
     has_current: boolean;
+    /** The newest live token's def_id; absent when none is live. Rotate or
+     *  retire by it: a per-user name is refused as a target. */
+    current_def_id?: string;
     last_updated: string;
 }
 /** Response of {@link LoomcycleClient.listOperatorTokenDefNames}. */
@@ -5913,6 +6011,49 @@ export interface RoutingResponse {
     throughput_mode?: string;
     /** Absent when no search providers are configured. */
     search?: SearchRoutingProvider[];
+    /** The memory embedder. Absent when none is configured. */
+    embedder?: RoutingEmbedder;
+    /** The decision models. Absent when none are configured. */
+    decision?: RoutingDecision;
+}
+/** The memory embedder in {@link RoutingResponse}. `state` is what its calls
+ *  did since boot, not a probe: `untried` means nothing has been embedded yet.
+ *  No error text or address is reported. */
+export interface RoutingEmbedder {
+    state: "untried" | "ok" | "failing";
+    provider?: string;
+    model?: string;
+    /** The `models:` alias `memory.embedder` names, when it names one. */
+    alias?: string;
+    /** Absent until the embedder has learned it. */
+    dimension?: number;
+    calls: number;
+    failures: number;
+    last_failure_kind?: string;
+    last_ok_unix?: number;
+    last_failure_unix?: number;
+}
+/** The decision block in {@link RoutingResponse}. */
+export interface RoutingDecision {
+    /** The model a call that names none is asked. */
+    default: string;
+    models: RoutingDecisionModel[];
+}
+/** One decision model. The state fields are its provider's probe; all three are
+ *  absent when the provider was never probed, and `listed` is also absent while
+ *  the provider is unreachable. Under the operator-key gate a tenant sees only
+ *  the models it can key. */
+export interface RoutingDecisionModel {
+    /** What a caller names: a `models:` alias or a model name. */
+    name: string;
+    provider: string;
+    model: string;
+    default?: boolean;
+    /** Reachable and listed. */
+    available?: boolean;
+    reachable?: boolean;
+    /** The provider's model list carries the model (for Ollama: it is pulled). */
+    listed?: boolean;
 }
 /** Response of {@link LoomcycleClient.listProviderModels}: a live listing from
  *  the provider, not the cached probe matrix. */
@@ -6050,3 +6191,337 @@ export interface StreamChangesOptions {
     /** Abort to close the stream; the iterator then throws an `AbortError`. */
     signal?: AbortSignal;
 }
+/** The access-control rollout mode a deployment runs in. */
+export type AclMode = "compat" | "shadow" | "enforce";
+/** Marks an entry the config declares rather than the store holds. */
+export type AclSource = "config";
+export type AclEffect = "allow" | "deny";
+/** What a binding attaches a list to. `tenant` is everyone in the tenant. */
+export type AclSubjectKind = "user" | "group" | "token" | "tenant";
+/** The closed `when` set of a rule. Every present field narrows the rule; an
+ *  absent one does not. */
+export interface AclCondition {
+    /** The request arrived on one of these (see `AclCatalog.transports`). */
+    transport?: string[];
+    /** A wall-clock window: on one of `days` (`mon`…`sun`), inside
+     *  `between: [from, to)` (`HH:MM`), in `tz` (an IANA zone). */
+    time?: {
+        days?: string[];
+        between?: string[];
+        tz?: string;
+    };
+    interactive?: boolean;
+    tier?: string[];
+    user_tier?: string[];
+    source_cidr?: string[];
+    owner_is_self?: boolean;
+    /** Inside a run: the run's agent matches this glob. */
+    agent?: string;
+    /** The run's spawn depth is at most `max`. */
+    depth?: {
+        max: number;
+    };
+}
+/** One rule: `effect` on any of `actions` over any of `resources`
+ *  (`type:selector`, e.g. `agent:reviewer-*`), when `when` holds. */
+export interface AclRule {
+    effect: AclEffect;
+    actions: string[];
+    resources: string[];
+    when?: AclCondition;
+    description?: string;
+}
+/** A rule list as written: a built-in baseline, or a draft list for
+ *  {@link LoomcycleClient.authzSimulate}. */
+export interface AclList {
+    name: string;
+    description?: string;
+    rules: AclRule[];
+}
+/** One rule list: a stored one, or (`source: "config"`) one the config
+ *  declares, which has only a name, a description and its rules. */
+export interface AclDefRow {
+    tenant_id?: string;
+    name: string;
+    /** Bumped on every write. Absent on a config list. */
+    version?: number;
+    content_sha256?: string;
+    catalog_version?: number;
+    rules: AclRule[];
+    description?: string;
+    created_at?: string;
+    updated_at?: string;
+    created_by?: string;
+    /** Set once the list is retired; absent while it is live. */
+    retired_at?: string;
+    source?: AclSource;
+}
+/** `aclDef({op: "list"})`. `builtin` is the code-defined baselines, which no
+ *  call can change. */
+export interface AclDefListResponse {
+    acls: AclDefRow[];
+    builtin: AclList[];
+}
+/** `GET /v1/_acldef/names`: every live list name the tenant's bindings can
+ *  reach, stored and config, sorted. */
+export interface AclDefNamesResponse {
+    names: string[];
+}
+/** `aclDef({op: "validate"})` on rules the server accepts. Rules it refuses
+ *  are a 400 (`acl_invalid`) naming the fault. */
+export interface AclValidateResult {
+    valid: boolean;
+    /** How many rules were read. */
+    rules: number;
+    catalog_version: number;
+}
+/** One resource type of the catalog: its verbs, and for a scoped type the
+ *  scopes a selector may name (`separator` joins scope and name). */
+export interface AclCatalogType {
+    type: string;
+    verbs: string[];
+    scopes?: string[];
+    separator?: string;
+}
+/** `aclDef({op: "catalog"})`: what a rule may name. */
+export interface AclCatalog {
+    catalog_version: number;
+    types: AclCatalogType[];
+    transports: string[];
+}
+/** The ops of the AclDef family. `create`, `update` and `put` are the same
+ *  upsert. */
+export type AclDefOp = "create" | "update" | "put" | "get" | "list" | "retire" | "validate" | "catalog" | "names";
+/** The input of {@link LoomcycleClient.aclDef}. `name` is required by
+ *  create/update/put/get/retire, `rules` by create/update/put/validate,
+ *  `include_retired` is read by list. */
+export interface AclDefInput {
+    op: AclDefOp;
+    name?: string;
+    rules?: AclRule[];
+    description?: string;
+    include_retired?: boolean;
+}
+/** One group: a stored one, or (`source: "config"`) one the config declares,
+ *  which lists its direct `members` (subjects) and member `groups` inline and
+ *  has no timestamps. A stored group's members come from
+ *  {@link LoomcycleClient.getGroup}. */
+export interface GroupRow {
+    tenant_id?: string;
+    name: string;
+    description?: string;
+    /** Set on a group an identity provider owns: its members are managed there,
+     *  and a write here is refused (409 `group_external`). */
+    external_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    created_by?: string;
+    source?: AclSource;
+    members?: string[];
+    groups?: string[];
+}
+export type GroupMemberKind = "user" | "group";
+/** One direct membership edge of a stored group. */
+export interface GroupMember {
+    tenant_id?: string;
+    group: string;
+    member_kind: GroupMemberKind;
+    member_id: string;
+    added_at: string;
+    added_by?: string;
+}
+export interface GroupListResponse {
+    groups: GroupRow[];
+}
+/** `GET /v1/_groups/{name}`: a stored group with its direct members. */
+export interface GroupDetail {
+    group: GroupRow;
+    members: GroupMember[] | null;
+    /** Every group a member of this one is also in, transitively, this one
+     *  included. */
+    contained_in: string[] | null;
+}
+/** `GET /v1/_groups/{name}/effective`: everyone the group holds, at any
+ *  nesting depth, config-declared members included. */
+export interface GroupEffective {
+    group: string;
+    /** User subjects, sorted. */
+    users: string[];
+    /** The nested groups walked, sorted (the group itself excluded). */
+    groups: string[];
+}
+/** The body of {@link LoomcycleClient.createGroup}: an upsert by name. */
+export interface CreateGroupBody {
+    name: string;
+    description?: string;
+    external_id?: string;
+}
+/** What a membership write reports. `removed` is set by a removal. */
+export interface GroupMemberChange {
+    group: string;
+    kind: GroupMemberKind;
+    id: string;
+    removed?: boolean;
+}
+/** One binding of a list to a subject: a stored one, or (`source: "config"`)
+ *  one the config declares, which has no `binding_id` and no timestamps. */
+export interface AclBinding {
+    binding_id?: string;
+    tenant_id?: string;
+    acl: string;
+    subject_kind: AclSubjectKind;
+    /** Absent for a tenant-wide binding. */
+    subject_id?: string;
+    /** Absent when the binding never expires. */
+    expires_at?: string;
+    created_at?: string;
+    created_by?: string;
+    /** Set once retired; absent while live. */
+    retired_at?: string;
+    source?: AclSource;
+}
+export interface AclBindingListResponse {
+    bindings: AclBinding[];
+}
+/** The body of {@link LoomcycleClient.createAclBinding}. The list must exist
+ *  and `expires_at` (RFC 3339) must be in the future, or the server refuses
+ *  with 400 `acl_binding_invalid`. */
+export interface CreateAclBindingBody {
+    acl: string;
+    subject_kind: AclSubjectKind;
+    subject_id?: string;
+    expires_at?: string;
+}
+/** One rule that decided: list, its version, the rule's index, its effect. */
+export interface AuthzReason {
+    acl: string;
+    version?: number;
+    rule: number;
+    effect: AclEffect;
+}
+/** An access-control decision (AuthZEN 1.0 shape). `decision` is true only
+ *  when a rule allowed; `outcome` `no_match` means no rule spoke, which in
+ *  `compat` and `shadow` mode the scope gate then decides. */
+export interface AuthzDecision {
+    decision: boolean;
+    outcome: "allow" | "deny" | "no_match";
+    reasons?: AuthzReason[];
+    /** The request crossed a tenant and no rule was read. */
+    tenant_floor?: boolean;
+    mode: AclMode;
+}
+/** The request context a rule's `when` is judged against. Omitted fields take
+ *  the call's own (`transport` is the transport the call arrived on). */
+export interface AuthzRequestContext {
+    transport?: string;
+    interactive?: boolean;
+    tier?: string;
+    user_tier?: string;
+    agent?: string;
+    depth?: number;
+}
+/** One question: may `subject` do `action` to `resource`? An omitted
+ *  `subject` (or one naming the caller) asks about the caller; naming another
+ *  subject of the tenant needs a tenant operator. An empty `resource.id` asks
+ *  about any instance of the type. */
+export interface AuthzEvaluationRequest {
+    subject?: {
+        type?: string;
+        id?: string;
+    };
+    action: {
+        name: string;
+    };
+    resource: {
+        type: string;
+        id: string;
+        owner?: string;
+    };
+    context?: AuthzRequestContext;
+}
+/** How {@link LoomcycleClient.authzEvaluations} runs its batch. */
+export type AuthzEvaluationsSemantic = "execute_all" | "deny_on_first_deny" | "permit_on_first_permit";
+/** A batch of questions for one subject. A top-level `action`, `resource` or
+ *  `context` is the default each entry that omits its own inherits. 1 to 256
+ *  entries. */
+export interface AuthzEvaluationsRequest {
+    subject?: {
+        type?: string;
+        id?: string;
+    };
+    action?: {
+        name: string;
+    };
+    resource?: {
+        type: string;
+        id: string;
+        owner?: string;
+    };
+    context?: AuthzRequestContext;
+    evaluations: Array<Partial<Omit<AuthzEvaluationRequest, "subject">>>;
+    options?: {
+        evaluations_semantic?: AuthzEvaluationsSemantic;
+    };
+}
+export interface AuthzEvaluationsResponse {
+    evaluations: AuthzDecision[];
+}
+/** One rule the engine read for an explanation, matching or not, and why. */
+export interface AuthzTrace {
+    acl: string;
+    version?: number;
+    rule: number;
+    effect: AclEffect;
+    matched: boolean;
+    why: string;
+}
+/** A binding as the engine applied it. */
+export interface AuthzAppliedBinding {
+    id?: string;
+    acl: string;
+    subject_kind: AclSubjectKind;
+    subject_id?: string;
+    expires_at?: string;
+}
+/** `POST /v1/_authz/explain`: the decision, every rule read for the resource's
+ *  type, the bound lists that do not exist, the bindings applied, and the
+ *  subject's groups. */
+export interface AuthzExplainResponse {
+    decision: AuthzDecision;
+    traces: AuthzTrace[] | null;
+    missing_acls: string[] | null;
+    applied_bindings: AuthzAppliedBinding[] | null;
+    groups: string[] | null;
+}
+/** A draft binding for {@link LoomcycleClient.authzSimulate}. */
+export interface AuthzDraftBinding {
+    acl: string;
+    subject_kind: AclSubjectKind;
+    subject_id?: string;
+    expires_at?: string;
+}
+/** Evaluate questions against a DRAFT: the subject's lists and bindings now,
+ *  with `acls` added or replaced by name and `bindings` added. Nothing is
+ *  written. 1 to 256 requests. */
+export interface AuthzSimulateRequest {
+    subject?: {
+        type?: string;
+        id?: string;
+    };
+    acls?: AclList[];
+    bindings?: AuthzDraftBinding[];
+    requests: AuthzEvaluationRequest[];
+}
+export interface AuthzSimulateResult {
+    /** The request, echoed. */
+    request: AuthzEvaluationRequest;
+    now: AuthzDecision;
+    with_draft: AuthzDecision;
+    /** The outcome differs between `now` and `with_draft`. */
+    changed: boolean;
+}
+export interface AuthzSimulateResponse {
+    results: AuthzSimulateResult[];
+    /** Lists the draft's bindings name that no layer has. */
+    missing_acls: string[] | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcycle/client",
-  "version": "1.121.0",
+  "version": "1.122.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",