novoagents 0.5.0-alpha.21 → 0.5.0-alpha.22

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 Customer-facing release notes for the supported pre-launch `novoagents` SDK
 and hosted API contract. Current documentation is the source of truth.
 
+## 0.5.0-alpha.22 - 2026-08-18
+
+- **Every executed tool call announces its start and its exact end.** An
+  ordinary tool wait is now a complete `data-novo-heartbeat` series: an
+  `executing_tool` opener (`beat: 0`, `elapsedMs: 0`) written the instant the
+  tool body starts, a beat per interval while it runs, and `settled` with the
+  call's exact `elapsedMs` when it ends. Sub-interval calls used to emit no
+  frame at all, and the first beat arrived one interval in — so a sibling
+  queued behind an exclusive tool was indistinguishable from a running one,
+  because `tool-input-*` is written when the model ASKS, before the scheduler
+  admits the call. Time a call from its own series (`emittedAt - elapsedMs`),
+  never from when you saw its `tool-input-start`, and stop on `settled`.
+  Delegation calls keep their existing lifecycle (`data-novo-task` is their
+  start signal). Additive; `beat` is `0` only on this opener.
+- **The browser message reducer keeps one heartbeat part per wait.**
+  `data-novo-heartbeat` was classified as run-level control state and dropped
+  from `message.parts`, which contradicted its own contract ("a heartbeat `id`
+  is stable within one wait and replaces its prior value") and left the
+  run-level `heartbeat` (latest wins) unable to tell two concurrent waits apart.
+  Each wait's frames now share one replace-in-place part, so a parked
+  transcript holds one part per tool call or delegated wave. The run-level
+  `heartbeat` is unchanged.
+- The stream reader mints no progress activity line for a wait's opener or its
+  `settled` frame; a closed tool wait no longer reads as "Waiting for
+  delegated work."
+- Docs now name `settled` explicitly (it shipped in the stream schema 12 line
+  without a changelog entry). No wire-contract or stream-schema revision.
+
 ## 0.5.0-alpha.21 - 2026-08-17
 
 - **`authorization_incomplete` leaves `NovoErrorCode`.** No route ever produced

package/dist/browser/reducer.js

@@ -10,12 +10,17 @@ const MESSAGE_CONTROL_DATA_TYPES = new Set([
     'data-novo-usage',
     'data-novo-step-terminal',
     'data-novo-model-step-restart',
-    // Heartbeats are run-level liveness state (latest wins); accumulating one
-    // message part per beat grows a parked transcript without bound.
-    'data-novo-heartbeat',
 ]);
 const KNOWN_DATA_TYPES = new Set([
     ...MESSAGE_CONTROL_DATA_TYPES,
+    // One heartbeat part per WAIT, replaced in place: the producer keeps the
+    // part id stable for a wait's whole series (`heartbeat_<waitId>`), so a
+    // parked transcript holds one part per tool call or delegated wave, never
+    // one per beat. Retaining it is what lets a consumer time each parallel tool
+    // call from its own series (`emittedAt - elapsedMs`) and freeze it on
+    // `settled`; the run-level `heartbeat` (latest wins) is liveness only and
+    // cannot tell two concurrent waits apart.
+    'data-novo-heartbeat',
     'data-novo-terminal',
     'data-novo-task',
     'data-novo-followup-replayed',
@@ -387,6 +392,22 @@ export function createNovoMessageSession(options = {}) {
             // The output may still be buffered with no visible part index.
             tools.delete(toolCallId);
         }
+        // A superseded call's heartbeat wait goes with it: the part is keyed by
+        // wait id, not tool call id, so find it by the `toolCallId` it carries.
+        // Left behind it would be execution evidence for a call the transcript no
+        // longer holds, accumulating one orphan per restarted attempt.
+        if (toolCallIds.size > 0) {
+            message.parts.forEach((part, index) => {
+                if (part.type !== 'data-novo-heartbeat')
+                    return;
+                const data = part.data;
+                if (isRecord(data) &&
+                    typeof data.toolCallId === 'string' &&
+                    toolCallIds.has(data.toolCallId)) {
+                    removedIndexes.add(index);
+                }
+            });
+        }
         for (const sourceId of sourceIds) {
             const index = latestSourceParts.get(sourceId);
             if (index !== undefined)

package/dist/types.d.ts

@@ -442,19 +442,31 @@ export type NovoTaskChunk = {
  *
  * - `phase: 'delegating'` is an identity-redacted frame emitted as an internal
  *   delegation call begins, before a worker task card can exist.
- * - `phase: 'executing_tool'` repeats roughly every 15s until the call settles.
+ * - `phase: 'executing_tool'` opens an ordinary tool wait the instant the tool
+ *   body starts (`beat: 0`, `elapsedMs: 0`) and repeats roughly every 15s
+ *   until the call settles. The opener is your only evidence that a call is
+ *   EXECUTING: `tool-input-*` is written when the model asks, before the
+ *   scheduler admits the call, so a sibling queued behind an exclusive tool
+ *   looks identical to a running one until this frame arrives. Time the call
+ *   from its own series (`emittedAt - elapsedMs`), never from when you saw its
+ *   `tool-input-start`.
  * - `phase: 'awaiting_subagents'` is a SINGLE frame that opens a delegated wait
  *   BEFORE any launch begins, carrying the intended task count with empty
  *   `workerRefs` — per-worker refs arrive on each `data-novo-task` as its
  *   launch succeeds. An orchestrator suspended on its subagents runs no code of
  *   its own, so track each task with `data-novo-task` and its worker sub-stream
  *   rather than expecting a series.
- * - `phase: 'settled'` closes an `'executing_tool'` wait, and is the frame a
- *   live timer must stop on. It closes ONLY that wait — a delegated wait is a
- *   single frame and is never closed by a heartbeat, so do not block a spinner
- *   on one arriving.
+ * - `phase: 'settled'` closes an `'executing_tool'` wait — every executed
+ *   ordinary tool call, sub-interval ones included — carrying the call's exact
+ *   `elapsedMs` plus its `toolCallId`. It is the frame a live timer must stop
+ *   on. An internal delegation call that beat past the interval also closes
+ *   with an identity-free `settled` on its opaque wait id. The single
+ *   `'awaiting_subagents'` wave frame is never closed by a heartbeat, so do
+ *   not block a spinner on one arriving.
  *
- * Purely informational.
+ * The message reducer keeps ONE heartbeat part per wait (`id` is stable for
+ * the series and each frame replaces the last), so a parked transcript holds
+ * one part per tool call or delegated wave. Purely informational.
  */
 export type NovoHeartbeatChunk = {
     type: 'data-novo-heartbeat';
@@ -475,19 +487,32 @@ export type NovoHeartbeatChunk = {
          * beat instead counts up forever, which is how an 18-second tool call
          * renders as "Running command - 5m 19s".
          *
-         * Three cases where it never arrives, all expected:
-         * - a tool call that ends inside the first beat interval opens no wait, so
-         *   it closes none — there are no frames for it at all;
+         * Two cases where it never arrives, both expected:
          * - an `'awaiting_subagents'` wait is a single frame and is NEVER closed by
          *   a heartbeat, because a suspended orchestrator runs no code of its own.
          *   Track delegated work with `data-novo-task` and the worker sub-streams;
-         * - a `'delegating'` frame is likewise never closed — it is superseded by
-         *   the wave's `'awaiting_subagents'` frame and the `data-novo-task` cards.
+         * - the reader-synthesized `'delegating'` frame is never closed — it is
+         *   superseded by the wave's `'awaiting_subagents'` frame and the
+         *   `data-novo-task` cards. (A LIVE delegation beat loop, on a call that
+         *   outlived the interval, does close its opaque wait with an identity-free
+         *   `'settled'`; nothing about a delegated task's outcome rides on it.)
+         *
+         * Every executed ordinary tool call opens (`beat: 0`) and settles, so a
+         * `tool-input-available` with no opener means the call has not started
+         * executing — queued, awaiting approval, or not yet admitted.
          */
         phase: 'delegating' | 'awaiting_subagents' | 'executing_tool' | 'settled';
-        /** 1-based monotonic beat within the current wait. */
+        /**
+         * Monotonic beat within the current wait: `0` on the frame that opens an
+         * ordinary tool wait, then 1-based per interval. The `awaiting_subagents`
+         * opener and the reader-synthesized `delegating` frame use `1`.
+         */
         beat: number;
-        /** Elapsed wall clock since the wait began; 0 on the frame that opens one. */
+        /**
+         * Elapsed wall clock since the wait began, on the producer's clock; 0 on
+         * the frame that opens one and the call's exact duration on `'settled'`.
+         * `emittedAt - elapsedMs` is the wait's start from any frame of the series.
+         */
         elapsedMs: number;
         /** Outstanding items this heartbeat is still waiting on. */
         activeTaskCount: number;
@@ -515,9 +540,14 @@ export type NovoHeartbeatChunk = {
          * `data-novo-task` and the worker sub-streams instead.
          */
         emittedAt?: string;
-        /** The executing call, matching its `tool-input-*` frames (`executing_tool`). */
+        /**
+         * The call this wait belongs to, matching its `tool-input-*` frames. On
+         * every frame of an ordinary tool wait — opener, beats, and `settled` —
+         * so a consumer can correlate the closer even when it replaced the opener
+         * in place. Absent on delegation and wave frames.
+         */
         toolCallId?: string;
-        /** Public tool name of the executing call (`executing_tool`). */
+        /** Public tool name of the call, on the same frames as `toolCallId`. */
         toolName?: string;
     };
 };

package/docs/changelog.md

@@ -3,6 +3,29 @@
 Release notes describe the supported pre-launch API and `novoagents` SDK.
 Current API pages remain the source of truth for new integrations.
 
+## 0.5.0-alpha.22 - 2026-08-18
+
+- **Every executed tool call announces its start and its exact end.** An
+  ordinary tool wait is a complete `data-novo-heartbeat` series: an
+  `executing_tool` opener (`beat: 0`, `elapsedMs: 0`) the instant the tool body
+  starts, a beat per interval, and `settled` with the exact `elapsedMs`. The
+  opener is the only evidence a call is executing rather than queued
+  (`tool-input-*` is written when the model asks, before admission). Time a call
+  from its own series as `emittedAt - elapsedMs`; stop on `settled`.
+- The browser message reducer keeps one `data-novo-heartbeat` part per wait,
+  replaced in place, so concurrent tool calls can be timed independently from
+  `run.messages`. The run-level `heartbeat` is unchanged.
+- No wire-contract or stream-schema revision.
+
+## 0.5.0-alpha.21 - 2026-08-17
+
+- `authorization_incomplete` leaves `NovoErrorCode`; it is a `github_error`
+  value on the return to `returnUrl`. Wire contract revised; no stream-schema
+  change.
+- An organization owner's approval no longer binds an installation on its own:
+  once the owner approves, call `authorize({ connectionId })` again and complete
+  the selection as for a new connect.
+
 ## 0.5.0-alpha.20 - 2026-08-17
 
 - **Finish a GitHub connect in your own product.** The install callback binds

package/docs/concepts/streaming.md

@@ -68,7 +68,7 @@ The stream is composed of a fixed sequence of chunk families. Per assistant step
    - `data-novo-tool-result-overflow` interleaved when a tool result spills past the budget. The clipping applies to the result's readable text; media blocks (image, audio, video) are dropped whole rather than binary-truncated, since a sliced base64 payload decodes to a corrupt file
    - `data-novo-browser-session` interleaved when the managed [browser](https://novoagents.ai/docs/concepts/managed-browser.md) opens, changes page, or closes, always before the turn's `data-novo-step-terminal`
    - `data-novo-task` interleaved when an orchestrator starts or finishes a delegated [subagent](https://novoagents.ai/docs/concepts/subagents.md) task
-   - `data-novo-heartbeat` interleaved during long tool calls and delegated waits. See the [taxonomy](#the-data-novo-taxonomy) for timer and parallel-call handling
+   - `data-novo-heartbeat` opening, beating through, and closing each executed tool call, and during delegated waits. See the [taxonomy](#the-data-novo-taxonomy) for timer and parallel-call handling
 4. **`data-novo-step-terminal`**: closes an assistant **turn**, a maximal run of model steps that isn't interrupted by a pause. The model takes as many `start-step`…`finish-step` model steps as the task needs inside one turn, and a single `data-novo-step-terminal` closes the turn once the model stops or the run pauses. A run that never pauses is one turn, so you get **exactly one** `data-novo-step-terminal`, just before the run's `data-novo-usage`/`data-novo-terminal`; a run that pauses (approval, question, worker) and resumes emits one per resumed segment. It carries the turn's messages, the turn's **cumulative usage delta** (summed across the turn's model steps), a `modelFinishReason`, a generic provider-neutral `modelLabel`, the run's `chargeId` (the join key to the `usage.events` debit row), and optional `perf` timing.
 5. **Pause chunks (between steps, when applicable):**
    - `data-novo-input-requested` → `data-novo-input-resolved` around any pause. The `request.kind` (`'approval_request'` or `'question'`) tells the two apart; an approval is just an input request whose options are `[approve, deny]`.
@@ -146,7 +146,7 @@ A `status: 'failed'` with `terminalReason: null` means the model errored. A `sta
 | `data-novo-tool-server-unavailable` | An MCP tool server is unavailable to the run: disabled by policy (`errorCode: 'policy_denied'`), or its tool listing failed. A listing failure is retried and then fails the step; the run never continues without the server's tools. |
 | `data-novo-http-connection-unavailable` | An HTTP connection is unavailable to the run: disabled by policy (`errorCode: 'policy_denied'`), or its OpenAPI spec failed to load or parse (`errorCode: 'spec_unreachable' \| 'spec_invalid' \| 'base_url_missing'`), in which case the failure is retried and then fails the step; the run never continues without the connection's operations. Operation-level non-2xx responses are not this chunk; they return to the model as tool output. |
 | `data-novo-task` | A delegated [subagent](https://novoagents.ai/docs/concepts/subagents.md) task lifecycle on the orchestrator stream. One id-reconciled card per task carrying `{ rootRunId, workerRef, role: 'worker' \| 'advisor', status: 'started' \| 'completed' \| 'failed' \| 'cancelled', label?, summary? }`. Render `label` as the UI title; open the sub-stream with `runs.workers.stream(rootRunId, workerRef)`. |
-| `data-novo-heartbeat` | Optional liveness while a tool or delegated task is still pending. Carries `{ runId, rootRunId, threadId, agentId, phase, beat, elapsedMs, activeTaskCount, workerRefs }`, plus `toolCallId` and `toolName` for `executing_tool`, plus `emittedAt` on frames a live beat loop wrote. Measure staleness against `emittedAt` (ISO 8601, server time) rather than arrival time: reconnecting replays history, so an old beat can arrive seconds ago. Two opener shapes omit it and prove nothing about current liveness: the reader-synthesized `delegating` frame and the single `awaiting_subagents` frame. A live delegation tool beat also has phase `delegating` and does carry `emittedAt`, so use field presence rather than `phase` as provenance. Tool waits can emit repeated `executing_tool` beats followed by `settled`; stop any timer on `settled`. Delegated waits emit one `awaiting_subagents` frame, so track completion through `data-novo-task` and worker sub-streams. Parallel tool calls have independent series. A heartbeat `id` is stable within one wait and replaces its prior value. This frame is safe to ignore. |
+| `data-novo-heartbeat` | Optional liveness while a tool or delegated task is still pending. Carries `{ runId, rootRunId, threadId, agentId, phase, beat, elapsedMs, activeTaskCount, workerRefs }`, plus `toolCallId` and `toolName` on every frame of an ordinary tool wait (opener, beats, and `settled`), plus `emittedAt` on frames a live beat loop wrote. Measure staleness against `emittedAt` (ISO 8601, server time) rather than arrival time: reconnecting replays history, so an old beat can arrive seconds ago. Two opener shapes omit it and prove nothing about current liveness: the reader-synthesized `delegating` frame and the single `awaiting_subagents` frame. A live delegation tool beat also has phase `delegating` and does carry `emittedAt`, so use field presence rather than `phase` as provenance. Every executed ordinary tool call is a complete series: an `executing_tool` opener (`beat: 0`, `elapsedMs: 0`) the instant the tool body starts, a beat per interval while it runs, and `settled` with the exact `elapsedMs` when it ends. The opener is the only evidence a call is executing rather than queued (`tool-input-*` is written when the model asks, before the scheduler admits the call); time a call from its own series as `emittedAt - elapsedMs`, and stop any timer on `settled`. Delegated waves emit one `awaiting_subagents` frame that is never closed (an internal delegation call that outlived the interval closes its own opaque wait with an identity-free `settled`), so track completion through `data-novo-task` and worker sub-streams. Parallel tool calls have independent series. A heartbeat `id` is stable within one wait and replaces its prior value. This frame is safe to ignore. |
 | `data-novo-worker-meta` | First frame of a worker sub-stream. Carries root run identity, `workerRef`, `progressEnabled`, status, role, label, and the full dispatch prompt. |
 | `data-novo-worker-terminal` | Last frame of a worker sub-stream. Carries `workerRef`, terminal status/reason, and an optional structured error. |
 

package/docs/llms-full.md

@@ -941,7 +941,7 @@ The stream is composed of a fixed sequence of chunk families. Per assistant step
    - `data-novo-tool-result-overflow` interleaved when a tool result spills past the budget. The clipping applies to the result's readable text; media blocks (image, audio, video) are dropped whole rather than binary-truncated, since a sliced base64 payload decodes to a corrupt file
    - `data-novo-browser-session` interleaved when the managed [browser](https://novoagents.ai/docs/concepts/managed-browser.md) opens, changes page, or closes, always before the turn's `data-novo-step-terminal`
    - `data-novo-task` interleaved when an orchestrator starts or finishes a delegated [subagent](https://novoagents.ai/docs/concepts/subagents.md) task
-   - `data-novo-heartbeat` interleaved during long tool calls and delegated waits. See the [taxonomy](#the-data-novo-taxonomy) for timer and parallel-call handling
+   - `data-novo-heartbeat` opening, beating through, and closing each executed tool call, and during delegated waits. See the [taxonomy](#the-data-novo-taxonomy) for timer and parallel-call handling
 4. **`data-novo-step-terminal`**: closes an assistant **turn**, a maximal run of model steps that isn't interrupted by a pause. The model takes as many `start-step`…`finish-step` model steps as the task needs inside one turn, and a single `data-novo-step-terminal` closes the turn once the model stops or the run pauses. A run that never pauses is one turn, so you get **exactly one** `data-novo-step-terminal`, just before the run's `data-novo-usage`/`data-novo-terminal`; a run that pauses (approval, question, worker) and resumes emits one per resumed segment. It carries the turn's messages, the turn's **cumulative usage delta** (summed across the turn's model steps), a `modelFinishReason`, a generic provider-neutral `modelLabel`, the run's `chargeId` (the join key to the `usage.events` debit row), and optional `perf` timing.
 5. **Pause chunks (between steps, when applicable):**
    - `data-novo-input-requested` → `data-novo-input-resolved` around any pause. The `request.kind` (`'approval_request'` or `'question'`) tells the two apart; an approval is just an input request whose options are `[approve, deny]`.
@@ -1019,7 +1019,7 @@ A `status: 'failed'` with `terminalReason: null` means the model errored. A `sta
 | `data-novo-tool-server-unavailable` | An MCP tool server is unavailable to the run: disabled by policy (`errorCode: 'policy_denied'`), or its tool listing failed. A listing failure is retried and then fails the step; the run never continues without the server's tools. |
 | `data-novo-http-connection-unavailable` | An HTTP connection is unavailable to the run: disabled by policy (`errorCode: 'policy_denied'`), or its OpenAPI spec failed to load or parse (`errorCode: 'spec_unreachable' \| 'spec_invalid' \| 'base_url_missing'`), in which case the failure is retried and then fails the step; the run never continues without the connection's operations. Operation-level non-2xx responses are not this chunk; they return to the model as tool output. |
 | `data-novo-task` | A delegated [subagent](https://novoagents.ai/docs/concepts/subagents.md) task lifecycle on the orchestrator stream. One id-reconciled card per task carrying `{ rootRunId, workerRef, role: 'worker' \| 'advisor', status: 'started' \| 'completed' \| 'failed' \| 'cancelled', label?, summary? }`. Render `label` as the UI title; open the sub-stream with `runs.workers.stream(rootRunId, workerRef)`. |
-| `data-novo-heartbeat` | Optional liveness while a tool or delegated task is still pending. Carries `{ runId, rootRunId, threadId, agentId, phase, beat, elapsedMs, activeTaskCount, workerRefs }`, plus `toolCallId` and `toolName` for `executing_tool`, plus `emittedAt` on frames a live beat loop wrote. Measure staleness against `emittedAt` (ISO 8601, server time) rather than arrival time: reconnecting replays history, so an old beat can arrive seconds ago. Two opener shapes omit it and prove nothing about current liveness: the reader-synthesized `delegating` frame and the single `awaiting_subagents` frame. A live delegation tool beat also has phase `delegating` and does carry `emittedAt`, so use field presence rather than `phase` as provenance. Tool waits can emit repeated `executing_tool` beats followed by `settled`; stop any timer on `settled`. Delegated waits emit one `awaiting_subagents` frame, so track completion through `data-novo-task` and worker sub-streams. Parallel tool calls have independent series. A heartbeat `id` is stable within one wait and replaces its prior value. This frame is safe to ignore. |
+| `data-novo-heartbeat` | Optional liveness while a tool or delegated task is still pending. Carries `{ runId, rootRunId, threadId, agentId, phase, beat, elapsedMs, activeTaskCount, workerRefs }`, plus `toolCallId` and `toolName` on every frame of an ordinary tool wait (opener, beats, and `settled`), plus `emittedAt` on frames a live beat loop wrote. Measure staleness against `emittedAt` (ISO 8601, server time) rather than arrival time: reconnecting replays history, so an old beat can arrive seconds ago. Two opener shapes omit it and prove nothing about current liveness: the reader-synthesized `delegating` frame and the single `awaiting_subagents` frame. A live delegation tool beat also has phase `delegating` and does carry `emittedAt`, so use field presence rather than `phase` as provenance. Every executed ordinary tool call is a complete series: an `executing_tool` opener (`beat: 0`, `elapsedMs: 0`) the instant the tool body starts, a beat per interval while it runs, and `settled` with the exact `elapsedMs` when it ends. The opener is the only evidence a call is executing rather than queued (`tool-input-*` is written when the model asks, before the scheduler admits the call); time a call from its own series as `emittedAt - elapsedMs`, and stop any timer on `settled`. Delegated waves emit one `awaiting_subagents` frame that is never closed (an internal delegation call that outlived the interval closes its own opaque wait with an identity-free `settled`), so track completion through `data-novo-task` and worker sub-streams. Parallel tool calls have independent series. A heartbeat `id` is stable within one wait and replaces its prior value. This frame is safe to ignore. |
 | `data-novo-worker-meta` | First frame of a worker sub-stream. Carries root run identity, `workerRef`, `progressEnabled`, status, role, label, and the full dispatch prompt. |
 | `data-novo-worker-terminal` | Last frame of a worker sub-stream. Carries `workerRef`, terminal status/reason, and an optional structured error. |
 
@@ -6309,6 +6309,29 @@ source: https://novoagents.ai/docs/changelog.md
 Release notes describe the supported pre-launch API and `novoagents` SDK.
 Current API pages remain the source of truth for new integrations.
 
+## 0.5.0-alpha.22 - 2026-08-18
+
+- **Every executed tool call announces its start and its exact end.** An
+  ordinary tool wait is a complete `data-novo-heartbeat` series: an
+  `executing_tool` opener (`beat: 0`, `elapsedMs: 0`) the instant the tool body
+  starts, a beat per interval, and `settled` with the exact `elapsedMs`. The
+  opener is the only evidence a call is executing rather than queued
+  (`tool-input-*` is written when the model asks, before admission). Time a call
+  from its own series as `emittedAt - elapsedMs`; stop on `settled`.
+- The browser message reducer keeps one `data-novo-heartbeat` part per wait,
+  replaced in place, so concurrent tool calls can be timed independently from
+  `run.messages`. The run-level `heartbeat` is unchanged.
+- No wire-contract or stream-schema revision.
+
+## 0.5.0-alpha.21 - 2026-08-17
+
+- `authorization_incomplete` leaves `NovoErrorCode`; it is a `github_error`
+  value on the return to `returnUrl`. Wire contract revised; no stream-schema
+  change.
+- An organization owner's approval no longer binds an installation on its own:
+  once the owner approves, call `authorize({ connectionId })` again and complete
+  the selection as for a new connect.
+
 ## 0.5.0-alpha.20 - 2026-08-17
 
 - **Finish a GitHub connect in your own product.** The install callback binds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novoagents",
-  "version": "0.5.0-alpha.21",
+  "version": "0.5.0-alpha.22",
   "description": "Thin TypeScript SDK for the Novo Agents hosted API.",
   "license": "UNLICENSED",
   "type": "module",