ask-agent 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a067aefe3faa67280e7ba4cde37994b52f27d5e665e86510e16ee8acf594f80
-  data.tar.gz: 4d059bcc2cf98b1fa159c4ab7eba622ba1e529063b7d517343fd3a4f59b97180
+  metadata.gz: e875e155f72f3bc773ff218b64243ac918354fac930b0181e02ae1a74d0bc4eb
+  data.tar.gz: 9ec62c98c64b7307f445311cce0f6fd6bf81a9f7fde52daa505cd532d4734520
 SHA512:
-  metadata.gz: 4746d44442fbf8bdf9f67b325914cc57401857151caa2e56d5930d2134e19f03ae18d1064039e414e343539efa4c9c6be26ed2badd59898e3c5deb176f7bebe0
-  data.tar.gz: 1c8319c4cb60213a2de06b7cba0fc8443b217918586559af1c0a61e212d4cd30a58eb1d05784d4a5aca0737af65740dd4042285a8b1dc0976d4957cc426b0a5f
+  metadata.gz: 14d6490ab16f5e675e05ac3e72f37c113edcfd7e7339c10fe6a73290b88e4cab0ab8535d21860e51d09aac36c7a7066b3dbfe1f19b04d5c873a301094fb610fe
+  data.tar.gz: 729b178fb7f474e2fe5c84ce692169ba184fefe1b761d7ddc2a1dfaf39c57d184155f9f67e186bd91b13faaab05a5e79aac49107055d0089269ca10e9e100f94

