ask-coding-providers 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed62b6a25b44845e1a4e2c8c3d1b00c07e49f108a53448e7691d5f2468af76bc
-  data.tar.gz: 985d2a2d0e93157d590afa9223a4434c8f481205f026cf46db5fa4bec751e763
+  metadata.gz: b1b9421ae222addaf585ea8b26333306078843d0574a4b71a34cecaa3fc4ff79
+  data.tar.gz: 8c7d16435c702703f0f661474077389c28d4fc796aafe196bfce4ccd1f7019b2
 SHA512:
-  metadata.gz: 173a8066a3b737d8dc9ef5cb3b5e1d514fbab7a25df8a96acb91f064d25f2badecb8f8219d5658b4a04565a46f15d4c0f9c051274f68f4fc0a777d9d2d1eafa7
-  data.tar.gz: 7d3b34d1ae1c65e8b7f22eb19ef1e61dbe4b86a1fa9c97eab807decea3c2c9e0d84ac95e1d4e1fab2d4c562e8c32f500237a21f21f5f8f2b412b16680ff027cd
+  metadata.gz: 76cbfb82c26608b1d73a44673b09ab6a299a7c604e80566fa8e9555acd4c2443239d28fafafdee6e29589aa9062cef5e4c4bab465bdb103e41db66560e91b2fe
+  data.tar.gz: 4a704264075d1c25ce32bf4ae73106050c3ffd7aa52f34ed042f8e98c4132d0f150aca5fe88af3114ca4d0b8c066a83c9f545b44ca267b6abf34d7e802f5c829

data/lib/ask/coding_providers/ask_agent/adapter.rb

@@ -2,52 +2,137 @@
 
 require "securerandom"
 
+begin
+  require "ask-llm-providers"
+  require "ask/agent"
+rescue LoadError => e
+  raise "Missing dependency for AskAgent adapter: #{e.message}. Add ask-agent and ask-llm-providers to your Gemfile."
+end
+
 module Ask
   module CodingProviders
     module AskAgent
+      # Approval queue that notifies callbacks when actions are submitted or
+      # change status, so clients can stream approval state in real time.
+      #
+      # The session wires its own apply/reject/submit callbacks onto the
+      # queue (see Session#build_approval); this subclass only adds
+      # observation hooks on top, using its own listeners so the session's
+      # on_submit (pending-tool registration) is never clobbered.
+      class EmittingApprovalQueue < Ask::Agent::ApprovalQueue
+        # @param on_submit [Proc, nil] called with the new {Action} after
+        #   submission (and after the auto-approval drain)
+        # @param on_status [Proc, nil] called with an {Action} whose status
+        #   changed to :approved or :rejected
+        def initialize(on_submit: nil, on_status: nil, **kwargs)
+          @on_action_submitted = on_submit
+          @on_status = on_status
+          super(**kwargs)
+        end
+
+        def submit(tool_call_id:, tool_name:, args: {}, auto_approvable: false, message: nil)
+          id = super
+          @on_action_submitted&.call(self[id])
+          id
+        end
+
+        private
+
+        def apply(action)
+          result = super
+          @on_status&.call(action.with(status: :approved))
+          result
+        end
+
+        def reject_action(action)
+          result = super
+          @on_status&.call(action.with(status: :rejected))
+          result
+        end
+      end
+
       # Adapter that wraps Ask::Agent::Session directly (in-process).
       #
-      # No app-server, no external binary — sessions run in the same process.
-      # Perfect for deployments where running a separate process is impractical.
+      # Sessions persist across turns: each session id maps to one
+      # Ask::Agent::Session instance whose conversation history accumulates.
+      # Every agent event is translated and streamed to subscribers, including
+      # thinking deltas, tool executions, approvals, plans, and todos. When a
+      # tool queues for human approval, the turn pauses; approving or
+      # rejecting from any thread continues the turn (follow-up turns run
+      # inside ask-agent and their events reach the same subscribers).
       #
       # @example
