nexo_ai 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c12fe51de0643c44b5ede5f140d45a2c2c50b15b8f357ad0e40132bcd40034c
-  data.tar.gz: 6c98b8a0adab754ba7ea290ca2227df8f464f9a71407ad4956b6a985b5a40346
+  metadata.gz: 2a372c4ac5c253a76cbf930d99b134bbdc62c596dc8bde4414da26f08c99ad39
+  data.tar.gz: 8329003fd163b8b4131f4608b18ecb5604717b7dd6995699328216cb22143320
 SHA512:
-  metadata.gz: 221c754bcd1d4d46bf8550c5411c95e194840b5c9de42dbf66a4035a7b5d95bdccb2fb8c5a5ade8eccf88e238e763cb59b9e97d2b40d7d92fc9aee273dfe8376
-  data.tar.gz: 337b96d65dcbfcb2d879ed2e6dc62867d1a27a768f0693e007db8a0f562de0a6e5d3d129f0092d804eb531cbac0b375b7b97731016e1551cd9d1c164bae94e05
+  metadata.gz: 3e3de8747793d6c7b052d9272f6e23345e33d0749e66cd17a4247429eec1999f1329830c1c21841ac399bc04743f2d6595126496d8a24d340b537ad5ee4de026
+  data.tar.gz: 271699e28b6c236f618250b06f75ed8c4fc5d0dec269d24d0f4bac145366e1cedc0f6fee37926117b9fbf2446a8d4d7b54054f2c73562f3d6a1bfd6ae41e21d5

data/CHANGELOG.md

@@ -1,5 +1,56 @@
 ## [Unreleased]
 
+## [0.11.0] - 2026-08-20
+
+An agent's tool schema now tells the truth about what it may do.
+
+### Changed
+
+- **An agent no longer advertises a tool its permission mode can never authorize.**
+  Tool attach was gated on the sandbox (`Sandbox#supports?`) but not on the gate, so a
+  `:read_only` agent — the default — put `WriteFile` and `Shell` in its schema on every
+  turn even though `#authorize!` was guaranteed to deny them. The same held for `Fetch`
+  and `WebSearch`, which were gated on `fetch_allow` / `search_backend` being declared
+  but not on the capability being permitted. Models do try these tools, and each attempt
+  costs a full round trip.
+
+  `Agent#chat`, `#apply_fetch` and `#apply_search` now also consult
+  `Permissions#never_allows?`. Only `:read_only` is decidable ahead of time; `:auto`,
+  `:ask` and `:approve` decide per call and still attach — `:approve` in particular must
+  reach the gate so it can raise `ApprovalRequired` and suspend the run.
+
+  This is a cost and description-accuracy measure, **not** a security change:
+  `#authorize!` remains the boundary and still denies at call time.
+
+  **Upgrading:** an agent that is supposed to write, shell out, fetch or search needs the
+  capability in `allow:` (or a non-`:read_only` mode). If it does not have it today the
+  tool was already failing on every call — the tool now disappears from the schema instead
+  of erroring. Note that `fetch_allow` scopes hosts and `search_backend` names a backend;
+  neither is a capability grant.
+
+### Added
+
+- `Nexo::Permissions#never_allows?(capability)` — true when a capability can never be
+  authorized for this gate, for any call. Derived from the new `Permissions::PRIVILEGED`
+  constant, which `#authorize!` also reads, so the predicate cannot drift from the gate.
+
+## [0.10.0] - 2026-08-20
+
+Durable workflows without a database.
+
+### Added
+
+- `Nexo.config.run_store` — set a store instance and it wins over the automatic
+  choice (ActiveRecord under Rails, in-memory otherwise).
+- `Nexo::RunStore::Disk` — a file-backed store, one JSON document per run under a
+  directory, written atomically (temp file + rename). This is what makes `checkpoint`,
+  `suspend!`/`resume` and a run's recorded artifacts available to a host with no
+  database: all of them read state back from the store, and the in-memory one dies
+  with the process. `Disk::Run` subclasses `Memory::Run`, so the run shape and every
+  read helper are shared and host code behaves identically on either store. `#all`
+  lists the directory newest-first. `claim_for_resume!` re-reads from disk so a stale
+  copy cannot win a claim; it is atomic within a process, not across machines.
+
 ## [0.9.0] - 2026-08-20
 
 Skills and sandboxes learn to talk about the environment, and an agent's output finally

