ask-agent 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2b75f968977ca6b41df200a5dbba36cc73d799bc74e91ad3a201a3b9a2c78e7
-  data.tar.gz: 19fe24495b1f70b44a320c98b77ee8c2fdf9d83a5642e4bf58c071f8e16ec45c
+  metadata.gz: 969e484bfb85499a953c458a677564c9e0419066dcb931d12f451d0297b1c355
+  data.tar.gz: 3f13c4c60d09bfe2918f2bd974cb90c82f06224f492575e52a0e8f8aea1ebac4
 SHA512:
-  metadata.gz: 5c9057c8b69cbe470beb46d9c656bf56ea15abf1d5328a93bc1a66cbef9c8f69f77aa0cfeb9f64cce264c60278f4df0c9290e3d89b71c42816ff2755d91b3e5e
-  data.tar.gz: 6df2b868b1430e00c9f2fab030ab48b1128de64b23a29b22f9c70963b977c777e20aaf75d5da529f772998116c453763b935ca92d4495efa21bd04efe309caf4
+  metadata.gz: 3ee591ac269d606a3b8c07e1ea8dee3407174351efcf7fe45fd2972318382feac61be8175bd9110d4307fcef67bade241fd991ebb121711dae569bd831c08e60
+  data.tar.gz: debc87ce3557c9e40883078958fa2614b1c136ae7bd703512f8faa052b865586ccba4d69aab0eed9cb6e4ebc27537724d4bf95a6d5f0bcbb785b92f91861f676

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## [0.40.0] — 2026-08-10
+
+### Fixed
+
+- **Approval race: completing a queued tool call now always lands.**
+  The approval policy queues a tool call inside the executor (before_tool
+  hook), but the loop only registered the pending call *after* the executor
+  returned. An approval landing in that window found nothing to complete —
+  the call was then registered as a ghost pending entry and the turn never
+  settled. Two changes close it:
+  - `ApprovalQueue` gains an `on_submit` callback that fires **before** the
+    auto-approval drain; `Session#build_approval` (and the plan queue) wire
+    it to `register_pending_tool`, so the pending call exists the moment the
+    action is queued.
+  - `Session#register_pending_tool` skips re-registration for calls that
+    were already resolved (`action_id` check) or recently completed
+    (bounded `@recently_completed` set), so a late loop registration cannot
+    resurrect a completed call.
+
+### Added
+
+- `ApprovalQueue#on_submit` accessor and `on_submit:` initializer argument.
+
 ## [0.38.0] — 2026-08-07
 
 ### Added

data/lib/ask/agent/approval_queue.rb

@@ -55,9 +55,24 @@ module Ask
       #   auto-approval rules keyed by tool name. An action is auto-applied
       #   only when its tool is listed here with +true+ AND the action itself
       #   is marked auto_approvable.
-      def initialize(on_approve: nil, on_reject: nil, auto_approve: nil)
+      # @!attribute [rw] on_approve
+      #   Called with an {Action} when it is approved and applied. The
+      #   session wires this to execute the real tool call; can be replaced
+      #   after construction (e.g. by queue subclasses that also emit events).
+      # @!attribute [rw] on_reject
+      #   Called with an {Action} when it is rejected.
+      # @!attribute [rw] on_submit
+      #   Called with the new {Action} when it is submitted — BEFORE the
+      #   auto-approval drain runs, so subscribers can register the pending
+      #   call before it is applied. The session wires this to register the
+      #   pending tool call, closing the race where an approval lands while
+      #   the executor is still in flight.
+      attr_accessor :on_approve, :on_reject, :on_submit
+
+      def initialize(on_approve: nil, on_reject: nil, auto_approve: nil, on_submit: nil)
         @on_approve = on_approve
         @on_reject = on_reject
+        @on_submit = on_submit
         @auto_approve = auto_approve || {}
         @actions = {}
         @next_id = 1
@@ -90,6 +105,11 @@ module Ask
           action
         end
 
+        # Notify BEFORE the drain: an auto-approvable action is applied
+        # (and possibly completed) inside drain, and listeners need to
+        # observe the submission first.
+        @on_submit&.call(action)
+
         drain
         action.id
       end

data/lib/ask/agent/session.rb

@@ -6,6 +6,10 @@ require "time"
 module Ask
   module Agent
     class Session
