pi-agent-rb 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14badc81403e563a04b5280ad81fb0205d16c5ff0e413c8f80025a1a57b559d9
-  data.tar.gz: da9584bec2e0e637f4ca59162ce809a27168b1551d81236afdb4324b003eb255
+  metadata.gz: 764c10abd215cb94244b349a446dd3743637196556fe3b302abf0c221c78d554
+  data.tar.gz: 19cc0cc64de81a17d120dceffe88ad862c959c210d791400b1883e160648a0ea
 SHA512:
-  metadata.gz: ad277fa02847fffc564c066646fdadaa539e8781897aa81d93d15f666593ee3eb62ee9285034fbc28678739ec4f8054adbf285aeb8dc0a2374cf609d3343568b
-  data.tar.gz: 5d72e811dfd4317954296f288f467b5c74ff81fc2a736b1661c0f1d1ee0beacac11615acbdba2c5892b65ae0d46be0982acae73e28c2fef57ec078cb04e66d9f
+  metadata.gz: 22022aa55d47d49cd2d9b547a2ee846e590dd4bbe3133a577b579662b806d560a99a852f0ee9667c5bdd9138cd32c6292f2d217cedf8e1d2acd1a76fd77ffbf3
+  data.tar.gz: aaa78bfe30ee3e2b9db5aab67b0eba26bbd6c8e62a3d3626aff496a0c345815fde43fe001894bccfbec01497fc8586244140a7f597d22cb73d825f034414e441

data/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.10] - 2026-06-25
+
+### Changed
+- Bumped pinned upstream `pi-coding-agent` version to `0.80.2` (rolls up
+  0.80.0–0.80.2: the old global `@earendil-works/pi-ai` API moved to the
+  `@earendil-works/pi-ai/compat` entrypoint and the selective `/base`
+  provider entrypoints were removed; plus provider/auth resolution fixes
+  (Bedrock, Cloudflare, Fireworks, OpenAI Responses/Codex), session-name
+  newline normalization, and a `Ctrl+J` newline keybinding). These are
+  SDK/library-level changes; no changes to the RPC protocol surface or the
+  `--approve`/`--no-approve` flags this gem drives.
+
+### Added
+- `Session#follow_up` now accepts a block to drain the agent cycle the queued
+  message triggers, mirroring `prompt`'s block contract. It is race-free —
+  the event subscription is established before the message is sent, so none
+  of the cycle's events are missed.
+- `Session#events`: a lower-level, prompt-less drain of the agent event
+  stream, for callers that subscribe before the cycle starts (e.g. from a
+  thread). Mirrors `prompt`'s block/Enumerator contract. (The class docstring
+  already referenced this method; it now exists.)
+
 ## [0.1.9] - 2026-06-22
 
 ### Changed

data/README.md

@@ -14,7 +14,7 @@ building interactive agent UIs (web, TUI) on top of pi.
 
 - Ruby 3.3+
 - `pi` on `PATH` (install via `npm i -g @earendil-works/pi-coding-agent`)
-- This gem is pinned against pi `0.79.10`; other versions may work but are not verified.
+- This gem is pinned against pi `0.80.2`; other versions may work but are not verified.
 
 ## Installation
 
@@ -69,7 +69,7 @@ end
 
 Other session methods:
 
-- Prompting: `steer`, `follow_up`, `abort`
+- Prompting: `steer`, `follow_up`, `events`, `abort`
 - Model: `set_model`, `cycle_model`, `available_models`, `set_thinking`
 - State: `get_state`, `messages`, `last_assistant_text`, `session_stats`
 - Context: `compact`
@@ -79,6 +79,26 @@ Other session methods:
 `set_model` accepts either `set_model("anthropic/claude-sonnet-4-5")` or
 `set_model("anthropic", "claude-sonnet-4-5")`.
 
+A `prompt` streams one agent cycle (`agent_start`..`agent_end`). A message
+queued with `follow_up` runs in a *later* cycle; pass a block to `follow_up`
+to drain that cycle. Like `prompt`, it yields each `Event` until `agent_end`:
+
+```ruby
+PiAgent.session do |session|
+  session.prompt("Draft a haiku") { |e| print e.delta if e.type == :message_update }
+  session.follow_up("Now translate it to French") { |e| print e.delta if e.type == :message_update }
+end
+```
+
+The block form is race-free: `follow_up` subscribes to the event stream
+*before* sending the message, so none of the cycle's events are missed.
+
+`events` is a lower-level, prompt-less drain of the same stream. Because it
+subscribes lazily when iteration begins, it only works when you subscribe
+*before* the cycle starts — e.g. begin iterating it from a thread, then
+trigger the cycle. For the common follow-up case, prefer the block form
+above.
+
 ### Images
 
 `prompt`, `steer`, and `follow_up` accept an `images:` array. Entries