data/docs/permissions.md

@@ -8,7 +8,7 @@ and the agent loop continues — it does not raise. A path that escapes the work
 
 |                          | `:read` | `:glob` | `:write`            | `:shell`                          | `:fetch`   | `:search`  |
 | ------------------------ | ------- | ------- | ------------------- | --------------------------------- | ---------- | ---------- |
-| `:read_only` (default)   | ✅      | ✅      | ❌ `{error}`        | ❌ `{error}`                      | ❌ `{error}` | ❌ `{error}` |
+| `:read_only` (default)   | ✅      | ✅      | ❌ not attached ‡   | ❌ not attached ‡                 | ❌ not attached ‡ | ❌ not attached ‡ |
 | `:auto`                  | ✅      | ✅      | ✅                  | ✅                                | ✅         | ✅         |
 | `:ask`                   | ✅      | ✅      | per `on_ask`        | per `on_ask`                      | per `on_ask` | per `on_ask` |
 | `:approve`               | ✅      | ✅      | per `decision`      | per `decision`                    | per `decision` | per `decision` |
@@ -18,7 +18,22 @@ and the agent loop continues — it does not raise. A path that escapes the work
 
 `:read`/`:glob` are auto-allowed under **every** mode (they sit in the default
 `allow` list), so `:ask`/`:approve` never prompt for them — only
-`:write`/`:shell`/`:fetch`/`:search` reach the gate. **†** `:fetch` and `:search`
+`:write`/`:shell`/`:fetch`/`:search` reach the gate.
+
+**‡** Under `:read_only` these four capabilities can *never* be authorized, so their tools are
+not attached at all — the model never sees `WriteFile`, `Shell`, `Fetch` or `WebSearch` in its
+schema. Anything named in `allow:` is exempt and attaches normally, and `:auto`/`:ask`/`:approve`
+always attach because they decide per call. Leaving a guaranteed failure in the schema is not
+free: a model that reads the schema tries the tool, and each attempt costs a full round trip.
+`Permissions#never_allows?` is the predicate, and it is derived from the same `PRIVILEGED` list
+`#authorize!` uses so the two cannot disagree. This is a cost and description-accuracy measure,
+**not** a security boundary — `#authorize!` is still the gate and still denies at call time.
+
+Note that declaring `fetch_allow` or a `search_backend` is *not* a capability grant: `fetch_allow`
+scopes which hosts are reachable, and both still need `:fetch` / `:search` permitted before the
+tool is attached.
+
+**†** `:fetch` and `:search`
 run in the **host process** (stdlib `net/http` / a host-injected backend), so **no
 sandbox constrains them** — not even a `--network none` container. They are bounded
 only by the capability gate above plus `fetch_allow` / the injected backend.

data/docs/sandboxes.md

@@ -54,10 +54,19 @@ scope; none widens authority silently.
   instructions → sandbox instructions → skill instructions**. Provider-neutral, injected through
   the existing `with_instructions` path.
 
-- **Capability-gated tool attach (`Sandbox#supports?`).** A `:virtual` agent no longer advertises
-  a `Shell` tool it can never run — `Agent#chat` attaches `Shell` only when
-  `@sandbox.supports?(:shell)`. `Local`/`Container` support all four capabilities; `Virtual`
-  supports everything but `:shell`. `ReadFile`/`WriteFile`/`Glob` are always attached.
+- **Gated tool attach, on two axes.** An agent does not advertise a tool it could never
+  successfully call, because a guaranteed failure in the schema costs a round trip every time a
+  model tries it. `Agent#chat` attaches a tool only when **both** hold:
+
+  1. *The sandbox supports the capability* (`Sandbox#supports?`). `Local`/`Container` support all
+     four; `Virtual` supports everything but `:shell`, so a `:virtual` agent has no `Shell`.
+  2. *The permission gate does not deny it statically* (`Permissions#never_allows?`). Under
+     `:read_only`, `:write` and `:shell` can never be authorized unless listed in `allow:`, so
+     neither `WriteFile` nor `Shell` is attached. `:auto`, `:ask` and `:approve` decide per call
+     and always attach — `:approve` in particular *must* reach the gate so it can suspend the run.
+
+  `ReadFile` and `Glob` are always attached. This is a cost and description-accuracy measure, not
+  a security boundary: `Permissions#authorize!` remains the gate and still denies at call time.
 
 - **Shell output truncation (`Nexo::OutputTruncator`).** Unbounded command output (`npm install`,
   `git log`) is truncated before it reaches the model, so a single command can't blow a small

