nexus-ai-pro 1.25.0 → 2.1.0

package/API_STABILITY.md

@@ -1,12 +1,13 @@
 # API Stability Policy
 
-This policy describes compatibility guarantees for `nexus-ai-pro`. The 1.x compatibility guarantees
-apply beginning with version 1.0.0.
+This policy describes compatibility guarantees for `nexus-ai-pro`. The 2.x guarantees apply beginning
+with version 2.0.0, as the 1.x guarantees applied from 1.0.0. The sections for the 1.x stages below
+still describe each surface; where they say "the 1.x rules", read the rules of the current major line.
 
 ## Release stages
 
-The package follows semantic versioning. Within the 1.x line, incompatible changes to stable public
-APIs require a major release. Minor releases may add backward-compatible features, and patch releases
+The package follows semantic versioning. Within a major line, incompatible changes to stable public
+APIs require the next major release. Minor releases may add backward-compatible features, and patch releases
 are intended to remain backward compatible.
 
 The following surfaces are public and covered by this policy:
@@ -40,6 +41,72 @@ Both are covered by this policy:
 Deep imports into `dist`, `dist-cjs`, or `src` are not supported. Import only from `nexus-ai-pro` or
 one of its explicit subpaths.
 
+## 2.1 stage (2.1.0)
+
+Everything 2.1 adds is stable from the start and additive: no default changes meaning.
+
+- graph durability modes, `flush()`, `maxPendingWrites`, `onError` with `NodeFailure` and
+  `RecoveredFailure`, `nodeDefaults`, `NodeTimeout`, `context.heartbeat()`, `SendOptions`,
+  `RunControl` and `RunControlLike`, and `GraphDrainedError` (`nexus-ai-pro/graph`);
+- `lintGraph()` and its finding types (`nexus-ai-pro/graph/lint`). New rules may be added in a minor
+  release; a rule's code and severity do not change within 2.x;
+- `OperationContext.previousHeartbeat` and `OperationRecord.heartbeatDetails`;
+- `AssistantRunContext.control`;
+- the graph event stream: `events()`, `resumeEvents()`, `continueEvents()`, `GraphEventStream`, its
+  event and option types, `GraphStreamOverflowError`, `context.message()` and `context.tool()`, and
+  `subgraphEvents`. New projections may be added in a minor release;
+- `TracerOptions.incremental` and `exporters`, `TraceExporter`, `traceparent` in and out, `flush()`,
+  `closeAbandonedRuns()`, `w3cTraceId()` and `w3cSpanId()` (`nexus-ai-pro/tracing`);
+- `OtlpTraceExporter` and `runToOtlpSpan()` (`nexus-ai-pro/tracing/otlp`). Attributes may be added as
+  the GenAI conventions settle; the ones listed in the tracing guide stay;
+- rollups (`nexus-ai-pro/tracing/rollups`), timed replay (`timing`, `pace`), evaluator provenance
+  (`withProvenance()`, `Experiment.evaluators` and `framework`, `LLMJudge.asEvaluator()`),
+  `createAgent({ streamTokens })`, and `graphAssistant(graph, { events })`;
+- `rateLimit.algorithm` and `burst`, `RateLimitStore.gcra()`, `RateLimitDecision`, and `gcraDecide()`;
+  `health.observationTtlMs`, `ProviderHealthStatus`, a snapshot's `status` and `stale`, and
+  `checkProviders({ staleOnly })`.
+
+The studio's `rollups` source follows the studio's experimental label.
+
+## 2.0 stage (2.0.0)
+
+2.0 removes what 1.x deprecated and promotes the surfaces that have settled.
+
+**Promoted to stable.** These follow the 2.x rules without an experimental label:
+
+- graphs, with their advanced APIs: `Send`, `Command`, breakpoints, `updateState()`, `fork()`, node
+  caching, and functional workflows (`nexus-ai-pro/graph`, `/graph/functional`, `/graph/visualize`);
+- the store (`nexus-ai-pro/store`, `/store/redis`), agents (`nexus-ai-pro/agent`), and tracing
+  (`nexus-ai-pro/tracing`);
+- evaluation (`nexus-ai-pro/evaluate`) and prompts (`nexus-ai-pro/prompts` and `/postgres/prompts`);
+- the agent server (`nexus-ai-pro/server`): its routes, `RunRecord`, `ThreadRecord`, `RunEvent`, and
+  recovery.
+
+**New in 2.0, and stable from the start:**
+
+- the operation lifecycle: the stage order, `LifecycleConfig`, `LifecycleHooks`, the
+  `OperationDescriptor`, `OperationOutcome`, and `OperationTicket` shapes, the `BudgetLedger`
+  contract, and `ProviderCallContext`. New families and stages may be added in a minor release;
+  existing ones keep their names;
+- mixed content: `AssetContent`, `ToolOutput`, and `response.assets`;
+- checkpoint schema version 2. Both checkpointers read version 1 throughout 2.x.
+
+**Still experimental in production readiness**, each following the 2.x rules all the same:
+
+- images, until recorded live conformance passes on all three backends;
+- the studio package;
+- deployments, tenant limits, and the server's worker queue (1.24);
+- the context hub, insights, and the studio's accounts (1.23);
+- the loaders, the vector stores added in 1.20 and 1.22, the retrievers, and the MCP registry;
+- the SQLite adapters (1.21).
+
+**Root import.** The root exports the core client, its config builders, its types, the errors it
+throws, the lifecycle, and `tool()` and `toolOutput()`. Adding anything else to the root waits for a
+major release, and a check in CI fails when the root grows.
+
+**Dependencies.** The package has no required dependency. `zod`, `ajv`, `ajv-formats`, and
+`@types/node` are optional peers; making any of them required again would need a major release.
+
 ## Capability negotiation stage
 
 `negotiateCompletionRequest()`, `NexusCapabilityError`, `CapabilityPolicy`, `CapabilityWarning`, and