-      #   adapter = AskAgent::Adapter.new(model: "deepseek-v4-flash", provider: "opencode_go")
+      #   adapter = AskAgent::Adapter.new(
+      #     model: "deepseek-v4-flash", provider: "opencode_go",
+      #     approval: :require, approval_required: %w[bash write edit]
+      #   )
       #   adapter.start
       #   sid = adapter.create_session("/tmp")
-      #   adapter.send_and_stream(sid, "Hello") { |ev| puts ev }
+      #   adapter.send_and_stream(sid, "Hello") { |ev| puts ev[:type] }
+      #   adapter.pending_approvals(sid) # => [{id: 1, tool_name: "bash", ...}]
+      #   adapter.approve_action(sid, 1)
       class Adapter < Ask::CodingProviders::Adapter
+        # Approval modes: :off disables the queue, :require gates
+        # approval_required tools behind human review, :auto keeps the queue
+        # (visible/inspectable) but never blocks.
+        APPROVAL_OFF = :off
+        APPROVAL_REQUIRE = :require
+        APPROVAL_AUTO = :auto
+        APPROVAL_MODES = [APPROVAL_OFF, APPROVAL_REQUIRE, APPROVAL_AUTO].freeze
+
+        # How long a turn stays settled before it is considered complete
+        # (protects against follow-up turns starting right after the queue
+        # drains).
+        SETTLE_POLL_INTERVAL = 0.05 # seconds
+        SETTLE_POLLS = 4
+
         # @param model [String] model ID (e.g. "deepseek-v4-flash")
         # @param provider [String] provider slug (e.g. "opencode_go")
         # @param tools [Array] tool instances to make available
         # @param max_turns [Integer] max conversation turns per session
-        def initialize(model:, provider:, tools: [], max_turns: 25, **session_opts)
-          # Lazy require — these gems are optional for the gem but required for this adapter
-          begin
-            require "ask-llm-providers"
-            require "ask/agent"
-          rescue LoadError => e
-            raise "Missing dependency for AskAgent adapter: #{e.message}. Add ask-agent and ask-llm-providers to your Gemfile."
-          end
-
+        # @param approval [Symbol] one of APPROVAL_MODES
+        # @param approval_required [Array<String>] tool names gated behind
+        #   human approval when approval is :require
+        # @param plan_mode [Boolean] enable plan mode (exit_plan_mode tool +
+        #   read-only gate until the plan is approved)
+        # @param todos [Boolean] enable the todo list (todo_write tool)
+        # @param session_opts [Hash] extra options passed to
+        #   Ask::Agent::Session (hooks, system_prompt, compactor, ...)
+        def initialize(model:, provider:, tools: [], max_turns: 25,
+                       approval: APPROVAL_OFF, approval_required: nil,
+                       plan_mode: false, todos: false, **session_opts)
           @model_id = model
           @provider_slug = provider
-          @tools = tools
+          @tools = Array(tools)
           @max_turns = max_turns
+          @approval = approval
+          @approval_required = Array(approval_required)
+          @plan_mode = !!plan_mode
+          @todos = !!todos
           @session_opts = session_opts
           @started = false
           @provider = nil
+          @sessions = {}
+          @mutex = Mutex.new
+          unless APPROVAL_MODES.include?(approval)
+            raise ArgumentError, "approval must be one of #{APPROVAL_MODES.inspect}, got #{approval.inspect}"
+          end
         end
 
