ask-agent 0.38.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3486ed15f739d216a4b0dd46e8efdb29cc6cc7689a70ea4a2a6ef5477444037
-  data.tar.gz: 628f14e1905695cf814eb3ff49012f924d30ce13c92c25ef425ec695dc37502f
+  metadata.gz: 969e484bfb85499a953c458a677564c9e0419066dcb931d12f451d0297b1c355
+  data.tar.gz: 3f13c4c60d09bfe2918f2bd974cb90c82f06224f492575e52a0e8f8aea1ebac4
 SHA512:
-  metadata.gz: 7cd3f07a7dbcaa19379815eb1999f225bef3baa938ab34e018c0d1c0d755edbd5e78ba67881f65098e4b3a59b2f6696e75e1a6bfa2bba3ba17c9cb151918c9ae
-  data.tar.gz: 8644f8522aa5ea4719bb6e02d6dc19ce85d66f2e5e53765da02fcb8a002c67540f60ce31f787abb091a4e76b80a83fdb82d538b2866506385fa8c66e94f54d4a
+  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/chat.rb

@@ -53,8 +53,9 @@ module Ask
         @prompt_caching = prompt_caching.nil? ? config.prompt_caching : prompt_caching
       end
 
-      def ask(message = nil, &block)
-        @messages << Ask::Message.new(role: :user, content: message.to_s) if message
+      def ask(message = nil, attachments: nil, &block)
+        validate_attachment_modalities!(attachments)
+        @messages << Ask::Message.new(role: :user, content: merge_attachments(message, attachments)) if message || attachments
 
         stream = block_given?
         tool_defs = @tools.map { |t| Ask::ToolDef.from_tool(t) }
@@ -79,10 +80,11 @@ module Ask
         response_msg
       end
 
-      def add_message(role:, content: nil, tool_call_id: nil, tool_calls: nil)
+      def add_message(role:, content: nil, tool_call_id: nil, tool_calls: nil, attachments: nil)
+        validate_attachment_modalities!(attachments) if role == :user
         @messages << Ask::Message.new(
           role: role,
-          content: content,
+          content: merge_attachments(content, attachments),
           tool_call_id: tool_call_id,
           tool_calls: tool_calls
         )
@@ -112,6 +114,42 @@ module Ask
 
       MAX_CHAT_RETRIES = 3
 
+      # Merge attachments into message content as content blocks: a plain
+      # string becomes a Text block followed by the attachment blocks;
+      # Array content has the blocks appended. Returns the content
+      # unchanged when there are no attachments.
+      def merge_attachments(content, attachments)
+        return content if attachments.nil? || attachments.empty?
+
+        blocks = content.is_a?(Array) ? content.dup : (content ? [Ask::Content::Text.new(content.to_s)] : [])
+        Ask::Attachment.wrap_all(attachments).each do |item|
+          blocks << (item.is_a?(Ask::Attachment) ? item.to_content : item)
+        end
+        blocks
+      end
+
+      # :inline attachments must be within the model's input modalities.
+      # :context attachments are plain text (a manifest line) and always
+      # supported. The check is skipped when the catalog has no modality
+      # info for the model.
+      def validate_attachment_modalities!(attachments)
+        return if attachments.nil? || attachments.empty?
+
+        inline = Ask::Attachment.wrap_all(attachments).select { |a| a.is_a?(Ask::Attachment) && a.inline? }
+        return if inline.empty?
+
+        modalities = @model_info.respond_to?(:modalities) ? @model_info.modalities : nil
+        supported = modalities.is_a?(Hash) ? Array(modalities[:input] || modalities["input"]) : []
+        return if supported.empty? || supported.include?("*")
+
+        unsupported = inline.reject { |a| supported.include?(a.type.to_s) }
+        return if unsupported.empty?
+
+        raise Ask::Agent::UnsupportedAttachmentError,
+          "Model #{@model_id} cannot receive #{unsupported.map(&:type).uniq.join(', ')} attachments " \
+          "(supported input modalities: #{supported.join(', ')})"
+      end
+
       def provider
         @test_provider || @provider ||= build_provider
       end

data/lib/ask/agent/loop.rb

@@ -17,12 +17,12 @@ module Ask
       @max_consecutive_tool_turns = max_consecutive_tool_turns
       end
 
