ask-agent 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d3eb1ad33d205f6b868c931aabf78172bc3b3d3dca0674ad67910d1ff7997a2
-  data.tar.gz: faff03efa8eba0d1594756745b9a29dcb8c2d51a362d818f7ec18904c3f9f92e
+  metadata.gz: 9a50ba3d8610e0e05d54ff53c23757a4ef6ecfddb3bc43094d469ebd252e6cfa
+  data.tar.gz: 2269528d25df7991e2aefbc84c4fc89a5a6a4ac4b1d9fbfb95ab9dd421bfa9ba
 SHA512:
-  metadata.gz: a9212d2d0730b6e5a9df227bb75c15a8491685b9243e6cf5f4f7511763e51a4b0bcc31c624f760e113c9e52d701863cf95664d67200bc54d67d7d9922932d6f6
-  data.tar.gz: 1c8664489865b480faf003c19952fc13963238e1259c9f3e7170592a31a10eca13b39cab40fa2d428274b3f3f49a405b8be817a5475b3e86fd211bcfa4c1630b
+  metadata.gz: cc258ca1b71919c61a5986f18190c3c5b2bed2d17d1f8efa6e63a8f8f37e258694603ce9b9c382e1843b6c03f94f7121b976f2875d9e429146bd024dfbd9162c
+  data.tar.gz: b371ea561dcd8d67e49c26e0fa18eaa0d142040f0e1adb4de7eba9c517d5cc7e03892dda1edccf2f0b46a3c2e672408f4fe8103547dee9ebd029f5d6f23d0482

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+## [0.8.1] — 2026-07-21
+
+### Added
+
+- **Per-agent skills via `agent_dir:`** — `Session` now accepts `agent_dir:` parameter. When set, `Ask::Skills.discover(agent_dir:)` discovers skills scoped to that agent directory, loading them alongside shared skills.
+
+- **Agent definitions pass `agent_dir` automatically** — `Ask::Agent.new("name")` passes the agent's directory path to `Session`, enabling per-agent skill discovery without any configuration.
+
+### Changed
+
+- `Ask::Agent::Session#initialize` now accepts optional `agent_dir:` keyword.
+- Skills discovery in Session uses `Ask::Skills.discover(agent_dir: @agent_dir)` instead of the plain `Ask::Skills.discover`, enabling the new per-agent and shared skills paths from ask-skills 0.3.0.
+
+## [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/configuration.rb

@@ -4,7 +4,8 @@ module Ask
   module Agent
     class Configuration
       attr_accessor :default_model, :default_max_turns, :compactor_enabled,
-                    :compactor_threshold, :parallel_tool_execution, :max_tool_retries
+                    :compactor_threshold, :parallel_tool_execution, :max_tool_retries,
+                    :prompt_caching
 
       # @return [Middleware::Pipeline] the middleware pipeline for provider calls
       attr_reader :middleware
@@ -18,7 +19,7 @@ module Ask
         @compactor_enabled = true
         @compactor_threshold = 0.8
         @parallel_tool_execution = true
-        @max_tool_retries = 3
+        @prompt_caching = false
 
         @middleware = Middleware::Pipeline.new
         @stream_transforms = StreamTransforms::Pipeline.new

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/session.rb

@@ -20,8 +20,10 @@ module Ask
       def initialize(model:, tools: [], max_turns: 25, max_tool_retries: 3,
                      compactor: nil, hooks: {}, persistence: nil,
                      id: nil, system_prompt: nil, parallel_tools: true,
-                     reflector: nil, telemetry: true, meta_agent: nil, **chat_options)
+                     reflector: nil, telemetry: true, meta_agent: nil,
+                     agent_dir: nil, **chat_options)
         @id = id || SecureRandom.uuid
+        @agent_dir = agent_dir
         @max_turns = max_turns
         @max_tool_retries = max_tool_retries
         @parallel_tools = parallel_tools
@@ -46,8 +48,8 @@ module Ask
         @compactor = compactor ? build_compactor(compactor) : nil
         @hooks = Hooks.new(hooks)
 
-        # Auto-discover skills and inject into system prompt
-        @skills_registry = Ask::Skills.discover rescue nil
+        # Auto-discover skills (shared + per-agent if agent_dir is given)
+        @skills_registry = Ask::Skills.discover(agent_dir: @agent_dir) rescue nil
         if @skills_registry && !@skills_registry.names.empty?
           skill_text = @skills_registry.format_for_prompt
           if !skill_text.empty? && @chat.messages.any? { |m| m.role == :system }

data/lib/ask/agent/version.rb

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

data/lib/ask/agent.rb

@@ -145,6 +145,9 @@ module Ask
         config = klass._config
         session_opts = { model: config[:model] || Ask::Agent.configuration.default_model }
 
+        # Pass agent directory for per-agent skills discovery
+        session_opts[:agent_dir] = dir
+
         # Resolve tools
         tools = resolve_definition_tools(config[:tools], dir)
         session_opts[:tools] = tools if tools.any?

metadata

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