data/docs/tools.md

@@ -1,12 +1,22 @@
 # Tools
 Nexo attaches four sandbox-backed tools — `ReadFile`, `WriteFile`, `Shell`, and `Glob` — each gated by the [sandbox](sandboxes.md) and [permission](permissions.md) seams.
 
-Which tools attach depends on what the sandbox supports:
-
-- **Capability-gated tool attach (`Sandbox#supports?`).** A `:virtual` agent no longer advertises
-  a `Shell` tool it can never run — `Agent#chat` attaches `Shell` only when
-  `@sandbox.supports?(:shell)`. `Local`/`Container` support all four capabilities; `Virtual`
-  supports everything but `:shell`. `ReadFile`/`WriteFile`/`Glob` are always attached.
+Which tools attach depends on what the sandbox supports *and* on what the permission mode could
+ever allow:
+
+- **Gated tool attach, on two axes.** An agent does not advertise a tool it could never
+  successfully call, because a guaranteed failure in the schema costs a round trip every time a
+  model tries it. `Agent#chat` attaches a tool only when **both** hold:
+
+  1. *The sandbox supports the capability* (`Sandbox#supports?`). `Local`/`Container` support all
+     four; `Virtual` supports everything but `:shell`, so a `:virtual` agent has no `Shell`.
+  2. *The permission gate does not deny it statically* (`Permissions#never_allows?`). Under
+     `:read_only`, `:write` and `:shell` can never be authorized unless listed in `allow:`, so
+     neither `WriteFile` nor `Shell` is attached. `:auto`, `:ask` and `:approve` decide per call
+     and always attach — `:approve` in particular *must* reach the gate so it can suspend the run.
+
+  `ReadFile` and `Glob` are always attached. This is a cost and description-accuracy measure, not
+  a security boundary: `Permissions#authorize!` remains the gate and still denies at call time.
 
 `Shell` truncates unbounded command output before it reaches the model:
 

data/docs/workflows.md

@@ -82,6 +82,34 @@ ActiveRecord when it is available and the in-memory store otherwise. The schema
 uses portable `json` columns (SQLite and PostgreSQL alike) and a UUID string
 primary key.
 
