Skip to content

v0.12.0

Choose a tag to compare

@sasan1200 sasan1200 released this 15 Jul 19:30
· 453 commits to main since this release

Added

  • Added deterministic consumer snapshot tooling for release-candidate evidence.
    It captures dirty tracked and intended untracked sources without private or
    generated artifacts, emits a verified Git bundle plus path/mode/content
    metadata, encodes untracked provenance in the immutable commit, preserves
    original worktree status bytes, rejects capture races, and lets the consumer
    verifier consume and independently re-derive that durable evidence directly.
    Final evidence can pin the expected consumer origin/base, rejects private
    workstation paths and agent/debug artifacts, and verifies the captured RC
    dependency and lock without rewriting either file.

  • Aligned Hermes runtime control with the live aiohttp API Server: baseUrl
    capability-probes /v1/capabilities and maps /v1/models,
    /api/sessions/list, and /api/sessions/usage. The separate TUI dashboard
    remains explicit, API-server-only clients do not claim gateway.raw, and an
    existing run may opt into /v1/runs/{run_id}/events SSE without creating a
    run. Unsupported auth, session mutations, cron-as-task, and workspace remain
    typed unavailable. OpenClaw's owned default identity now matches the accepted
    openclaw-control-ui; explicit consumer identity still wins.
    API Server authentication resolves independently from explicit dashboard
    credentials, and runtime disposal aborts all active API Server SSE streams
    while suppressing post-dispose delivery. Naturally completed and failed
    streams release their captured handlers immediately; later caller or runtime
    disposal is harmless.

  • Added opt-in, provider-neutral RuntimeControlClientOptions.gatewayReconnect
    with retryable-only bounded backoff for owned OpenClaw gateway lifecycles.
    Concurrent connects share only their in-flight promise, later manual connects
    invoke the transport again, and disposal cancels pending retries. Hermes
    rejects the policy and post-close manual reconnect explicitly because its
    fixed dashboard channel cannot be reconstructed safely.

  • Added provider-neutral RuntimeControlClientOptions.gatewayConnection,
    composed from the existing GatewayRpcClientOptions, so owned OpenClaw
    connections can receive mobile-safe identity, device signing, scopes,
    protocol, timeout, request-limit, and redacted RPC-trace settings. Injected
    transports retain precedence; Hermes rejects unsupported fields explicitly
    instead of silently downgrading security configuration.

  • Added the optional provider-neutral GATEWAY_RAW_EXTENSION (gateway.raw)
    contract for arbitrary operation requests, unchanged raw event snapshots,
    normalized connection state, cancellation, and exact-once asynchronous
    disposal. The descriptor does not claim provider support and remains distinct
    from normalized runtime-control events and the CAVI-only cavi.control
    extension.

  • Added shared gateway.raw conformance for OpenClaw and Hermes covering
    request and raw-event identity, listener isolation, ordered reconnect state,
    abort propagation, typed unsupported operations, and exact-once disposal.
    Published testing imports, compatibility evidence, and dependency guardrails
    keep the suite provider-neutral; REST-only Hermes remains unsupported.

  • Added the CAVI extension's provider-neutral resolvePluginApiPath dispatcher
    for generic /api/plugins/{plugin}/... routes and the
    LIBRARY_LEGACY_API_BASE_PATH compatibility constant for consumers that
    normalize released /library/api inputs. Portal dispatch and existing
    library route behavior are unchanged.

  • Added a provider-neutral runtime-control scenario catalog through the testing
    subpath. It records typed capability unavailability, keeps live mutation
    probes behind an explicit disposable mode and typed extension, cleans created
    resources in reverse order, redacts failure details, and always reports client
    disposal independently.

  • Added a provider-neutral typed extension registry to RuntimeControlClient.
    Descriptors normalize IDs, registries reject blank or duplicate IDs and expose
    immutable sorted discovery with descriptor-identity lookup, and repeated
    withRuntimeControlExtensions calls compose without shadowing existing or core
    client properties while preserving module identity and delegating disposal
    exactly once.

  • Added the typed CAVI_CONTROL_EXTENSION (cavi.control) descriptor. The CAVI
    registry enhancer now installs independently constructed complete CAVI control
    adapters for configured OpenClaw and Hermes providers while preserving their
    released core modules, immutable base registries, and canonical alias checks.

  • Added the CAVI-only withCaviRuntimeControlProviders registry enhancer. It
    immutably installs the resolved Hermes runtime-control factory while
    preserving base modules, aliases, capabilities, resolution order, the root
    capability matrix, and provider-neutral package-factory options. Canonical
    Hermes identity now fails closed for missing, ambiguous, or alias-shadowed
    registries; generic module types and defensive-copy registries are preserved,
    and mutable extension setup is snapshotted without cloning opaque runtime
    resources.

  • Documented branch-free RuntimeControlClient consumption and the exact
    Hermes/OpenClaw transport, REST fallback, event, authentication, lifecycle,
    task, workspace, cost, and upstream protocol-ownership boundaries. The
    Hermes session module requires both dashboard REST and a channel. An explicit
    dashboard token suppresses authentication resolution and wins over the generic
    token; otherwise a resolved authorization header wins, with the generic token
    supplying bearer authorization when resolved headers contain no authentication.
    Hermes session pagination preserves validated upstream totals, CAVI task
    snapshots fail closed on malformed nested schemas, and task/workspace metadata
    reports the adapter's actual WebSocket or HTTP transport without labeling
    local fallback data as wire traffic. Blank resolved authorization values use
    the generic bearer token, session cursors stop at the 200-row bound and do not
    repeat when REST fallback cannot advance, and partial operator-section
    fallbacks retain non-wire provenance. The
    immutable generated v0.11.0 documentation remains historically accurate
    and intentionally excludes these unreleased APIs.

  • Added an OpenAI-style operation reference to the documentation pipeline
    (rendered on cavi-ai.xyz): per-operation method signatures, request bodies,
    responses, runnable examples, and the HTTP endpoint each operation maps to,
    covering the universal runtime contract, every provider (Claude, Codex,
    Gemini, Hermes, OpenClaw), Claude Managed Agents, the gateway control-plane and
    WebSocket RPC surfaces, and the CAVI extension, plus a companion redundancy
    audit that records removal candidates. A new docs:check step
    (scripts/docs/check-operation-endpoints.mjs) fails the build when a
    documented HTTP path is not owned by a paths.ts file.