package/CHANGELOG.md

@@ -4,6 +4,245 @@ Notable changes to this project are recorded here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+## [2.1.0] - 2026-10-04
+
+Fault-tolerant graphs and crash-safe observability. A graph now chooses when its checkpoints are
+written, recovers from a node whose retries ran out, tells a hung task from a slow one, and stops
+cleanly when its worker has to go. Traces survive the process that wrote them and reach any
+OpenTelemetry backend, every consumer of a run reads one event stream, and dashboards read hourly
+totals instead of every trace. Nothing changes until it is opted into: the defaults keep their 2.0
+meaning.
+
+Two pieces planned for 2.3 come early: a rate limiter with no window edge to burst across, and
+provider health that expires.
+
+### Added
+
+- **Durability modes.** `compile({ durability })` takes `sync` (the default), `async`, or `exit`.
+  `async` writes checkpoints in the background, in order, while the next superstep runs, and waits
+  for them before the run returns, pauses, fails, or drains. `maxPendingWrites` (8) bounds the writes
+  in flight. `exit` writes only where the run stops. `flush()` waits for every run's writes.
+- **Recovery after retries.** A node's `onError` receives a `NodeFailure` once its retries run out
+  and returns an update or a `Command`, such as a route to a refund node. The decision is
+  checkpointed, as `recovered` on the next checkpoint, before anything it routes to runs, so a crash
+  after it resumes into the same path. `compile({ nodeDefaults })` sets retries, timeouts, and
+  `onError` for every node.
+- **Run and idle timeouts.** `timeout: { runMs, idleMs }` caps an attempt and the time between signs
+  of progress. `context.heartbeat()`, `emit()`, and `report()` refresh the idle timer.
+  `GraphNodeTimeoutError.kind` says which limit fired. A `Send` can override the timeout of the task
+  it creates, and the override is checkpointed with the task.
+- **Cooperative drain.** `RunControl`, passed as `control` to a run, stops it after its current
+  superstep with its checkpoint written, ending in `GraphDrainedError`; `continue()` resumes it
+  anywhere. The agent server drains its graph runs this way when a replica drains with a queue, so
+  they are handed off at once instead of after the drain timeout.
+- **`lintGraph()`** on the new `nexus-ai-pro/graph/lint`, and `nexus graph lint`: static cycles,
+  retried nodes that are not `idempotent` or have no timeout, deferred durability with side effects,
+  an in-process checkpointer under a deployment, unbounded concurrency, and unchecked routes. Nodes
+  can declare `idempotent: true`, and `describe()` reports durability, the checkpointer, and each
+  node's retries, timeouts, and recovery.
+- **Progress that survives a retry.** An operation's `context.heartbeat(details)` stores `details` as
+  `heartbeatDetails`, and the next attempt reads them as `context.previousHeartbeat`.
+- A `task_failed` graph event, and a semantics table in the graph guide that says what each
+  execution primitive repeats after a crash.
+- **Crash-safe traces.** `new Tracer({ incremental: true })` writes each run when it starts and when it
+  ends, so a crashed run stays in the store with every run beneath it that finished, and a live run
+  can be watched. Sampling is decided at the root's start, and an unsampled trace is still kept whole
+  when tail sampling wants it. `closeAbandonedRuns()` closes what a dead process left running, as a
+  `RunAbandoned` error. `tracer.flush()` waits for writes and exports.
+- **Traces across processes.** `handle.traceparent()` and `StartRunOptions.traceparent` carry a trace
+  through a W3C `traceparent` header: an operation's `traceContext`, a remote call, any OpenTelemetry
+  service. `w3cTraceId()` and `w3cSpanId()` give the ids every process derives alike.
+- **OpenTelemetry export**, on the new `nexus-ai-pro/tracing/otlp`. `TracerOptions.exporters` takes any
+  `TraceExporter`, and `OtlpTraceExporter` sends runs to a collector as OTLP/HTTP JSON with no SDK:
+  model calls as `chat <model>` client spans with the GenAI semantic conventions, tools, agents, and
+  graph nodes with theirs, and Nexus-only facts under `nexus.*`. `runToOtlpSpan()` is the conversion.
+- **One event stream.** `graph.events()`, `resumeEvents()`, and `continueEvents()` run a graph as
+  typed events with projections — `values`, `updates`, `messages`, `tools`, `tasks`, `checkpoints`,
+  `custom` — read together or one at a time through `messages()`, `tools()`, `values()`, and
+  `updates()`, with `result` for the outcome. Nodes stream model output with `context.message()`
+  and report tool calls with `context.tool()`. Subgraph events come through with a `namespace` when
+  asked, and `GraphRunOptions.subgraphEvents` does the same for `onEvent`.
+- **Bounded readers.** Every reader of a stream has its own buffer (`maxBuffered`, 1,000), and the run
+  waits for the slowest at each superstep. Within a step, `overflow` coalesces model chunks and state
+  snapshots (the default), drops the oldest or newest, or fails with `GraphStreamOverflowError`.
+  `streamStats()` reports the peak and what was merged or dropped.
+- **Agents stream.** `createAgent()` reports its model's output and every tool call on the stream,
+  token by token with `streamTokens` and a client with `stream()`. `traceGraph()` records the tool
+  calls as `tool` runs inside their node. `graphAssistant(graph, { events })` records chosen
+  projections on each server run.
+- **Rollups**, on the new `nexus-ai-pro/tracing/rollups`: `rollupTraceStore()` adds every finished run
+  to hourly rows per kind, model, provider, and tenant, in `MemoryRollupStore` or any `RollupStore`,
+  with latency buckets for `rollupPercentile()` and `sumRollups()` to total them. The studio's costs
+  view reads them when given `rollups`.
+- **Timed replay.** `recordingFetch({ timing: true })` keeps each chunk of a response and when it came,
+  and `replayFetch({ pace })` replays it at once, at the original pace, scaled, or released chunk by
+  chunk by a function.
+- **GCRA rate limiting.** `rateLimit.algorithm: 'gcra'` spreads calls at `maxRequests` per `windowMs`
+  with at most `burst` at once, so a burst across a window edge can no longer pass twice the limit.
+  Both stores decide it through `gcra()`; `RedisRateLimitStore` runs it as one Lua script on Redis's
+  clock. `gcraDecide()` is the arithmetic, for a store of your own.
+- **Health that expires.** `health.observationTtlMs` makes a provider with no recent calls `unknown`,
+  routed to as one never seen instead of kept down by an old failure or up by an old success.
+  Snapshots carry a `status` (`healthy`, `degraded`, `unhealthy`, `unknown`) and `stale`, and
+  `ai.checkProviders({ staleOnly: true })` refreshes the unknown ones.
+- **Evaluator provenance.** An experiment records each evaluator's position, name, the score keys it
+  produced, and what `withProvenance()` declared — version, judge model, prompt version, temperature,
+  and rubric — and the framework version that ran it. `LLMJudge.asEvaluator()` brings the judge to
+  `evaluate()`, declaring its own provenance.
+- A weekly `live-providers` workflow runs real conformance against every provider with a key in the
+  repository's secrets, DeepSeek included, and opens an issue when one breaks.
+
+### Fixed
+
+- **A manual operation heartbeat no longer strands the result.** `context.heartbeat()` wrote the
+  record behind the runner's back, so the runner's final write failed its sequence check and a
+  successful result was not saved. Heartbeats now go through the runner, one at a time.
+- `continue()` on a finished thread left it marked `running` with an empty result. It now leaves it
+  completed and returns its state.
+- A run started under a parent from another tracer, or another process, was never written: its trace
+  waited for a root that was not there. It is now written as its trace's root in this process.
+
+### Proof
+
+- A crash-injection suite kills a run before, during, and after every checkpoint write and inside
+  nodes, before and after their side effects, in `sync` and `async` mode, on the memory, operation
+  store, SQLite, Postgres, and Redis checkpointers. A fresh process always reaches the state of an
+  uninterrupted run.
+- A saga test: a charge exhausts its retries, `onError` routes to a refund, the process dies during
+  the refund, and the resumed run refunds without charging again.
+- A property test generates 40 graphs with branches, loops, `Send`, retries, and interrupts, and
+  replays each from every checkpoint of its history to the same state.
+- The graph benchmark runs 50 supersteps against an 8 ms store: `async` finishes in about half the
+  time of `sync`, in the same state, and CI fails if it stops beating it by a quarter.
+- A long agent's process dies at its fourteenth step: a second process reads every finished step from
+  the same JSONL store, and `closeAbandonedRuns()` closes the rest.
+- A server and a worker each export to a local OTLP collector, and the collector receives one trace,
+  the worker's run under the server's, with the GenAI attributes on the model call.
+- A reader a hundred times slower than a node that streams 100,000 chunks never holds more than its
+  buffer, under every overflow policy, and coalescing loses no text.
+- The studio's costs view answers over a month of a million runs, held as rollups, in under 200 ms,
+  reading the traces once.
+- In the two milliseconds around a window's edge, fixed windows pass 199 calls of a 100-call limit and
+  GCRA passes 100. A provider down on Monday and idle since is `unknown`, and routed to, on Wednesday.
+
+## [2.0.0] - 2026-10-02
+
+Consolidation. One lifecycle runs every call of every family, the root import holds the core client
+and nothing else, and the package installs with no required dependency. Everything removed here was
+deprecated in 1.x; [MIGRATING.md](./MIGRATING.md) covers each change with before-and-after code, and
+`nexus migrate` rewrites the imports.
+
+### Breaking
+
+- **The root import keeps only the core**: the client, its config builders, its types, the errors it
+  throws, the lifecycle, and the tool helpers. The 498 other names it re-exported are on their
+  subpaths; `nexus migrate` moves 1.x imports there. Importing the root costs 323 KB, down from 572 KB.
+- **`zod`, `ajv`, `ajv-formats`, and `@types/node` are optional peer dependencies.** A zod shape is
+  checked through its own `safeParse`; a JSON Schema response format loads ajv on its first check, and
+  says what to install when it is missing. A production install is 5.3 MB, the package alone, down
+  from 12.3 MB.
+- **A response's `estimatedCost` string is removed**, for the numeric `cost`. A plan's
+  `estimatedCost` object stays.
+- **Modalities say which way they flow.** `ModelCapabilities.inputModalities` and `outputModalities`
+  are required on every entry, bundled or registered; `modalities`, the `Modality` type, and the
+  `modalities` routing requirement are removed.
+- **Checkpoint schema version 2.** A checkpoint has its `version`, an `id`, its `tasks` always, and its
+  questions only in `interrupts`; `interrupt` is gone. Both checkpointers read version 1 for the whole
+  2.x line, so threads 1.x left waiting resume. A checkpointer's `get()` and `history()` return a
+  `StoredGraphCheckpoint` of either version.
+- **Options that were never read are removed**: `GoogleProviderConfig.projectId`,
+  `OllamaProviderConfig.timeout`, `MetricsConfig.prometheus`, `DensificationConfig.preserveMarkdown`,
+  `HealthConfig.latencyHalfLife`, `InjectionDetectionConfig.sensitivity`, and
+  `ToolPolicyConfig.requiresApproval`.
+- **`ImageManagerConfig` is removed**, for `ImageConfig`.
+- **`PipelineStepName` is a closed list.** A custom step is recorded as `customStep`, with its own name
+  in `PipelineTraceStep.custom`. The `auditLog` step is replaced by the lifecycle's `audit`.
+- **`ai.stream()` opens on its first read**, so authorization, rate-limit, guardrail, and budget errors
+  come out of the loop rather than from the call.
+- **What the lifecycle records changed**: metrics carry `family` and `operation` for every family, the
+  image family is labelled `image`, audit events carry `family` and `operation` and add an `error`
+  event, and `response.meta.requestId` is the operation's id.
+- **The model registry is current as of 2026-10-02.** Models their providers shut down are removed:
+  Claude 3.x and 4.0 to 4.1, `gpt-4.5-preview`, `o1-mini`, `gpt-5-codex`, Gemini 1.5 and 2.0 and the
+  shut-down 3.x previews, Groq Compound, Llama 4 Scout, and Qwen3 32B, Mistral's 2024 models, Devstral,
+  and Magistral, and DeepSeek's `deepseek-chat`, `deepseek-reasoner`, V3, and R1. Four names no
+  provider served are gone too: `claude-sonnet-5-0`, `claude-haiku-5-0`, `claude-fable-5-0`, and
+  `gemini-3.5-pro`. Cohere's `command-r` and `command-r-plus` are filed under their dated names, and
+  `mistral-medium-3-5` under `mistral-medium-2604`. Every intent alias points at a current model.
+
+### Added
+
+- **One lifecycle for every operation.** Completions, streams, embeddings, voice, telephony, images,
+  realtime sessions, graphs, agents, queued jobs, and provider batches pass through the same stages:
+  validate, authorize, input policy, resolve assets, route, reserve budget, execute, output policy,
+  persist, reconcile cost, and audit. `lifecycle` on the client configures what they share: an
+  `authorize` callback that can refuse any call, a `budget` every family draws on, and `hooks` that see
+  each call start and finish, cache hits included. `ai.lifecycle` makes graphs, agents, workflows,
+  realtime sessions, job queues, and batches operations of the client too.
+- **A shared spend budget**: `budgetLedger()` on the new `nexus-ai-pro/lifecycle` holds each call's
+  estimate before it runs and charges what it cost after, per tenant and per period, so concurrent calls
+  cannot overshoot together. It keeps totals in memory or in any tenant usage store, Redis included.
+- **`ProviderCallContext`**, handed to every provider call of every family: the request id, the abort
+  signal, the deadline, trace headers, and the idempotency key. The OpenAI and Anthropic adapters send
+  the key and the headers on. Requests take `requestId`, `tenantId`, and `idempotencyKey`.
+- **Mixed text-and-asset content.** `toolOutput()` lets a tool return text, images, and asset
+  references, sent as the tool message itself instead of base64 JSON. An `asset` content part names an
+  asset by reference, an image part can carry an asset, and a model that produces images returns them
+  on `response.assets`.
+- **Typed pipelines**: `PipelineContext` and the runner are generic over the request and response, with
+  `PipelineShapes` for another family's types.
+- **New models**: OpenAI GPT-6 Astra, GPT-6.1 Sol, GPT-6 Sol, GPT-6 Luna, GPT-5 Pro, o3-pro, and
+  GPT-5.3 Codex; Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Fable 5, Opus 5, Sonnet 5, and Sonnet 4.5;
+  Gemini 3.8, 3.7, and 3.6 Flash, 3.5 Flash-Lite, 3.1 Flash-Lite, 3 Pro Image, and 3.1 Flash Image;
+  Groq's Qwen3.8 27B and MiniMax M2.7; Mistral Medium 3.5 and Ministral 3 14B, 8B, and 3B; DeepSeek
+  Flash and V4 Pro; and Cohere Command A Plus, North Mini Code, North Small Translate, and three Tiny
+  Aya models.
+- `ModelCapabilities.sampling`, false for a model that accepts only its default temperature and top-p.
+  Negotiation drops a non-default value for it.
+- `nexus migrate` lists each model name the 2.0 registry dropped, with what to use instead.
+- Anthropic responses report thinking tokens in `usage.reasoningTokens`.
+- **`llms.txt` and `llms-full.txt`** for AI assistants and coding agents: an index of every guide with
+  the facts an assistant needs to recommend the package correctly, and the guides in one file.
+  `llms.txt` ships in the package. Both are generated from the README and the guides, and CI fails
+  when they fall behind.
+- `toCheckpoint()` and `CheckpointDraft` for building a version 2 checkpoint by hand.
+- A `cache_hits` metric, and `routingDecision.provider` and `.model` on a response.
+
+### Changed
+
+- Provider adapters, and the agent, verification, evaluation, workflow, semantic-cache, image, and
+  embedding engines, load on first use, so importing the client never loads them.
+- A context-window summary is an operation of its own, authorized, budgeted, and audited.
+- `getCall()`, `listPhoneNumbers()`, and `updatePhoneNumber()` run through the lifecycle, so they are
+  rate-limited and audited like `createCall()`.
+- `nexus migrate` lists the options and model entries 2.0 removed, and keeps a single moved name on
+  one line.
+- **Prices and limits follow the providers.** GPT-5.6, GPT-5.2 Pro, Mistral Large 3, and Mistral
+  Small 4 cost less. Gemini 3.5 Flash costs $1.50 and $9 per million tokens, not $0.10 and $0.40.
+  Claude Opus 4.5 has a 200K context and 64K output, not 1M and 128K, and Codestral a 128K context.
+  Models with an announced shutdown are `deprecated`, with the date and the replacement in their
+  notes, and an alias that resolves to one is deprecated too.
+- `toolChoice: false` now means a call cannot be forced: negotiation drops `required` or a named tool
+  and lets `auto` and `none` through.
+
+### Fixed
+
+- **Claude 4.6 onward get adaptive thinking.** The Anthropic adapter sent every model a thinking
+  budget, which Claude rejects after 4.6, so a request with `reasoning` failed on current models. It
+  now sends adaptive thinking and `output_config.effort` from 4.6 on, and turns thinking off the way
+  each model allows. It drops sampling values that Claude 4.7 and later reject, and leaves room for
+  thinking when no output limit is set.
+- **Tool calls reach providers whole.** The OpenAI chat and Responses, Anthropic, and Google adapters
+  dropped a conversation's tool calls and the ids that link results to them, so a real tool loop could
+  fail on its second turn. Each now sends both the way its API expects, images in results included.
+- **Responses are priced on the model they were routed to.** A provider that echoed a dated snapshot
+  name priced the call at nothing; Groq, Mistral, and Cohere models filed under a prefix did too.
+- `resolveModel('google/gemini-2.5-flash')` found no capabilities for a provider-prefixed name. It now
+  finds the entry filed without the prefix, when that entry belongs to the same provider.
+- Streams honour the circuit breaker, the cost budget, audit, and metrics, as completions always did.
+- A cache hit is audited and counted.
+- The upload scanner's types no longer need Node's: `content` takes text or any `Uint8Array`.
+
 ## [1.25.0] - 2026-10-01
 
 The bridge to 2.0. Everything 2.0 removes is deprecated now, every capability has a subpath of its
@@ -1255,7 +1494,9 @@ shared policy vocabulary is in place for a future release that revisits this.
 - URL fetching rejects unsafe private-network targets and limits response reads.
 - CLI and audit findings no longer disclose detected secret values.
 
-[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.25.0...HEAD
+[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.25.0...v2.0.0
 [1.25.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.24.0...v1.25.0
 [1.24.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.23.0...v1.24.0
 [1.23.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.22.0...v1.23.0