+### Durable without a database — `RunStore::Disk`
+
+The in-memory store dies with the process, and **everything durable reads state
+back from the store**: `checkpoint`, `suspend!`/`resume`, and a run's recorded
+artifacts. So for a CLI or a script — no Rails, no database, but a process that
+ends — point the store at a directory:
+
+```ruby
+Nexo.config.run_store = Nexo::RunStore::Disk.new(dir: "~/.local/state/myapp/runs")
+```
+
+One JSON document per run, rewritten whenever the run changes, written to a temp
+file and renamed so a crash cannot leave a truncated document behind. The run shape
+and every read helper are Memory's — `Disk::Run` subclasses it — so host code
+written against one store behaves identically on the other. `#all` lists the
+directory newest-first, which is what a host wants for *"what did the last run
+produce?"*.
+
+A configured store wins over the automatic choice, including under Rails.
+
+**Scope, honestly.** Rewriting the whole document per change suits the run sizes this
+is meant for (a CLI's own history) and is wrong for a busy multi-worker queue — that
+is what the ActiveRecord backend is for. `claim_for_resume!` re-reads from disk, so a
+stale in-memory copy cannot win a claim, but it is atomic **within** a process only.
+Runs are never pruned: retention is the host's policy and `dir` is a plain directory
+it can manage. `Workflow.reconcile_interrupted!` sweeps the Memory and ActiveRecord
+stores only.
+
 ## Input staging and artifacts
 
 A run owns a **sandbox** — declared with the `sandbox` class macro (default

data/lib/nexo/agent.rb

@@ -285,14 +285,19 @@ module Nexo
       # One ReadTracker per chat, shared by ReadFile (records) and WriteFile
       # (enforces the read-before-write + stale guard) — R4.
       tracker = ReadTracker.new
-      tools = [
-        Tools::ReadFile.new(sandbox: @sandbox, permissions: @permissions, tracker: tracker),
-        Tools::WriteFile.new(sandbox: @sandbox, permissions: @permissions, tracker: tracker),
-        Tools::Glob.new(sandbox: @sandbox, permissions: @permissions)
-      ]
-      # Attach Shell only when the sandbox can actually run one (R2), so a
-      # :virtual agent stops advertising a tool it can never run.
-      if @sandbox.supports?(:shell)
+      # A sandbox tool is attached only when the agent could actually use it, on
+      # BOTH axes: the sandbox has to support the capability (R2 — a :virtual
+      # sandbox has no shell) and the gate must not deny it statically (a
+      # :read_only agent can never be authorized for :write or :shell). Otherwise
+      # a guaranteed failure sits in the tool schema on every turn and models do
+      # try it. This is the same attach-time gating apply_fetch/apply_search
+      # already apply; #authorize! stays the actual boundary either way.
+      tools = [Tools::ReadFile.new(sandbox: @sandbox, permissions: @permissions, tracker: tracker)]
+      unless @permissions.never_allows?(:write)
+        tools << Tools::WriteFile.new(sandbox: @sandbox, permissions: @permissions, tracker: tracker)
+      end
+      tools << Tools::Glob.new(sandbox: @sandbox, permissions: @permissions)
+      if @sandbox.supports?(:shell) && !@permissions.never_allows?(:shell)
         tools << Tools::Shell.new(sandbox: @sandbox, permissions: @permissions)
       end
       c.with_tools(*tools)
@@ -570,6 +575,10 @@ module Nexo
     # allow-list only scopes hosts, it is not the capability grant.
     def apply_fetch(chat)
       return if self.class.fetch_allow.empty?
+      # The allow-list scopes hosts; it is not the capability grant. A gate that
+      # can never authorize :fetch gets no tool rather than a guaranteed failure
+      # in its schema (see Permissions#never_allows?).
+      return if @permissions.never_allows?(:fetch)
 
       chat.with_tools(
         Tools::Fetch.new(sandbox: @sandbox, permissions: @permissions, allow_hosts: self.class.fetch_allow)
@@ -585,6 +594,7 @@ module Nexo
     # through Permissions#authorize! at call time.
     def apply_search(chat)
       backend = self.class.search_backend or return
+      return if @permissions.never_allows?(:search)
 
       chat.with_tools(
         Tools::WebSearch.new(sandbox: @sandbox, permissions: @permissions, backend: backend)

data/lib/nexo/configuration.rb

@@ -57,6 +57,14 @@ module Nexo
     # this only gates the opt-in Turbo mirror.
     attr_accessor :broadcast_events
 
+    # The run store Workflow persists runs through, default +nil+ → the automatic
+    # choice (ActiveRecord under Rails, in-memory otherwise). Set an instance to
+    # override, which is what a host outside Rails needs for anything durable:
+    # checkpoint/suspend/resume all read state back from the store, and the
+    # in-memory one dies with the process. +Nexo::RunStore::Disk.new(dir:)+ is the
+    # shipped answer for a CLI or a script.
+    attr_accessor :run_store
+
     # The ActiveJob queue Workflow.run_later enqueues onto (Spec 11 R1), default
     # +nil+ → ActiveJob's default queue. Set to a symbol (e.g. +:nexo+) to route
     # workflow jobs to a dedicated queue.
@@ -74,6 +82,7 @@ module Nexo
       @buffer_workflow_events = false
       @session_chat_model = "Chat" # ruby_llm's own default acts_as_chat host
       @broadcast_events = false # safe default: opt in to the Turbo mirror
+      @run_store = nil # nil → the automatic choice (ActiveRecord under Rails, else Memory)
       @job_queue = nil # nil → ActiveJob's default queue
     end
 

data/lib/nexo/permissions.rb

@@ -20,6 +20,11 @@ module Nexo
     # The recognized permission modes: +:auto+, +:read_only+, +:ask+, +:approve+.
     MODES = %i[auto read_only ask approve].freeze
 
+    # The capabilities +:read_only+ refuses. Named once so #authorize! and
+    # #never_allows? cannot drift apart: the whole value of the predicate is that
+    # it reports what the gate will actually do, so both must read the same list.
+    PRIVILEGED = %i[write shell fetch search].freeze
+
     # Raised when a capability is not authorized. Tools rescue this and return
     # +{ error: ... }+ so the agent loop continues.
     class Denied < StandardError; end
@@ -76,9 +81,8 @@ module Nexo
       when :auto
         true
       when :read_only
-        if %i[write shell fetch search].include?(capability)
-          raise Denied, "#{capability} denied in read_only mode"
-        end
+        raise Denied, "#{capability} denied in read_only mode" if PRIVILEGED.include?(capability)
+
         true
       when :ask
         # Scoped-ask: when ask_when says this action doesn't need a prompt,
@@ -109,6 +113,25 @@ module Nexo
       end
     end
 
+    # Whether +capability+ can NEVER be authorized by this gate, for any call.
+    #
+    # True only under +:read_only+, for a PRIVILEGED capability absent from
+    # +allow:+ — that is the one case knowable ahead of time. Every other mode
+    # decides per call and must be reported as *possible*: +:auto+ allows, +:ask+
+    # consults its hook, and +:approve+ has to reach the gate so it can raise
+    # ApprovalRequired and suspend the run.
+    #
+    # Agent#chat uses this to skip ATTACHING a tool the model could never
+    # successfully call, so a guaranteed failure stops occupying the tool schema
+    # on every turn. That makes this a cost and description-accuracy measure, not
+    # a security boundary: #authorize! remains the gate and still denies at call
+    # time whether or not the tool was advertised.
+    def never_allows?(capability)
+      return false if @allow.include?(capability)
+
+      @mode == :read_only && PRIVILEGED.include?(capability)
+    end
+
     # Authorizes an MCP tool *call* by name. A deliberate sibling of #authorize!
     # on a separate capability axis: an MCP tool runs inside the MCP server,
     # outside the sandbox, so this gates the authority to *invoke* it — a different

data/lib/nexo/run_store.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
+require "fileutils"
+
 module Nexo
   # Storage seam for Workflow runs. Two interchangeable backends expose an
   # identical create/find interface and return run objects responding to the
@@ -11,11 +14,19 @@ module Nexo
   # +push_event(event)+, +save_events!+, +push_artifact(artifact)+,
   # +save_artifacts!+, and +save_state!+ (Spec 13).
   module RunStore
-    # Selects a backend: the ActiveRecord store when both ::ActiveRecord::Base
-    # and Nexo::WorkflowRun are defined (the Rails path), otherwise the in-memory
-    # store. With no Rails loaded the AR check short-circuits, so the plain-Ruby
-    # path never references ActiveRecord.
+    # Selects a backend: +Nexo.config.run_store+ when a host set one, else the
+    # ActiveRecord store when both ::ActiveRecord::Base and Nexo::WorkflowRun are
+    # defined (the Rails path), otherwise the in-memory store. With no Rails loaded
+    # the AR check short-circuits, so the plain-Ruby path never references
+    # ActiveRecord.
+    #
+    # The configured store wins over both, which is the only way a non-Rails host
+    # gets durability: everything that survives a process — checkpoint, suspend,
+    # resume, a run's recorded artifacts — is read back from the store, and Memory
+    # dies with the process. See Disk.
     def self.default
+      return Nexo.config.run_store if Nexo.config.run_store
+
       if defined?(::ActiveRecord::Base) && defined?(Nexo::WorkflowRun)
         ActiveRecord.new
       else
@@ -158,5 +169,137 @@ module Nexo
           .update_all(status: "running") == 1
       end
     end
+
+    # File-backed backend for a host with no database: one JSON document per run
+    # under +dir+, rewritten whenever the run changes. This is what makes durability
+    # available outside Rails — checkpoint, suspend/resume and a run's recorded
+    # artifacts all read state back from the store, and Memory dies with the process.
+    #
+    #   Nexo.config.run_store = Nexo::RunStore::Disk.new(dir: "~/.local/state/myapp/runs")
+    #
+    # The Run is Memory's, subclassed: the shape and every read helper are shared, so
+    # a host written against one store behaves identically on the other. Only the
+    # +save_*+ hooks differ — they write the document. +push_event+/+push_artifact+
+    # deliberately do NOT, because Workflow always calls the matching +save_*+ right
+    # after, and persisting twice would double the writes for nothing.
+    #
+    # Scope, honestly: rewriting the whole document per change is fine for the run
+    # sizes this is meant for (a CLI's own history) and wrong for a busy multi-worker
+    # queue — that is what the ActiveRecord backend is for. +claim_for_resume!+ is
+    # atomic within a process but NOT across processes; two machines resuming the
+    # same run concurrently is out of scope. Runs are never pruned here: retention is
+    # the host's policy, and +dir+ is a plain directory it can manage.
+    class Disk
+      # A Memory::Run that writes itself to +path+ whenever Workflow saves it.
+      class Run < Memory::Run
+        # Absolute path of this run's JSON document. Assigned by the store.
+        attr_accessor :path
+
+        # The three save hooks Workflow calls after mutating a run. Memory's are
+        # no-ops because the Struct already holds everything; here they are the
+        # whole point.
+        def save_events! = persist!
+
+        # Writes the run after Workflow appended an artifact.
+        def save_artifacts! = persist!
+
+        # Writes the run after Workflow stored checkpoint/suspend state.
+        def save_state! = persist!
+
+        # Assigns attributes (Memory's behaviour) and writes the run.
+        def update!(attrs)
+          super
+          persist!
+        end
+
+        # Writes the document atomically — a temp file in the same directory, then
+        # a rename — so a crash mid-write cannot leave a truncated run behind.
+        def persist!
+          return if path.nil?
+
+          tmp = "#{path}.#{Process.pid}.tmp"
+          ::File.write(tmp, JSON.generate(to_h.except(:path)))
+          ::File.rename(tmp, path)
+        end
+      end
+
+      # Serializes writes within the process, mirroring Memory's store-wide lock.
+      MUTEX = Mutex.new
+
+      # +dir+ is created on demand; +~+ is expanded.
+      def initialize(dir:)
+        @dir = ::File.expand_path(dir)
+      end
+
+      # The directory runs are written to.
+      attr_reader :dir
+
+      # Builds a fresh +"pending"+ Run, writes it, and returns it.
+      def create(workflow_class:, payload:)
+        run = Run.new(
+          id: Nexo.generate_run_id, workflow_class: workflow_class, status: "pending",
+          payload: payload, result: nil, error: nil, events: [], artifacts: [], state: {}
+        )
+        ::FileUtils.mkdir_p(@dir)
+        run.path = path_for(run.id)
+        run.persist!
+        run
+      end
+
+      # Reads a run back by id. A miss raises KeyError, matching Memory.
+      def find(id)
+        path = path_for(id)
+        raise KeyError, "run not found: #{id}" unless ::File.exist?(path)
+
+        hydrate(JSON.parse(::File.read(path)), path)
+      end
+
+      # Every run in the directory, newest-written first. Not part of the store
+      # contract Workflow calls — it is here because a host with a run directory
+      # inevitably wants to list it ("what did the last run produce?").
+      def all
+        return [] unless ::File.directory?(@dir)
+
+        Dir.glob(::File.join(@dir, "*.json"))
+          .sort_by { |p| -::File.mtime(p).to_f }
+          .filter_map do |p|
+            hydrate(JSON.parse(::File.read(p)), p)
+          rescue JSON::ParserError, SystemCallError
+            # A half-written or hand-edited document must not break the listing.
+            nil
+          end
+      end
+
+      # Atomically claims a +"suspended"+ run for resume, re-reading from disk so a
+      # stale in-memory copy cannot win. Within one process only — see the class
+      # note.
+      def claim_for_resume!(run)
+        MUTEX.synchronize do
+          current = find(run.id)
+          return false unless current.status == "suspended"
+
+          run.status = "running"
+          run.path ||= path_for(run.id)
+          run.persist!
+          true
+        end
+      end
+
+      private
+
+      def path_for(id) = ::File.join(@dir, "#{id}.json")
+
+      # Rebuilds a Run from its document. Missing members read as nil/empty rather
+      # than raising, so a document written by an older version still loads.
+      def hydrate(data, path)
+        run = Run.new(
+          id: data["id"], workflow_class: data["workflow_class"], status: data["status"],
+          payload: data["payload"], result: data["result"], error: data["error"],
+          events: data["events"] || [], artifacts: data["artifacts"] || [], state: data["state"] || {}
+        )
+        run.path = path
+        run
+      end
+    end
   end
 end

data/lib/nexo/version.rb

@@ -2,5 +2,5 @@
 
 module Nexo
   # The gem version (also used as +spec.version+ in the gemspec).
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexo_ai
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Mario Alberto Chávez