data/lib/ask/agent/chat.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Ask
+  module Agent
+    # Response message returned by {Chat#ask}.
+    # Presents a message-like response interface for ask-agent internal use.
+    ResponseMessage = Data.define(:content, :tool_calls, :thinking) do
+      def tool_call? = !tool_calls.empty?
+      def to_s = content.to_s
+    end
+
+    # Tool call data used in {ResponseMessage} and {ChatChunk}.
+    ToolCallInfo = Data.define(:id, :name, :arguments)
+
+    # Chunk yielded during streaming from {Chat#ask}.
+    ChatChunk = Data.define(:content, :tool_calls, :thinking) do
+      def tool_call? = !tool_calls.empty?
+    end
+
+    # Thin wrapper around {Ask::Provider} + an internal message array that
+    # presents a Chat-like API for ask-agent internal use.
+    #
+    # Manages conversation history, resolves the correct provider/model,
+    # handles streaming chunk accumulation, and normalises tool call
+    # formats between Ask::Provider (Array of Hashes) and ask-agent
+    # internal usage (Hash of { id => ToolCallInfo }).
+    class Chat
+      # @return [String] model ID (e.g. "gpt-4o")
+      attr_reader :model
+
+      # @return [Array<Ask::Message>] all messages in the conversation
+      attr_reader :messages
+
+      # @param model [String, #ask] model ID or chat-like object
+      # @param tools [Array<Ask::Tool>] tool instances available to the chat
+      # @param temperature [Float, nil] sampling temperature
+      # @param schema [Ask::Schema, Hash, nil] structured output schema
+      def initialize(model:, tools: [], temperature: nil, schema: nil, **)
+        @model_id = model.respond_to?(:id) ? model.id : model.to_s
+        @model_info = resolve_model(@model_id)
+        @tools = tools
+        @temperature = temperature
+        @schema = schema
+        @messages = []
+        @provider = nil
+      end
+
+      # Send a user message and get a completion response.
+      #
+      # @param message [String, nil] user message text
+      # @yield [ChatChunk] streaming chunks (only when a block is given)
+      # @return [ResponseMessage] the assistant's response
+      def ask(message = nil, &block)
+        @messages << Ask::Message.new(role: :user, content: message.to_s) if message
+
+        stream = block_given?
+        tool_defs = @tools.map { |t| Ask::ToolDef.from_tool(t) }
+
+        # Accumulator for tool calls during streaming (keyed by index)
+        calls_acc = {}
+
+        result = provider.chat(
+          @messages.map(&:to_h),
+          model: @model_id,
+          tools: tool_defs,
+          temperature: @temperature,
+          stream: stream,
+          schema: @schema&.respond_to?(:to_json_schema) ? @schema.to_json_schema : @schema
+        ) do |raw_chunk|
+          next unless block_given?
+
+          # Accumulate tool calls by index during streaming
+          accumulate_tool_calls(raw_chunk, calls_acc)
+
+          # Yield adapted chunk with current tool call state
+          yield ChatChunk.new(
+            content: raw_chunk.content,
+            tool_calls: build_current_tool_calls(calls_acc),
+            thinking: raw_chunk.respond_to?(:thinking) ? raw_chunk.thinking : nil
+          )
+        end
+
+        response_msg = if stream
+          build_stream_response(result, calls_acc)
+        else
+          build_response(result)
+        end
+
+        # Store assistant response in conversation history
+        @messages << Ask::Message.new(
+          role: :assistant,
+          content: response_msg.content,
+          tool_calls: response_msg.tool_calls&.values&.map { |tc|
+            { id: tc.id, type: "function", name: tc.name, arguments: tc.arguments }
+          }
+        )
+
+        response_msg
+      end
+
+      # Add a message to the conversation history.
+      #
+      # @param role [Symbol] :system, :user, :assistant, :tool
+      # @param content [String, nil] message content
+      # @param tool_call_id [String, nil] tool call ID (for tool results)
+      # @param tool_calls [Array<Hash>, nil] tool call invocations
+      def add_message(role:, content: nil, tool_call_id: nil, tool_calls: nil)
+        @messages << Ask::Message.new(
+          role: role,
+          content: content,
+          tool_call_id: tool_call_id,
+          tool_calls: tool_calls
+        )
+      end
+
+      # Set or replace the system prompt.
+      #
+      # @param prompt [String] system instructions
+      # @return [self]
+      def with_instructions(prompt)
+        @messages.reject! { |m| m.role == :system }
+        @messages.unshift(Ask::Message.new(role: :system, content: prompt))
+        self
+      end
+
+      # Clear all messages from the conversation.
+      def reset_messages!
+        @messages.clear
+      end
+
+      private
+
+      # Resolve model info from the catalog.
+      def resolve_model(model_id)
+        Ask::ModelCatalog.find(model_id)
+      rescue Ask::ModelNotFound
+        nil
+      end
+
+      # Lazily resolve and instantiate the LLM provider.
+      def provider
+        @provider ||= build_provider
+      end
+
+      def build_provider
+        slug = @model_info&.provider || "openai"
+        klass = Ask::Provider.resolve(slug)
+        klass.new(provider_config(slug))
+      end
+
+      def provider_config(slug, extra_keys: {})
+          env_key = "#{slug.upcase}_API_KEY"
+          key = ENV[env_key] || ENV["OPENCODE_API_KEY"] || ENV["OPENAI_API_KEY"]
+          base = ENV["#{slug.upcase}_API_BASE"] || ENV["OPENCODE_API_BASE"]
+          config = { api_key: key }
+          config[:"#{slug}_api_key"] = key
+          config[:"#{slug}_api_base"] = base if base
+          Ask::LLM::Config.new(config)
+      end
+
+      # Accumulate partial tool calls from streaming chunks.
+      def accumulate_tool_calls(raw_chunk, calls_acc)
+        return unless raw_chunk.tool_call?
+
+        raw_chunk.tool_calls.each do |tc|
+          idx = tc[:index] || 0
+          calls_acc[idx] ||= { id: tc[:id], name: tc[:name], arguments: +"" }
+          calls_acc[idx][:id] ||= tc[:id]
+          calls_acc[idx][:name] ||= tc[:name]
+          calls_acc[idx][:arguments] << tc[:arguments].to_s if tc[:arguments]
+        end
+      end
+
+      # Build current snapshot of tool calls from accumulator.
+      def build_current_tool_calls(calls_acc)
+        hash = {}
+        calls_acc.each_value do |tc_data|
+          next unless tc_data[:id]
+          hash[tc_data[:id]] = ToolCallInfo.new(
+            id: tc_data[:id],
+            name: tc_data[:name] || "",
+            arguments: tc_data[:arguments]
+          )
+        end
+        hash
+      end
+
+      # Convert Ask::Provider tool_calls (Array of Hashes) to Hash.
+      def build_tool_call_hash(raw_calls)
+        hash = {}
+        raw_calls.each do |tc|
+          id = tc[:id] || tc["id"]
+          next unless id
+          hash[id] = ToolCallInfo.new(
+            id: id,
+            name: tc[:name] || tc["name"] || "",
+            arguments: tc[:arguments] || tc["arguments"] || ""
+          )
+        end
+        hash
+      end
+
+      # Build response from streaming result.
+      def build_stream_response(stream, calls_acc)
+        thinking = stream.chunks.filter_map(&:thinking).last
+        ResponseMessage.new(
+          content: stream.accumulated_text,
+          tool_calls: build_current_tool_calls(calls_acc),
+          thinking: thinking
+        )
+      end
+
+      # Build response from non-streaming result.
+      def build_response(msg)
+        tool_calls = msg.tool_calls ? build_tool_call_hash(msg.tool_calls) : {}
+        thinking = msg.respond_to?(:thinking) ? msg.thinking : nil
+        ResponseMessage.new(content: msg.content.to_s, tool_calls: tool_calls, thinking: thinking)
+      end
+    end
+  end
+end