Changed

  • Extracted the core gateway session loaders behind an injectable,
    provider-neutral GatewaySessionOperations port. The default OpenClaw adapter
    preserves the released plural sessions.* RPC and REST fallback mappings,
    payloads, caches, and one-argument loader calls without adding a CAVI copy.
    Optional request options now propagate through every session operation;
    already-aborted signals prevent legacy transport dispatch, while in-flight
    cancellation remains unsupported by those released transports.
  • Extended the additive gateway session operation seam with optional typed
    cancellation and provider-neutral raw creation/update/state fields. Canonical
    session methods now share abortable request option types; providers without
    proven cancellation semantics keep the optional operation absent.
  • Directly renamed the unreleased canonical facade, factories, provider hook,
    and conformance kit to the RuntimeControlClient vocabulary. This is a
    pre-release rename, not a compatibility removal; the older released
    RuntimeControlPlane declaration API remains intact.
  • Reduced API.md to an index that points at the pipeline operation reference;
    its former control-plane facade and OpenClaw adapter prose moved into the
    operation pages, and the docs-integrity contract now verifies them there.
    Renamed the Claude provider reference page to claude-anthropic.md to avoid a
    CLAUDE.md case collision on case-insensitive filesystems.

Fixed

  • OpenClaw canonical session summaries now preserve the upstream preferred
    title, using an explicit session label before the derived display name for
    both list and get operations.

  • Aligned OpenClaw control-plane validation with current upstream
    sessions.list pagination/default metadata, usage.cost cost-detail and
    cache-status fields, and agents.list runtime/thinking metadata while
    retaining fail-closed nested validation, including current session label and
    display-name fields. Current OpenClaw session pagination now follows validated
    continuation metadata without truncating later pages.
    Already-aborted OpenClaw requests no longer dispatch a hidden RPC that rejects
    during disposal, Hermes API Server requests preserve caller abort identity
    without dispatching fetch, and late caller cancellation no longer masks an
    unrelated HTTP transport failure or a timeout that already won the combined
    abort race.

  • Made Hermes runtime-control composition independent per configured surface:
    CAVI task/workspace adapters now install without dashboard REST, while absent
    dashboard modules remain exact unavailable facades. Construction now unwinds
    owned channels and RPC resources in reverse order, including readiness,
    synchronous subscription, and post-construction abort failures, without
    closing borrowed channels or replacing the primary error.

  • Added the current /cavi-control/api/cost/history route as a fail-closed
    fallback for 404/405 responses from the released plugin cost-history route.
    The existing adapter, response handling, fallback behavior, and in-flight
    cache remain shared; authentication, server, schema, and abort failures do
    not try the alias.

  • Strengthened the CAVI ownership guard to validate complete classification
    metadata and resolve static, dynamic, TypeScript import-equals, CommonJS, and
    relative barrel dependencies across core, contracts, providers, and extension
    implementations. Inventory owners and classification families now also match
    each compiler-resolved export declaration rather than trusting table text.

  • Hardened the OpenClaw canonical adapter so factory-owned WebSockets resolve
    fresh bearer authentication case-insensitively before connecting, without
    duplicate semantic headers. Native event names and payloads are bounded and
    secret-safe before delivery; malformed wire responses become sanitized
    TransportProtocolError failures, workspace identity comes only from explicit
    workspace descriptors, and currency-less upstream cost totals stay canonically
    unavailable while their validated amount remains provider data.

  • Expanded canonical control-plane conformance from object-presence checks to
    exact method and behavioral validation, guaranteed facade disposal, and real
    package-factory coverage through the provider-neutral injected transport
    seam. Empty module objects and unavailable errors with a mismatched provider
    or operation capability no longer pass conformance.

  • Corrected API documentation that simultaneously advertised OpenClaw's adapter
    and described the package as shipping no built-in adapter.

  • OpenClaw's internal control-plane factory now supplies a stable provider
    client identity when it creates the authenticated WebSocket connection.

  • Made the package-root canonical control-plane factory resolve shipped
    provider modules through a provider-layer registry while preserving explicit
    registry overrides and the provider-neutral core dependency boundary.