+      # Max ids remembered as "recently completed" to guard against late
+      # loop registrations resurrecting ghost pending calls.
+      RECENTLY_COMPLETED_MAX = 200
+
       attr_reader :id, :chat, :tools, :turn_count, :created_at, :messages
       attr_reader :tool_calls_made, :total_input_tokens, :total_output_tokens, :total_cost
 
@@ -39,6 +43,7 @@ module Ask
         @deleted = false
         @abort_requested = false
         @pending_tools = {}
+        @recently_completed = []
         @pending_mutex = Mutex.new
         @followup_pending = false
         @turn_count = 0
@@ -63,7 +68,6 @@ module Ask
         @todos_enabled = !!todos
         @todo_list = TodoList.new if @todos_enabled
         @todo_list&.subscribe { |entries| emit(Events::TodoUpdated.new(todos: entries)) }
-
         # Durable memory (memory_write / memory_search tools). An instance
         # with its own namespace and state adapter; nil disables memory.
         @memory = memory
@@ -107,7 +111,19 @@ module Ask
         end
         @plan_queue = ApprovalQueue.new(
           on_approve: ->(action) { approve_plan(action) },
-          on_reject: ->(action) { reject_plan(action) }
+          on_reject: ->(action) { reject_plan(action) },
+          # Same race closure as the tool approval queue: register the
+          # pending call at submit time so plan approvals land even when
+          # the executor is still in flight.
+          on_submit: ->(action) {
+            register_pending_tool(action.tool_call_id, {
+              tool_name: action.tool_name,
+              message: action.message || "Plan awaiting approval",
+              status: "pending",
+              tool_call_id: action.tool_call_id,
+              action_id: action.id
+            })
+          }
         ) if @plan_mode
 
         @tools = resolve_tools(tools)
@@ -689,10 +705,19 @@ end
       # --- Async (pending) tools ---
 
       # Registers a pending tool call (called by the loop when a tool
-      # returned Ask::Result.pending). The background work completes later
-      # via #complete_pending_tool.
+      # returned Ask::Result.pending, or at approval-queue submit time).
+      # The background work completes later via #complete_pending_tool.
+      #
+      # A call can be resolved (approved/rejected) while the executor is
+      # still in flight; when the loop then registers the same call, the
+      # registration is skipped so no ghost pending entry is left behind.
       def register_pending_tool(tool_call_id, result)
         @pending_mutex.synchronize do
+          return if @recently_completed.include?(tool_call_id)
+          if (action_id = result[:action_id]) && @approval_queue
+            action = @approval_queue[action_id]
+            return if action && action.status != :pending
+          end
           @pending_tools[tool_call_id] = result
         end
         emit(Events::ToolPending.new(name: result[:tool_name], id: tool_call_id))
@@ -718,6 +743,12 @@ end
           pending = @pending_tools.delete(tool_call_id)
           return false unless pending
 
+          # Remember the id briefly so a late loop registration (from a
+          # completion that landed while the executor was in flight) cannot
+          # resurrect it as a ghost pending call.
+          @recently_completed << tool_call_id
+          @recently_completed.shift if @recently_completed.size > RECENTLY_COMPLETED_MAX
+
           @chat.add_message(
             role: :tool,
             content: result[:message].to_s,
@@ -806,6 +837,24 @@ end
           )
         end
 
+        # Custom queues (subclasses, event-emitting wrappers) may come
+        # without callbacks — wire the session's defaults so approvals
+        # actually execute the tool call.
+        queue.on_approve ||= ->(action) { apply_approved_action(action) }
+        queue.on_reject ||= ->(action) { reject_pending_action(action) }
+        # Register the pending tool call the moment the action is queued —
+        # before the auto-approval drain — so completions always match even
+        # when an approval lands while the executor is still in flight.
+        queue.on_submit ||= ->(action) {
+          register_pending_tool(action.tool_call_id, {
+            tool_name: action.tool_name,
+            message: action.message || "Pending approval",
+            status: "pending",
+            tool_call_id: action.tool_call_id,
+            action_id: action.id
+          })
+        }
+
         policy = Ask::Agent::Policies::ApprovalPolicy.new(
           queue: queue,
           require_approval: policy_opts[:require_approval],

data/lib/ask/agent/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Agent
-    VERSION = "0.39.0"
+    VERSION = "0.40.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-agent
 version: !ruby/object:Gem::Version
-  version: 0.39.0
+  version: 0.40.0
 platform: ruby
 authors:
 - Kaka Ruto