ask-agent 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d3eb1ad33d205f6b868c931aabf78172bc3b3d3dca0674ad67910d1ff7997a2
-  data.tar.gz: faff03efa8eba0d1594756745b9a29dcb8c2d51a362d818f7ec18904c3f9f92e
+  metadata.gz: f95edab12d96da68593e426829ac2507682b4b5620b5ec0b09269062bf168bd9
+  data.tar.gz: 7353fff33dba2ebff749df32d4c079759f1f4b2eca9193a5299fe9ec7238966c
 SHA512:
-  metadata.gz: a9212d2d0730b6e5a9df227bb75c15a8491685b9243e6cf5f4f7511763e51a4b0bcc31c624f760e113c9e52d701863cf95664d67200bc54d67d7d9922932d6f6
-  data.tar.gz: 1c8664489865b480faf003c19952fc13963238e1259c9f3e7170592a31a10eca13b39cab40fa2d428274b3f3f49a405b8be817a5475b3e86fd211bcfa4c1630b
+  metadata.gz: 3e3dc6f6cae44b0c2f36e12c9253b3f21e97a17634907754cc1d2ea8930bd8bcc54b2f65ef2194dae9e1e60d4a721d8071a677f3f0bbfa0d99d68515c0da82b9
+  data.tar.gz: ab443967abf274b113b9ebd8f2901feffa1cf2d7e1436e6a14df8d1dbb87fa1f204d0cb97d2d567858e89631c0b08ed97bf4183174c6ffce97aee363ffa0f724

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## [0.8.0] — 2026-07-21
+
+### Added
+
+- **Provider-executed tool support in the agent loop** — `ResponseMessage` now carries a `tool_results` field for pre-computed results from provider-executed tools (e.g. OpenAI web search, file search, code interpreter). The `Loop` detects these results, adds them directly to the conversation without local execution, then proceeds with any remaining user tool calls.
+
+  ```ruby
+  agent = Ask::Agent.new("health_check")
+  agent.run("Search the web for server status")
+  # web_search runs on OpenAI's side; results come back pre-computed
+  ```
+
+### Changed
+
+- **`ResponseMessage`** added `tool_results` field (default `{}`). All existing call sites are compatible via keyword argument defaults.
+- **`Loop#run_turn`** — separates provider-executed results from user tool calls. Provider results are added to the conversation immediately. User tool calls continue to be executed locally via `ToolExecutor`.
+- **OpenAI provider** — `split_tools` separates `Ask::ProviderTool` objects from regular tools. `format_responses_tools` converts provider tools to the Responses API format. When provider tools are present, the Responses API endpoint is used instead of Chat Completions.
+
+### Tested
+
+- 13 new integration tests: loop handling with mixed tool types, provider-only tools, tool splitting, Responses API formatting.
+- Full suite: 329 tests, 592 assertions — 0 failures.
+
 ## [0.7.0] — 2026-07-21
 
 ### Added

data/lib/ask/agent/chat.rb

@@ -4,7 +4,14 @@ module Ask
   module Agent
     # Response message returned by {Chat#ask}.
     # Includes token counts and cost when available from the provider.
-    ResponseMessage = Data.define(:content, :tool_calls, :thinking, :input_tokens, :output_tokens, :cost) do
+    # +tool_calls+ are calls that need local execution.
+    # +tool_results+ are pre-computed results from provider-executed tools.
+    ResponseMessage = Data.define(:content, :tool_calls, :tool_results, :thinking, :input_tokens, :output_tokens, :cost) do
+      def initialize(content:, tool_calls: {}, tool_results: {}, thinking: nil, input_tokens: nil, output_tokens: nil, cost: nil)
+        super(content: content, tool_calls: tool_calls, tool_results: tool_results, thinking: thinking,
+              input_tokens: input_tokens, output_tokens: output_tokens, cost: cost)
+      end
+
       def tool_call? = !tool_calls.empty?
       def to_s = content.to_s
     end