Added

  • Added the CAVI-extension Hermes RuntimeControlClient composer. It exposes
    the complete seven-module facade, installs only configured dashboard/CAVI
    modules, preserves typed unavailable fallbacks, applies explicit dashboard
    auth precedence, and disposes owned transports idempotently without closing
    borrowed injected channels.

  • Added the CAVI-owned Hermes dashboard standard JSON-RPC driver with bounded,
    abortable requests, validated event notifications, secret-safe remote errors,
    explicit injected-channel ownership, remote-close synchronization, and a safe
    protocol-error observer. Matching malformed responses now reject their shared
    JSON-RPC request instead of occupying capacity indefinitely. The driver
    intentionally does not implement OpenClaw gateway framing, handshake, or
    unobservable reconnect replay claims.

  • Documented every public CAVI extension export in a compiler-checked ownership
    inventory and enforced the core-to-extension dependency direction, the exact
    four released provider forwarding exceptions, and generic transport/snapshot
    implementation ownership without changing any public export.

  • Published the provider-neutral createRuntimeControlClient facade and root
    CapabilityUnavailable error for the exact authStatus, sessions,
    models, usage, tasks, workspace, and events contract. Documented the
    verified OpenClaw method subset, typed unavailable native cursor resume,
    stream.reconnected plus stream.gap behavior without replay, and
    client-owned versus caller-owned disposal without changing existing root
    exports, provider subpaths, or execution-plane behavior.

  • Registered OpenClaw's canonical seven-module control-plane factory and marked
    only fixture-verified agent, model/auth, usage, session, and task RPC shapes.
    Other providers keep the same facade shape with typed unavailable errors.

  • Added OpenClaw capability-matrix detail and documented native reconnect,
    typed unavailable cursor resume, and explicit stream-gap semantics without
    changing existing rows, aliases, routes, or subpath exports.

  • Added provider-specific lifecycle helpers to OpenClawWebSocketClient for a
    narrow control-plane RPC seam: event subscription, abortable caller waits,
    and idempotent disposal without changing the authenticated gateway wire
    handshake. The internal OpenClaw control-plane factory owns clients it
    creates and leaves injected RPC seams caller-owned by default.

  • Provider-neutral createRuntimeControlClient(provider, options) construction,
    with alias-aware registry lookup, optional provider canonical factories, and
    a complete typed unavailable facade when a registered adapter is absent.
    Factory options cover URLs, token/auth resolution, cancellation, tracing, and
    injected transport without adding a built-in provider adapter.

  • Required RuntimeControlClient facade with authentication status,
    sessions, models, usage, tasks, workspace, and events modules, plus idempotent
    disposal and CapabilityUnavailable-based unavailable-provider scaffolding.
    The existing optional RuntimeControlPlane contract remains supported.

  • A versioned documentation consumer contract for the immutable 0.11.0
    artifact, including its copy path, public base path, stable alias, navigation
    entry point, source-package and generated-content integrity checks, complete
    contract and release navigation, and the explicit repository/CI handoff for
    documentation generated after the already-published npm release.

  • Universal shared transport infrastructure at
    @cavi-ai/api-client/core/transport, with createHttpTransport,
    createSseTransport, createWebSocketTransport, and
    createJsonRpcTransport; curated root transport contracts and guards; and
    compile-checked browser and Node examples. Retries and reconnects are bounded
    and opt-in, mutations require explicit idempotency for replay, SSE resumes by
    cursor with bounded dedupe, and errors/lifecycle events remain secret-safe.

  • Node-only stdio and Unix-domain socket byte-channel drivers under
    @cavi-ai/api-client/core/transport/node, with bounded opt-in reconnects,
    backpressure handling, no write replay, and exact-once owned-resource cleanup.

  • Provider-neutral runtime error codes and optional typed runtime metadata on
    ApiClientError, with a root-exported metadata getter and unchanged error
    serialization.

  • Provider-neutral runtime control-plane metadata and pagination contracts,
    plus typed HTTP, SSE, WebSocket, JSON-RPC, stdio, and Unix-socket transport
    capabilities with stable-transport detection.

  • Focused provider-neutral control-plane contracts for sessions, model catalogs,
    authentication status, usage and cost, tasks, and workspaces.

  • Normalized runtime control-plane event contracts, continuity inspection, event
    subscriptions, and the aggregate RuntimeControlPlane provider surface.

  • Optional provider control-plane declarations and factories, plus a frozen
    capability matrix for all six shipped provider entries. The matrix records
    existing runtime and transport facts without advertising control-plane
    modules before adapters exist.

  • Runner-neutral control-plane conformance inspection through the testing
    subpath, with curated root and core runtime contract exports that preserve the
    supported root capability-matrix surface without leaking provider adapters.

  • Compile-checked control-plane provider guidance documenting the additive
    execution/control-plane split, stable-first declarations, secret-safe auth
    status, and the truthful adapter-free initial capability matrix.

  • @cavi-ai/api-client/core/kanban — the first unified capability interface: a
    provider-agnostic KanbanClient with canonical card types that preserve the
    backend's native status alongside a canonical status category. Ships an
    OpenClaw Workboard adapter and a @cavi-ai/api-client/testing kanban
    conformance kit (inspectKanbanConformance) that any supports.kanban
    provider must pass.

Fixed

  • Transport authentication failures no longer retain resolver errors that may
    contain credentials; WebSocket disconnect handling is exact-once per socket
    generation; and Unix-socket reconnect timing uses injectable dependencies.
  • Runtime error metadata now validates its required and optional fields before
    narrowing unknown values, while preserving the stable serialized error shape.
  • Control-plane conformance now rejects both missing declared transports and
    undeclared exposed transports, and the provider matrix no longer represents
    OpenClaw's WebSocket RPC encoding as a separate transport or marks Hermes
    WebSocket support stable without sufficient implementation evidence.