data/lib/pi_agent/session.rb

@@ -14,9 +14,11 @@ module PiAgent
   # create/select step — the Session *is* the running pi process.
   #
   # v1 limitation: `prompt` streams one agent cycle (agent_start..agent_end).
-  # Messages queued mid-flight via `follow_up`/`steer` run in subsequent
-  # cycles; consume those by calling `prompt`-less `events` or another
-  # `prompt`. Bidirectional extension UI is not yet surfaced here.
+  # A message queued with `follow_up` runs in a later cycle; pass a block to
+  # `follow_up` to drain that cycle race-free (it subscribes before sending).
+  # `events` is a prompt-less drain of the same stream for when you have
+  # already subscribed before the cycle starts. Bidirectional extension UI
+  # is not yet surfaced here.
   class Session
     # Max time to wait for the next event before assuming the agent stalled.
     DEFAULT_EVENT_TIMEOUT = 300
@@ -44,6 +46,26 @@ module PiAgent
       self
     end
 
+    # Drain the event stream without submitting a new prompt. With a block,
+    # yields each Event until the cycle finishes (agent_end) and returns
+    # self; without a block, returns an Enumerator of Events.
+    #
+    # The subscription is established lazily, when iteration begins — so any
+    # cycle triggered *before* you call `events` may have already emitted
+    # events that are then missed. To drain a `follow_up` cycle race-free,
+    # pass a block to `follow_up` instead. Use `events` only when you
+    # subscribe before the cycle starts (e.g. from a thread that begins
+    # iterating, then trigger the cycle). With nothing queued, it blocks
+    # for `event_timeout` (300s default).
+    def events(event_timeout: DEFAULT_EVENT_TIMEOUT, &block)
+      stream = subscribed_stream(event_timeout: event_timeout)
+
+      return stream unless block
+
+      stream.each(&block)
+      self
+    end
+
     # Queue a steering message while the agent is running. Delivered after
     # the current assistant turn finishes its tool calls, before the next
     # LLM call. Fire-and-forget; raises on rejection.
@@ -53,8 +75,21 @@ module PiAgent
     end
 
     # Queue a follow-up message, delivered only after the agent stops.
-    def follow_up(message, images: nil)
-      @client.request("follow_up", message_params(message, images)).value!(timeout: DEFAULT_ACK_TIMEOUT)
+    #
+    # Without a block this is fire-and-forget: it queues the message and
+    # returns self. With a block it drains the resulting agent cycle
+    # race-free — the subscription is established *before* the message is
+    # sent, so no events are missed — yielding each Event until agent_end
+    # and returning self. Prefer the block form to consume a follow-up;
+    # the standalone `events` drain only works if you subscribe first.
+    def follow_up(message, images: nil, event_timeout: DEFAULT_EVENT_TIMEOUT, &block)
+      params = message_params(message, images)
+      unless block
+        @client.request("follow_up", params).value!(timeout: DEFAULT_ACK_TIMEOUT)
+        return self
+      end
+
+      event_stream("follow_up", params, event_timeout: event_timeout).each(&block)
       self
     end
 
@@ -207,14 +242,23 @@ module PiAgent
     end
 
     # Subscribe, send the command, then yield Events from the notification
-    # stream until a terminal event. The subscription is scoped to one
-    # iteration of the returned Enumerator so cleanup is deterministic.
+    # stream until a terminal event.
     def event_stream(type, params, event_timeout:)
+      subscribed_stream(event_timeout: event_timeout) do
+        @client.request(type, params).value!(timeout: DEFAULT_ACK_TIMEOUT)
+      end
+    end
+
+    # Subscribe, run `before_pump` (e.g. send a command) once the
+    # subscription is live so no events are missed in the gap, then yield
+    # Events until a terminal event. The subscription is scoped to one
+    # iteration of the returned Enumerator so cleanup is deterministic.
+    def subscribed_stream(event_timeout:, &before_pump)
       Enumerator.new do |yielder|
         queue = Queue.new
         handle = @client.subscribe { |msg| queue << msg }
         begin
-          @client.request(type, params).value!(timeout: DEFAULT_ACK_TIMEOUT)
+          before_pump&.call
           pump_events(queue, yielder, event_timeout)
         ensure
           @client.unsubscribe(handle)

data/lib/pi_agent/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module PiAgent
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 
   # Pinned upstream pi-coding-agent version this gem is verified against.
   # See: https://www.npmjs.com/package/@earendil-works/pi-coding-agent
-  SUPPORTED_PI_VERSION = "0.79.10"
+  SUPPORTED_PI_VERSION = "0.80.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pi-agent-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - chagel