-  def start
-    return if @started
-    klass = Ask::Provider.resolve(@provider_slug)
-    compat = klass.respond_to?(:compat_config) ? klass.compat_config : {}
-    api_key = ENV[compat[:alternate_env].to_s] || ENV[compat[:api_key_env].to_s] || ENV["#{@provider_slug.upcase}_API_KEY"]
-    @provider = klass.new(api_key: api_key)
-    @started = true
-  end
+        def start
+          return if @started
+          klass = Ask::Provider.resolve(@provider_slug)
+          compat = klass.respond_to?(:compat_config) ? klass.compat_config : {}
+          api_key = ENV[compat[:alternate_env].to_s] || ENV[compat[:api_key_env].to_s] || ENV["#{@provider_slug.upcase}_API_KEY"]
+          @provider = klass.new(api_key: api_key)
+          @started = true
+        end
 
         def stop
+          @mutex.synchronize do
+            @sessions.each_value { |entry| entry[:session]&.abort }
+            @sessions.clear
+          end
           @started = false
           @provider = nil
         end
@@ -56,73 +141,167 @@ module Ask
           @started
         end
 
-        # Create a new conversation session.
-        # The workspace_path is noted but not used by in-process agent.
+        # Create a new conversation session for a workspace.
         # Returns a session ID (UUID).
-        def create_session(workspace_path, mode: nil)
+        #
+        # @param workspace_path [String] working directory
+        # @param mode [String, nil] permission mode
+        # @param model [String, nil] model override for this session
+        def create_session(workspace_path, mode: nil, model: nil)
           ensure_started
           sid = "sess_#{SecureRandom.uuid}"
-          @sessions ||= {}
-          @sessions[sid] = { workspace: workspace_path, mode: mode, created_at: Time.now }
+          @mutex.synchronize do
+            @sessions[sid] = {
+              workspace: workspace_path,
+              mode: mode,
+              model: model || @model_id,
+              created_at: Time.now,
+              session: nil,
+              subscribers: [],
+              seq: 0,
+              turn_active: false
+            }
+          end
           sid
         end
 
         def resume_session(session_id)
           ensure_started
-          @sessions&.dig(session_id) || {}
+          entry = @sessions[session_id]
+          return {} unless entry
+          {
+            "session_id" => session_id,
+            "workspace" => entry[:workspace],
+            "model" => entry[:model],
+            "created_at" => entry[:created_at].iso8601
+          }
+        end
+
+        def list_sessions(workspace_path: nil, limit: 20)
+          ensure_started
+          @mutex.synchronize do
+            @sessions
+              .select { |_sid, e| workspace_path.nil? || e[:workspace] == workspace_path }
+              .sort_by { |sid, e| [e[:created_at], sid] }
+              .reverse
+              .first(limit)
+              .map { |sid, e| { session_id: sid, workspace: e[:workspace], created_at: e[:created_at].iso8601 } }
+          end
         end
 
         def subscribe(session_id, after_seq: 0)
           ensure_started
-          { "eventSeq" => 0 }
+          { "eventSeq" => session_entry(session_id)[:seq] }
         end
 
         def send_message(session_id, content, attachments: nil)
           ensure_started
-          # Run synchronously — returns when done
-          result = run_session(session_id, content, attachments: attachments)
+          result = nil
+          send_and_stream(session_id, content, attachments: attachments) do |ev|
+            result = ev.dig(:payload, "response") if ev[:type] == "turn.completed"
+          end
           { "response" => result }
         end
 
+        # Send a message and stream translated events to the block.
+        #
+        # Runs the session's loop synchronously; when tools queue for
+        # approval the turn pauses and this method waits (up to turn_timeout)
+        # for the queue to drain, so subscribers receive the full turn —
+        # including follow-up turns that run when approvals resolve.
+        #
+        # @yield [Hash] events with :type, :seq, :payload
         def send_and_stream(session_id, content, turn_timeout: 600.0, attachments: nil, &block)
           return enum_for(:send_and_stream, session_id, content, turn_timeout: turn_timeout, attachments: attachments) unless block
           ensure_started
 
-          # Build the ask-agent chat with our pre-configured provider
-          chat = build_chat
-          session = Ask::Agent::Session.new(
-            model: chat,
-            max_turns: @max_turns,
-            **@session_opts
-          )
+          entry = session_entry(session_id)
+          session = (entry[:session] ||= build_session(entry))
 