data/lib/ask/agent/compactor.rb

@@ -138,8 +138,8 @@ module Ask
 
       def build_llm_chat
         if @llm.respond_to?(:ask) then @llm
-        elsif @llm.is_a?(String) then RubyLLM::Chat.new(model: @llm)
-        else RubyLLM::Chat.new end
+        elsif @llm.is_a?(String) then Ask::Agent::Chat.new(model: @llm)
+        else Ask::Agent::Chat.new(model: Ask::Agent.configuration.default_model) end
       end
 
       def extract_summary

data/lib/ask/agent/meta_agent.rb

@@ -100,7 +100,7 @@ module Ask
 
       def call_llm_for_analysis(telemetry_data, existing_recommendations, resolved_ids)
         prompt = build_analysis_prompt(telemetry_data, existing_recommendations, resolved_ids)
-        chat = RubyLLM::Chat.new(model: @model, **@chat_options)
+        chat = Ask::Agent::Chat.new(model: @model, **@chat_options)
         response = chat.ask(prompt)
         parse_llm_response(response.content.to_s)
       rescue => e

data/lib/ask/agent/reflector.rb

@@ -66,12 +66,12 @@ module Ask
 
       def build_eval_chat
         model_id = model_id_from(@model)
-        RubyLLM::Chat.new(model: model_id)
+        Ask::Agent::Chat.new(model: model_id)
       end
 
       def model_id_from(model)
         case model
-        when RubyLLM::Chat then model.model.respond_to?(:id) ? model.model.id : model.model.to_s
+        when Ask::Agent::Chat then model.model.to_s
         when String then model
         else model.to_s
         end

data/lib/ask/agent/session.rb

@@ -35,7 +35,6 @@ module Ask
 
         @chat = build_chat(model, system_prompt, tools, **chat_options)
         @tools = resolve_tools(tools)
-        register_tools_on_chat
         @loop = Loop.new(max_turns: max_turns)
         @tool_executor = ToolExecutor.new(max_retries: max_tool_retries, parallel: parallel_tools)
         @compactor = compactor ? build_compactor(compactor) : nil
@@ -96,7 +95,7 @@ module Ask
           emit(Events::LoopDetected.new(tool_name: e.message, repeated_count: 3))
           @telemetry.log(:loop_detected, session_id: @id, tool_name: e.message, repeated_count: 3)
           response = last_content
-        rescue RubyLLM::ContextLengthExceededError
+        rescue Ask::ContextLengthExceeded
           if @compactor && !@compactor.overflow_recovered?
             @compactor.recover_from_overflow
             retry
@@ -210,20 +209,11 @@ module Ask
 
       private
 
-      def register_tools_on_chat
-        return unless @tools.any?
-
-        def @chat.handle_tool_calls(response, &)
-          @on[:end_message]&.call(response) if @on[:end_message]
-          response
-        end
-      end
-
       def build_chat(model, system_prompt, tools, **chat_options)
         if model.respond_to?(:ask)
           model
         else
-          chat = RubyLLM::Chat.new(model: model, **chat_options)
+          chat = Ask::Agent::Chat.new(model: model, tools: tools, **chat_options)
           chat.with_instructions(system_prompt) if system_prompt
           chat
         end

data/lib/ask/agent/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Agent
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/lib/ask/agent.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "ruby_llm"
 require "fileutils"
 require "json"
 require "securerandom"
@@ -41,6 +40,7 @@ end
 
 require_relative "agent/version"
 require_relative "agent/events"
+require_relative "agent/chat"
 require_relative "agent/telemetry"
 require_relative "agent/tool_abort_controller"
 require_relative "agent/session"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-agent
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kaka Ruto
@@ -10,7 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ask-tools
+  name: ask-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: ask-tools-shell
+  name: ask-llm-providers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -38,19 +38,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: ruby_llm
+  name: ask-tools
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
-  type: :development
+        version: '0.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: ask-tools-shell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -105,6 +119,7 @@ files:
 - README.md
 - lib/ask-agent.rb
 - lib/ask/agent.rb
+- lib/ask/agent/chat.rb
 - lib/ask/agent/compactor.rb
 - lib/ask/agent/configuration.rb
 - lib/ask/agent/events.rb