@@ -286,6 +293,7 @@ module Ask
         ResponseMessage.new(
           content: stream.accumulated_text,
           tool_calls: build_current_tool_calls(calls_acc),
+          tool_results: {},
           thinking: stream.chunks.filter_map(&:thinking).last,
           input_tokens: tokens[:input],
           output_tokens: tokens[:output],
@@ -300,9 +308,11 @@ module Ask
         input_tokens = metadata[:input_tokens] || metadata["input_tokens"]
         output_tokens = metadata[:output_tokens] || metadata["output_tokens"]
         cost = calculate_cost(input_tokens, output_tokens)
+        tool_results = metadata[:provider_results] || metadata["provider_results"] || {}
         ResponseMessage.new(
           content: msg.content.to_s,
           tool_calls: tool_calls,
+          tool_results: tool_results,
           thinking: thinking,
           input_tokens: input_tokens,
           output_tokens: output_tokens,

data/lib/ask/agent/loop.rb

@@ -43,34 +43,56 @@ module Ask
         event_emitter.emit(Events::MessageEnd.new(tool_calls: response.tool_call?))
         @turn_count += 1
 
-        unless response.tool_call?
+        # Check if there are any tool calls (user-executed or provider-executed)
+        has_tool_calls = response.tool_call? || (response.tool_results&.any? == true)
+
+        unless has_tool_calls
           @consecutive_tool_turns = 0
           return response.content.to_s
         end
 
         @consecutive_tool_turns += 1
 
-        # Execute tools with concurrent result streaming
-        tool_results = tool_executor.execute_parallel(
-          response.tool_calls, tools, hooks, event_emitter, ToolAbortController.new
-        ) do |tool_call_id, result|
-          # Add each tool result as it completes (concurrent streaming)
-          tc = response.tool_calls[tool_call_id]
-          chat.add_message(role: :tool, content: result[:message].to_s, tool_call_id: tool_call_id) if tc
+        provider_results = response.tool_results || {}
+        all_tool_results = []
+
+        # Add provider-executed tool results directly to conversation
+        provider_results.each do |id, result|
+          chat.add_message(role: :tool, content: result[:message].to_s, tool_call_id: id)
+          all_tool_results << {
+            tool_name: result[:tool_name] || id,
+            message: result[:message].to_s,
+            status: result[:status] || "success",
+            provider_executed: true
+          }
+        end
+
+        # Determine which tool calls still need local execution
+        user_tool_calls = response.tool_calls.reject { |id, _| provider_results.key?(id) }
+
+        if user_tool_calls.any?
+          # Execute user tool calls locally
+          user_results = tool_executor.execute_parallel(
+            user_tool_calls, tools, hooks, event_emitter, ToolAbortController.new
+          ) do |tool_call_id, result|
+            tc = user_tool_calls[tool_call_id]
+            chat.add_message(role: :tool, content: result[:message].to_s, tool_call_id: tool_call_id) if tc
+          end
+          all_tool_results.concat(user_results)
         end
 
         # Check loop detection
-        if loop_detected?(tool_results)
-          raise LoopDetected, tool_results.last[:tool_name]
+        if loop_detected?(all_tool_results)
+          raise LoopDetected, all_tool_results.last[:tool_name]
         end
 
         if @consecutive_tool_turns >= @max_consecutive_tool_turns
-          summary = tool_results.map { |r| r[:message].to_s.truncate(80) }.first(2).join("; ")
+          summary = all_tool_results.map { |r| r[:message].to_s.truncate(80) }.first(2).join("; ")
           return "Based on my investigation: #{summary}"
         end
 
         event_emitter.emit(Events::TurnEnd.new(
-          tool_results: tool_results,
+          tool_results: all_tool_results,
           turn_number: @turn_count,
           input_tokens: @last_input_tokens,
           output_tokens: @last_output_tokens,

data/lib/ask/agent/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Agent
-    VERSION = "0.7.0"
+    VERSION = "0.8.0"
   end
 end

metadata

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