-          # Emit turn.started
-          block.call({ type: "turn.started", seq: 1, payload: { "sessionId" => session_id } })
+          subscription = subscribe_session(entry, &block)
+          emit(entry, { type: "turn.started", seq: next_seq(entry), payload: { "sessionId" => session_id } })
 
-          # Wire streaming events
-          session.on_event do |event|
-            case event
-            when Ask::Agent::Events::TextDelta
-              block.call({
-                type: "model.streaming", seq: 2,
-                payload: { "delta" => event.content, "sessionId" => session_id }
+          begin
+            result = run_with_approvals(entry, session, content, attachments: attachments, turn_timeout: turn_timeout)
+            if session.abort_requested?
+              emit(entry, { type: "turn.aborted", seq: next_seq(entry), payload: { "sessionId" => session_id } })
+            else
+              emit(entry, {
+                type: "turn.completed", seq: next_seq(entry),
+                payload: {
+                  "response" => (result || accumulated_text(entry)).to_s,
+                  "sessionId" => session_id,
+                  "tokenCount" => session.total_input_tokens + session.total_output_tokens
+                }
               })
             end
-          end
-
-          begin
-            result = session.run(content, attachments: attachments)
-            block.call({
-              type: "turn.completed", seq: 3,
-              payload: { "response" => result, "sessionId" => session_id,
-                         "tokenCount" => session.total_input_tokens + session.total_output_tokens }
-            })
           rescue => e
-            block.call({
-              type: "turn.failed", seq: 3,
+            emit(entry, {
+              type: "turn.failed", seq: next_seq(entry),
               payload: { "error" => { "message" => e.message }, "sessionId" => session_id }
             })
+          ensure
+            unsubscribe_session(entry, subscription)
+            entry[:turn_active] = false
           end
+          nil
+        end
+
+        # ── Approval controls ──
+
+        # Approve one queued tool action. Continues the turn (follow-up
+        # turns run in this thread and stream to active subscribers).
+        #
+        # @return [Array<Ask::Agent::ApprovalQueue::Action>]
+        def approve_action(session_id, action_id)
+          queue = approval_queue(session_id)
+          queue ? queue.approve(action_id) : []
+        end
+
+        def reject_action(session_id, action_id)
+          queue = approval_queue(session_id)
+          queue ? queue.reject(action_id) : []
+        end
+
+        # Approve all pending tool actions.
+        def approve_all(session_id)
+          queue = approval_queue(session_id)
+          queue ? queue.approve_all : []
+        end
+
+        def reject_all(session_id)
+          queue = approval_queue(session_id)
+          queue ? queue.reject_all : []
+        end
+
+        # Actions still awaiting a decision, as plain hashes.
+        def pending_approvals(session_id)
+          queue = approval_queue(session_id)
+          return [] unless queue
+          queue.pending_actions.map { |a| action_hash(a) }
+        end
+
+        # The pending plan awaiting approval (plan mode), or nil.
+        def pending_plan(session_id)
+          session = session_entry(session_id)[:session]
+          return nil unless session&.plan_queue
+          action = session.plan_queue.pending_actions.first
+          action && action_hash(action)
+        end
+
+        # Approve / reject the proposed plan (plan mode).
+        def approve_plan(session_id)
+          session_entry(session_id)[:session]&.plan_queue&.approve_all || []
+        end
+
+        def reject_plan(session_id)
+          session_entry(session_id)[:session]&.plan_queue&.reject_all || []
+        end
+
+        # Abort the current turn. The loop exits at the next checkpoint and
+        # the stream emits turn.aborted.
+        def abort(session_id)
+          session_entry(session_id)[:session]&.abort
         end
 
         def get_events(session_id, after_seq:, limit: nil)
@@ -133,30 +312,90 @@ module Ask
           # No reverse requests in basic mode
         end
 
-	  def get_workspace_state(workspace_path)
-	    # No workspace state to report
-	    {}
-	  end
+        def get_workspace_state(workspace_path)
+          # No workspace state to report
+          {}
+        end
+
+        def session_directory(session_id)
+          entry = @mutex.synchronize { @sessions[session_id] }
+          entry && entry[:workspace]
+        end
+
+        # Message history for a session, newest first. Empty for unknown or
+        # not-yet-run sessions.
+        def session_history(session_id, limit: 100)
+          entry = @mutex.synchronize { @sessions[session_id] }
+          return [] unless entry
+          session = entry[:session]
+          return [] unless session
+          session.messages.last(limit).reverse.map do |m|
+            { text: m.content.to_s, role: m.role.to_s, origin: "ask_agent" }
+          end
+        end
 
-	  # Build an AskAgent adapter from config.
-	  # Reads ASK_AGENT_MODEL, ASK_AGENT_LLM_PROVIDER, ASK_AGENT_MAX_TURNS from ENV.
-	  def self.from_config(model: nil, llm_provider: nil, max_turns: nil, **)
-	    new(
-	      model: model || ENV.fetch("ASK_AGENT_MODEL", "deepseek-v4-flash"),
-	      provider: llm_provider || ENV.fetch("ASK_AGENT_LLM_PROVIDER", "opencode_go"),
-	      max_turns: (max_turns || ENV.fetch("ASK_AGENT_MAX_TURNS", "10")).to_i
-	    )
-	  end
+        # Build an AskAgent adapter from config.
+        # Reads ASK_AGENT_MODEL, ASK_AGENT_LLM_PROVIDER, ASK_AGENT_MAX_TURNS
+        # from ENV.
+        def self.from_config(model: nil, llm_provider: nil, max_turns: nil, **)
+          new(
+            model: model || ENV.fetch("ASK_AGENT_MODEL", "deepseek-v4-flash"),
+            provider: llm_provider || ENV.fetch("ASK_AGENT_LLM_PROVIDER", "opencode_go"),
+            max_turns: (max_turns || ENV.fetch("ASK_AGENT_MAX_TURNS", "10")).to_i
+          )
+        end
 
-	  private
+        private
 
         def ensure_started
           raise "Adapter not started. Call #start first." unless @started
         end
 
-        def build_chat
+        def session_entry(session_id)
+          entry = @mutex.synchronize { @sessions[session_id] }
+          raise ArgumentError, "Unknown session: #{session_id}" unless entry
+          entry
+        end
+
+        def approval_queue(session_id)
+          session_entry(session_id)[:session]&.approval_queue
+        end
+
+        # ── Session construction ──
+
+        def build_session(entry)
+          chat = build_chat(entry[:model])
+
+          queue = EmittingApprovalQueue.new(
+            on_submit: ->(a) { emit_approval(entry, a, :pending) },
+            on_status: ->(a) { emit_approval(entry, a, a.status) }
+          )
+
+          approval_cfg =
+            case @approval
+            when APPROVAL_REQUIRE then { queue: queue, require_approval: @approval_required }
+            when APPROVAL_AUTO then { queue: queue }
+            when APPROVAL_OFF then nil
+            else
+              raise ArgumentError, "approval must be one of #{APPROVAL_MODES.inspect}, got #{@approval.inspect}"
+            end
+
+          Ask::Agent::Session.new(
+            model: chat,
+            tools: @tools,
+            max_turns: @max_turns,
+            approval: approval_cfg,
+            plan_mode: @plan_mode,
+            todos: @todos,
+            **@session_opts
+          ).tap do |session|
+            session.on_event { |event| translate_event(entry, session, event) }
+          end
+        end
+
+        def build_chat(model_id)
           chat = Ask::Agent::Chat.new(
-            model: @model_id,
+            model: model_id,
             provider: @provider_slug,
             tools: @tools
           )
@@ -165,14 +404,152 @@ module Ask
           chat
         end
 
-        def run_session(session_id, content, attachments: nil)
-          chat = build_chat
-          session = Ask::Agent::Session.new(
-            model: chat,
-            max_turns: @max_turns,
-            **@session_opts
-          )
-          session.run(content, attachments: attachments)
+        # ── Turn lifecycle ──
+
+        # Run the agent loop, then wait — up to turn_timeout — for the turn
+        # to fully settle: idle, no pending tools, and an empty approval
+        # queue. Approvals resolve from other threads; each resolution may
+        # trigger follow-up turns inside ask-agent (via
+        # complete_pending_tool), whose events stream to the same
+        # subscribers. The settle grace period absorbs the gap between the
+        # queue draining and a follow-up turn starting.
+        def run_with_approvals(entry, session, content, attachments:, turn_timeout:)
+          result = session.run(content, attachments: attachments)
+          entry[:turn_active] = true
+          deadline = monotonic + turn_timeout
+          settle_count = 0
+
+          loop do
+            return result if session.abort_requested?
+            if turn_settled?(session, entry)
+              settle_count += 1
+              return result if settle_count >= SETTLE_POLLS
+            else
+              settle_count = 0
+            end
+
+            if monotonic > deadline
+              session.abort
+              raise Timeout::Error, "Turn timed out after #{turn_timeout}s"
+            end
+            sleep SETTLE_POLL_INTERVAL
+          end
+        end
+
+        def turn_settled?(session, _entry)
+          queue = session.approval_queue
+          !session.running? &&
+            !session.pending_tools? &&
+            (queue.nil? || queue.pending_actions.empty?)
+        end
+
+        def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # ── Event translation (ask-agent events → adapter events) ──
+
+        def translate_event(entry, session, event)
+          payload = { "sessionId" => session.id }
+          case event
+          when Ask::Agent::Events::TextDelta
+            emit(entry, { type: "model.streaming", seq: next_seq(entry), payload: payload.merge("delta" => event.content) })
+          when Ask::Agent::Events::ThinkingDelta
+            emit(entry, { type: "model.thinking", seq: next_seq(entry), payload: payload.merge("delta" => event.content) })
+          when Ask::Agent::Events::ToolExecutionStart
+            emit(entry, {
+              type: "tool.use", seq: next_seq(entry),
+              payload: payload.merge("toolName" => event.name, "input" => event.arguments, "toolCallId" => event.id)
+            })
+          when Ask::Agent::Events::ToolExecutionUpdate
+            emit(entry, {
+              type: "tool.delta", seq: next_seq(entry),
+              payload: payload.merge("toolName" => event.name, "toolCallId" => event.id, "partial" => event.partial_result)
+            })
+          when Ask::Agent::Events::ToolExecutionEnd
+            emit(entry, {
+              type: "tool.result", seq: next_seq(entry),
+              payload: payload.merge(
+                "toolName" => event.name, "toolCallId" => event.id,
+                "output" => tool_output(event.result),
+                "isError" => !!event.is_error,
+                "durationMs" => event.duration_ms
+              )
+            })
+          when Ask::Agent::Events::TodoUpdated
+            emit(entry, { type: "todos.updated", seq: next_seq(entry), payload: payload.merge("todos" => event.todos) })
+          when Ask::Agent::Events::PlanProposed
+            emit(entry, { type: "plan.proposed", seq: next_seq(entry), payload: payload.merge("plan" => event.plan) })
+          when Ask::Agent::Events::PlanApproved
+            emit(entry, { type: "plan.approved", seq: next_seq(entry), payload: payload.merge("plan" => event.plan) })
+          when Ask::Agent::Events::PlanRejected
+            emit(entry, { type: "plan.rejected", seq: next_seq(entry), payload: payload.merge("plan" => event.plan) })
+          when Ask::Agent::Events::Error
+            emit(entry, { type: "error", seq: next_seq(entry), payload: payload.merge("error" => { "message" => event.error.to_s }) })
+          end
+        end
+
+        def tool_output(result)
+          return result.to_s if result.nil?
+          return result.to_s if result.respond_to?(:to_s) && !result.respond_to?(:data) && !result.respond_to?(:message)
+          if result.respond_to?(:ok?)
+            result.ok? ? result.data.to_s : result.message.to_s
+          else
+            result.to_s
+          end
+        end
+
+        # ── Subscription / emission ──
+
+        def subscribe_session(entry, &block)
+          @mutex.synchronize { entry[:subscribers] << block }
+          block
+        end
+
+        def unsubscribe_session(entry, subscription)
+          @mutex.synchronize { entry[:subscribers].delete(subscription) }
+        end
+
+        def emit(entry, event)
+          if event[:type] == "model.streaming"
+            @mutex.synchronize do
+              entry[:streaming_text] = entry[:streaming_text].to_s + event.dig(:payload, "delta").to_s
+            end
+          end
+          subscribers = @mutex.synchronize { entry[:subscribers].dup }
+          subscribers.each { |sub| sub.call(event) }
+        end
+
+        def emit_approval(entry, action, status)
+          payload = {
+            "sessionId" => entry[:session]&.id,
+            "actionId" => action.id,
+            "toolName" => action.tool_name,
+            "args" => action.args,
+            "message" => action.message,
+            "autoApprovable" => action.auto_approvable,
+            "status" => status.to_s
+          }
+          type = status == :pending ? "approval.required" : "approval.updated"
+          emit(entry, { type: type, seq: next_seq(entry), payload: payload })
+        end
+
+        def accumulated_text(entry)
+          @mutex.synchronize { entry[:streaming_text].to_s }
+        end
+
+        def action_hash(action)
+          {
+            "id" => action.id,
+            "tool_call_id" => action.tool_call_id,
+            "tool_name" => action.tool_name,
+            "args" => action.args,
+            "auto_approvable" => action.auto_approvable,
+            "status" => action.status.to_s,
+            "message" => action.message
+          }
+        end
+
+        def next_seq(entry)
+          @mutex.synchronize { entry[:seq] += 1 }
         end
       end
     end

data/lib/ask/coding_providers/claude/adapter.rb

@@ -90,10 +90,12 @@ module Ask
               case event["type"]
               when "assistant"
                 msg = event["message"] || {}
-                (msg["content"] || []).each do |block|
-                  if block["type"] == "text" && block["text"]
-                    delta = block["text"]
+                (msg["content"] || []).each do |content_block|
+                  if content_block["type"] == "text" && content_block["text"]
+                    delta = content_block["text"]
                     accumulated += delta
+                    # NB: the inner loop variable must not shadow the
+                    # method's &block — block.call streams to the caller.
                     block.call({
                       type: "model.streaming", seq: 2,
                       payload: { "delta" => delta, "sessionId" => session_id }

data/lib/ask/coding_providers/codex/codex_db.rb

@@ -55,7 +55,7 @@ module Ask
           return [] unless available?
 
           db = open_db
-          rows = db.execute(<<~SQL, [directory, directory])
+          rows = db.execute(<<~SQL, [directory, directory, limit])
             SELECT id, title, updated_at, preview
             FROM threads
             WHERE (cwd = ? OR ? LIKE cwd || '/%')
@@ -99,7 +99,7 @@ module Ask
           return nil unless available?
 
           db = open_db
-          row = db.get_first_row(<<~SQL, workspace_path, workspace_path)
+          row = db.get_first_row(<<~SQL, [workspace_path, workspace_path])
             SELECT id, title, cwd FROM threads
             WHERE (cwd = ? OR ? LIKE cwd || '/%')
               AND archived = 0

data/lib/ask/coding_providers/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module CodingProviders
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-coding-providers
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kaka Ruto