-      def run_turn(chat:, message:, tools:, tool_executor:, compactor:, hooks:, event_emitter:, session_id: nil, persist: nil, tool_call_repair: nil, steer_source: nil)
+      def run_turn(chat:, message:, tools:, tool_executor:, compactor:, hooks:, event_emitter:, session_id: nil, persist: nil, tool_call_repair: nil, steer_source: nil, attachments: nil)
         raise MaxTurnsExceeded if @turn_count >= @max_turns
 
         event_emitter.emit(Events::TurnStart.new)
 
-        response = chat.ask(message) do |chunk|
+        response = chat.ask(message, attachments: attachments) do |chunk|
           if chunk.content.to_s.strip.length > 0
             event_emitter.emit(Events::TextDelta.new(content: chunk.content))
           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)
@@ -196,7 +212,7 @@ module Ask
       #   (only when the +artifacts:+ option is enabled)
       attr_reader :artifact_store
 
-      def run(message, tools: nil, reset: true)
+      def run(message, tools: nil, reset: true, attachments: nil)
         raise "Session deleted" if @deleted
         raise "Session already running" if @running
 
@@ -230,6 +246,7 @@ module Ask
 	          response = @loop.run_turn(
 	            chat: @chat,
 	            message: message,
+	            attachments: attachments,
 	            tools: active_tools,
 	            tool_executor: @tool_executor,
 	            compactor: @compactor,
@@ -443,7 +460,7 @@ module Ask
         data[:messages].each do |msg|
           session.chat.add_message(
             role: msg[:role].to_sym,
-            content: msg[:content],
+            content: deserialize_content(msg[:content]),
             tool_call_id: msg[:tool_call_id]
           )
         end
@@ -662,8 +679,11 @@ end
       # @param message [String]
       # @param expected_turn_id [Integer, nil] the turn id the caller
       #   believes is current; nil skips the check
+      # @param attachments [Array<Ask::Attachment>, nil] files to attach
+      #   (applied when the session is idle; queued steers keep the
+      #   message text only — the loop resolves queued messages as text)
       # @return [Hash] {status: :stale|:queued|:steered, turn_id: Integer}
-      def steer(message, expected_turn_id: nil)
+      def steer(message, expected_turn_id: nil, attachments: nil)
         @steer_mutex.synchronize do
           if expected_turn_id && expected_turn_id != @turn_id
             return { status: :stale, turn_id: @turn_id }
@@ -673,7 +693,7 @@ end
             return { status: :queued, turn_id: @turn_id }
           end
         end
-        @chat.add_message(role: :user, content: message.to_s)
+        @chat.add_message(role: :user, content: message.to_s, attachments: attachments)
         { status: :steered, turn_id: @turn_id }
       end
 
@@ -685,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))
@@ -714,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,
@@ -802,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],
@@ -959,7 +1012,7 @@ end
         data[:messages].each do |msg|
           target.chat.add_message(
             role: msg[:role].to_sym,
-            content: msg[:content],
+            content: self.class.deserialize_content(msg[:content]),
             tool_call_id: msg[:tool_call_id]
           )
         end
@@ -977,13 +1030,26 @@ end
         @tools.reject { |t| t.is_a?(Ask::Skills::LoadSkillTool) }
       end
 
+      # Persist content blocks as their +to_h+ hashes so attachments
+      # survive save/load; plain messages stay strings.
+      def self.serialize_content(message)
+        message.content_blocks ? message.content_blocks.map(&:to_h) : message.content.to_s
+      end
+
+      # Rebuild message content from a persisted value: block hashes are
+      # reconstructed via Ask::Content.from_h (deep_symbolize_keys may have
+      # symbol keys — from_h normalizes).
+      def self.deserialize_content(content)
+        content.is_a?(Array) ? content.map { |block| Ask::Content.from_h(block) } : content
+      end
+
       def persist!
         payload = {
           id: @id,
           messages: @chat.messages.map { |m|
             {
               role: m.role,
-              content: m.content.to_s,
+              content: self.class.serialize_content(m),
               tool_call_id: m.tool_call_id,
               created_at: Time.now.iso8601
             }

data/lib/ask/agent/version.rb

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

data/lib/ask/agent.rb

@@ -18,6 +18,7 @@ module Ask
     class ToolExecutionError < Error; end
     class CompactionFailed < Error; end
     class SessionNotPersisted < Error; end
+    class UnsupportedAttachmentError < Error; end
 
     class UnknownAgent < Error; end
 

metadata

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