ask-agent 0.33.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90d637b9a007fef96f7b03e78ac61366ec3597bd789dfb3aaa36059687fb1632
-  data.tar.gz: 48e9b46cd59bdbefa5e93dc2925c42c13f8b9ab85b389a2e4bf2b15b2c7add1e
+  metadata.gz: fcbe9fc4bae7e7eddc9fc206e35ef22499a9fb3a308bac6d9f48c2d1d2e12f8f
+  data.tar.gz: ae9c72d61a839330d2bbc68b8049fe1e54680f0462d4dee2e886d8377df439b3
 SHA512:
-  metadata.gz: a1f76527ad518404c64c36c697db32fdebdb4b6381d86513e3aca4658486db238c2ab08a4df4df9ebdd6f0997fb9a5620c8d4d77bf69e9dbd70bb3235009d8a7
-  data.tar.gz: b1697c33f4ca2dad32a05e716c060ec14baaf848e9b39f918a43a8917682fe7baf76c80ea583ffa44f648fe14c778d4b39fbb1d4237adae6718b78d14c6ea10f
+  metadata.gz: 7a34904c0d8c0d6397753262d4f3c359674893b5ddab7a85714f8eebf797db0cdd3b6a076ea2c18eb693ad1f2211677e88bf4f4a7f4e2e2f7fe5545892af5062
+  data.tar.gz: d78f87319a5d6b63c22e1bd7d9cacde6fd6306131f746ad5b4166d509acf5dad11b03db7e9fab6f908db752f7a592f2a4dc51fdb13fb4fa30ebc39c193894acb

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+## [0.36.0] — 2026-08-07
+
+### Added
+
+- **Large-output offloading — tool results never bloat the transcript.**
+  `Session.new(offload_large_outputs: true)` (or an Integer threshold,
+  default 4000 chars) stores tool messages above the threshold in a
+  state-backed store; the transcript keeps a short preview plus a reference
+  the model retrieves with the injected `output_read` tool:
+  - `Ask::Agent::ToolOutputStore` — pure KV on the same
+    `Ask::State::Adapter` as sessions/checkpoints/memory
+    (`output:<session_id>:<call_id>` + JSON index), works with every
+    backend; in-process Memory fallback when no `state:` is given. Stored
+    outputs are capped (`max_size:`, default 50,000 chars).
+  - `output_read` is exempt from offloading — its contract is to bring the
+    full output into context on demand.
+  - `Session#delete` cleans up the session's stored outputs.
+  - The loop now passes `session_id` to the tool executor (previously nil),
+    which offloading relies on.
+
+## [0.35.0] — 2026-08-07
+
+### Added
+
+- **Memory learning — automatic extraction (v2 of durable memory).**
+  `Session.new(memory: memory, memory_learning: true)` extracts durable
+  facts from the transcript when the session ends — the model no longer has
+  to remember to call `memory_write`:
+  - `Ask::Agent::MemoryExtractor` reads the memory-relevant messages (user
+    + assistant, capped, oldest dropped), sends them to the model with a
+    configurable structured-output prompt, and writes the returned facts
+    into the store — deduped (exact + near-duplicate via search), stamped
+    with provenance (`extracted: true`, source session id), and capped
+    (`max_candidates:`, default 10).
+  - Extraction is best-effort: unparseable responses and failed calls
+    yield an empty result and never break the session.
+  - `Memory.new(max_entries:)` prunes the oldest entries once a namespace
+    exceeds the cap — bounded memory, not a growing dump.
+  - Requires `memory:`; `memory_learning:` without it raises.
+
+## [0.34.1] — 2026-08-07
+
+### Added
+
+- **`account_id` session option.** `Ask::Agent::Chat.new(..., account_id:)` merges the value into the provider config (e.g. `ChatGPT-Account-Id` for the OpenAI Codex provider).
+
+## [0.34.0] — 2026-08-07
+
+### Added
+
+- **Runtime model/provider/key overrides.** `Ask::Agent.new(name, model:, provider:, api_key:, api_base:)` and `Ask::Agent::Chat.new(..., api_key:, api_base:)` — caller-supplied options win over the definition's config, and an explicit `api_key`/`api_base` is merged into the provider config ahead of Ask::Auth resolution. This is the BYOK / per-user credential injection seam (a session can be built against a specific provider and key without touching global configuration).
+
 ## [0.33.0] — 2026-08-06
 
 ### Added

data/lib/ask/agent/chat.rb

@@ -33,7 +33,7 @@ module Ask
 
       attr_writer :test_provider
 
-      def initialize(model:, tools: [], temperature: nil, schema: nil, provider: nil, prompt_caching: nil, **)
+      def initialize(model:, tools: [], temperature: nil, schema: nil, provider: nil, prompt_caching: nil, api_key: nil, api_base: nil, account_id: nil, **)
         @model_id = model.respond_to?(:id) ? model.id : model.to_s
         @model_info = Ask::ModelCatalog.find(@model_id)
         @tools = tools
@@ -41,6 +41,9 @@ module Ask
         @schema = schema
         @messages = []
         @provider_override = provider
+        @api_key = api_key
+        @api_base = api_base
+        @account_id = account_id
         @provider = nil
 
         # Read configured middleware, transforms, and caching from global config
@@ -130,12 +133,13 @@ module Ask
           cred_names << [base_s.to_sym, :api_key]
         end
 
-        key = Ask::Auth.resolve(*cred_names) rescue nil
+        key = @api_key || (Ask::Auth.resolve(*cred_names) rescue nil)
 
-        base_url = Ask::Auth.resolve(:"#{slug}_api_base") rescue nil
+        base_url = @api_base || (Ask::Auth.resolve(:"#{slug}_api_base") rescue nil)
         config = { api_key: key }
         config[:"#{slug}_api_key"] = key
         config[:"#{slug}_api_base"] = base_url if base_url
+        config[:account_id] = @account_id if @account_id
         Ask::LLM::Config.new(config)
       end
 

data/lib/ask/agent/loop.rb

@@ -99,6 +99,7 @@ module Ask
           # when the background work completes.
           user_results = tool_executor.execute(
             user_tool_calls, tools, hooks: hooks, event_emitter: event_emitter,
+            session_id: session_id,
             result_callback: lambda do |tool_call_id, result|
               tc = user_tool_calls[tool_call_id]
               next unless tc

data/lib/ask/agent/memory.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "monitor"
 require "securerandom"
 require "time"
 
@@ -37,10 +38,13 @@ module Ask
 
       # @param state [Ask::State::Adapter] backing store
       # @param namespace [String] isolation scope (user id, project id, ...)
-      def initialize(state:, namespace:)
+      # @param max_entries [Integer, nil] when set, the oldest entries are
+      #   pruned once the namespace exceeds this many entries
+      def initialize(state:, namespace:, max_entries: nil)
         @state = state
         @namespace = namespace.to_s
-        @mutex = Mutex.new
+        @max_entries = max_entries
+        @mutex = Monitor.new
       end
 
       # @return [Ask::State::Adapter] the underlying adapter
@@ -67,6 +71,7 @@ module Ask
           entry = Entry.new(id: SecureRandom.uuid, content: content, metadata: metadata, created_at: Time.now)
           @state.set(entry_key(entry.id), entry.to_h)
           @state.set(index_key, (load_index + [entry.id]).to_json)
+          prune_oldest if @max_entries
           entry
         end
       end
@@ -115,6 +120,15 @@ module Ask
 
       private
 
+      # Drop the oldest entries beyond the max_entries cap (called under the
+      # write mutex; delete re-enters it, which is safe).
+      def prune_oldest
+        current = entries
+        return if current.size <= @max_entries
+
+        current.first(current.size - @max_entries).each { |entry| delete(entry.id) }
+      end
+
       def entries
         load_index.filter_map { |id| load_entry(id) }
       end

data/lib/ask/agent/memory_extractor.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module Agent
+    # Extracts durable facts from a finished session's transcript and writes
+    # them to the session's {Memory} — the "learning" half of durable memory
+    # (codex two-phase pattern, phase 1).
+    #
+    # One LLM call with a structured-output prompt: the model reads the
+    # memory-relevant messages and returns a JSON list of durable facts.
+    # Candidates are deduped against the store (exact + near-duplicate via
+    # search), written with provenance (extracted: true, source session id),
+    # and capped at +max_candidates+.
+    #
+    # Extraction never raises: a failed call or unparseable response yields
+    # an empty result hash, never a broken session.
+    #
+    # Session wiring: `Session.new(memory: memory, memory_learning: true)`.
+    class MemoryExtractor
+      DEFAULT_SYSTEM_PROMPT = <<~PROMPT.strip
+        You are a memory curator. Read the conversation transcript and extract
+        durable facts worth remembering across sessions: user preferences,
+        decisions, conventions, resolved problems, and standing instructions.
+        Skip ephemeral details, session-specific chatter, secrets, and facts
+        already obvious from the conversation itself.
+        Respond with JSON only: {"facts": ["fact one", "fact two", ...]}.
+        Return an empty list if nothing is worth remembering.
+      PROMPT
+
+      # @param model [String] model to extract with
+      # @param memory [Ask::Agent::Memory] store to write into
+      # @param chat [Ask::Agent::Chat, nil] chat to use (built from +model+
+      #   when nil; inject a stub in tests)
+      # @param system_prompt [String] domain-specific extraction instructions
+      # @param max_candidates [Integer] cap on facts written per extraction
+      # @param max_transcript_messages [Integer] cap on transcript messages
+      #   sent to the model (oldest dropped first)
+      def initialize(model:, memory:, chat: nil, system_prompt: DEFAULT_SYSTEM_PROMPT,
+                     max_candidates: 10, max_transcript_messages: 60)
+        @model = model
+        @memory = memory
+        @chat = chat
+        @system_prompt = system_prompt
+        @max_candidates = max_candidates
+        @max_transcript_messages = max_transcript_messages
+      end
+
+      # @param transcript [Array<Ask::Message>] the finished session's messages
+      # @param session_id [String, nil] stamped into extracted entries as
+      #   provenance
+      # @return [Hash] {extracted: [String], skipped: [String], error: [String, nil]}
+      def extract(transcript:, session_id: nil)
+        relevant = memory_relevant_messages(transcript)
+        return { extracted: [], skipped: [], error: nil } if relevant.empty?
+
+        facts = request_facts(relevant)
+        return { extracted: [], skipped: [], error: "no facts returned" } if facts.empty?
+
+        extracted = []
+        skipped = []
+        facts.first(@max_candidates).each do |fact|
+          if duplicate?(fact)
+            skipped << fact
+          else
+            @memory.write(
+              fact,
+              metadata: { extracted: true, session_id: session_id, extracted_at: Time.now.iso8601 }
+            )
+            extracted << fact
+          end
+        end
+        { extracted: extracted, skipped: skipped, error: nil }
+      rescue StandardError => e
+        { extracted: [], skipped: [], error: e.message }
+      end
+
+      private
+
+      # User and assistant messages with content, oldest dropped first beyond
+      # the cap. Tool and system messages never reach the model.
+      def memory_relevant_messages(transcript)
+        transcript
+          .select { |m| %i[user assistant].include?(m.role.to_sym) && m.content.to_s.strip.length.positive? }
+          .last(@max_transcript_messages)
+      end
+
+      def request_facts(messages)
+        body = messages.map { |m| "#{m.role}: #{m.content}" }.join("\n")
+        response = chat.ask("#{@system_prompt}\n\nTranscript:\n#{body}")
+        parse_facts(response.content.to_s)
+      end
+
+      def chat
+        @chat ||= Chat.new(model: @model, tools: [])
+      end
+
+      def parse_facts(content)
+        parsed = JSON.parse(content)
+        facts = parsed.is_a?(Hash) ? (parsed["facts"] || parsed[:facts]) : parsed
+        Array(facts).map(&:to_s).map(&:strip).reject(&:empty?)
+      rescue JSON::ParserError
+        # Fallback: the first JSON array in the response.
+        match = content.match(/\[.*\]/m)
+        match ? JSON.parse(match[0]).map(&:to_s).map(&:strip).reject(&:empty?) : []
+      end
+
+      def duplicate?(fact)
+        @memory.search(fact, limit: 1).any? { |entry| similar?(entry.content, fact) }
+      end
+
+      def similar?(a, b)
+        a == b || a.include?(b) || b.include?(a)
+      end
+    end
+  end
+end

data/lib/ask/agent/output_read.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "ask/tools/tool"
+require "ask/result"
+
+module Ask
+  module Agent
+    # Tool that retrieves an offloaded tool output by call id — the other
+    # half of large-output offloading. The transcript keeps a preview plus a
+    # reference ("output_read id: \"call_123\""); this tool fetches the full
+    # output from the session's {ToolOutputStore}.
+    #
+    # Injected into the session when large-output offloading is enabled.
+    class OutputRead < Ask::Tool
+      description "Retrieve the full output of a tool call that was truncated in the conversation. " \
+                   "Use the id from the truncation note (e.g. output_read id: \"call_123\")."
+
+      param :id, type: :string, desc: "Tool call id from the truncation note", required: true
+
+      # @param store [Ask::Agent::ToolOutputStore]
+      # @param session_id [String] scopes lookups to this session
+      def initialize(store:, session_id:)
+        @store = store
+        @session_id = session_id
+        super()
+      end
+
+      def execute(id:)
+        output = @store.fetch(@session_id, id)
+        return Ask::Result.error(message: "No stored output for id #{id.inspect}") if output.nil?
+
+        Ask::Result.ok(data: output)
+      end
+    end
+  end
+end

data/lib/ask/agent/session.rb

@@ -24,7 +24,9 @@ module Ask
                      agent_dir: nil, evaluator: nil, audit_log: nil,
                      skills_disclosure: true, approval: nil,
                      tool_call_repair: nil, checkpoints: false,
-                     todos: false, plan_mode: false, memory: nil, **chat_options)
+                     todos: false, plan_mode: false, memory: nil,
+                     memory_learning: false, offload_large_outputs: false,
+                     **chat_options)
         @id = id || SecureRandom.uuid
         @agent_dir = agent_dir
         @max_turns = max_turns
@@ -57,6 +59,24 @@ module Ask
         # Durable memory (memory_write / memory_search tools). An instance
         # with its own namespace and state adapter; nil disables memory.
         @memory = memory
+        # Learning: extract durable facts from the transcript when the
+        # session ends (requires memory).
+        if memory_learning && !@memory
+          raise ArgumentError, "memory_learning: requires a memory: instance"
+        end
+        @memory_learning = !!memory_learning
+
+        # Large-output offloading: tool results above a size threshold are
+        # stored in a ToolOutputStore (state adapter when present, else
+        # in-process) and the transcript keeps a preview + reference.
+        @offload_threshold = case offload_large_outputs
+        when true then 4000
+        when Integer then offload_large_outputs
+        else nil
+        end
+        @output_store = if @offload_threshold
+          ToolOutputStore.new(state: state || persistence || Ask::State::Memory.new)
+        end
 
         # Plan mode — research phase gated to read-only tools until a human
         # approves the model's plan (submitted via the exit_plan_mode tool).
@@ -74,7 +94,12 @@ module Ask
         @tools = resolve_tools(tools)
         @chat = build_chat(model, system_prompt, @tools, **chat_options)
         @loop = Loop.new(max_turns: max_turns)
-        @tool_executor = ToolExecutor.new(max_retries: max_tool_retries, parallel: parallel_tools)
+        @tool_executor = ToolExecutor.new(
+          max_retries: max_tool_retries,
+          parallel: parallel_tools,
+          output_offload_threshold: @offload_threshold,
+          output_store: @output_store
+        )
         @compactor = compactor ? build_compactor(compactor) : nil
         @hooks = Hooks.new(hooks)
         @audit_log = build_audit_log(audit_log)
@@ -144,6 +169,9 @@ module Ask
       # @return [Ask::Agent::Memory, nil] durable memory (only when passed
       #   via the +memory:+ option)
       attr_reader :memory
+      # @return [Ask::Agent::ToolOutputStore, nil] store for offloaded large
+      #   tool outputs (only when large-output offloading is enabled)
+      attr_reader :output_store
 
       def run(message, tools: nil, reset: true)
         raise "Session deleted" if @deleted
@@ -209,6 +237,10 @@ module Ask
           @running = false
           Ask::Agent.current_session = nil if Ask::Agent.current_session.equal?(self)
           persist! if @state
+          # Learn from this session: extract durable facts into memory.
+          # Only on the initial run (not follow-ups); best-effort, never
+          # raises.
+          extract_memories if reset && @memory_learning
           # A pending tool completed while this run was busy: voice the
           # result now that the turn is over (one follow-up per completion).
           follow_up = @pending_mutex.synchronize do
@@ -396,6 +428,7 @@ module Ask
       def delete
         @deleted = true
         @checkpoint_store&.delete(@id)
+        @output_store&.delete(@id)
         @state&.delete(@id)
       end
 
@@ -484,6 +517,16 @@ module Ask
 
       # --- Plan mode ---
 
+      # Extract durable facts from this session's transcript into memory
+      # (memory_learning: true). Best-effort — extraction never breaks the
+      # session; failures are swallowed.
+      def extract_memories
+        extractor = MemoryExtractor.new(model: model_id_from(@chat), memory: @memory)
+        extractor.extract(transcript: @chat.messages, session_id: @id)
+      rescue StandardError
+        nil
+      end
+
       # Retrieve memories relevant to the incoming message and inject them
       # as a system message, so a new session starts with what earlier
       # sessions learned.
@@ -751,6 +794,9 @@ module Ask
           resolved << MemoryWrite.new(memory: @memory, session_id: @id) unless resolved.any? { |t| t.name == "memory_write" }
           resolved << MemorySearch.new(memory: @memory) unless resolved.any? { |t| t.name == "memory_search" }
         end
+        if @output_store
+          resolved << OutputRead.new(store: @output_store, session_id: @id) unless resolved.any? { |t| t.name == "output_read" }
+        end
         resolved
       end
 

data/lib/ask/agent/tool_executor.rb

@@ -11,10 +11,12 @@ module Ask
 
       attr_reader :total_executions
 
-      def initialize(max_retries: 3, parallel: true)
+      def initialize(max_retries: 3, parallel: true, output_offload_threshold: nil, output_store: nil)
         @max_retries = max_retries
         @parallel = parallel
         @total_executions = 0
+        @output_offload_threshold = output_offload_threshold
+        @output_store = output_store
       end
 
       attr_writer :telemetry
@@ -185,6 +187,15 @@ module Ask
           result[:result].to_s
         end
 
+        # Large outputs never enter the transcript: store the full message
+        # and keep a short preview plus a reference the model can retrieve
+        # with the output_read tool. output_read's own result is exempt —
+        # its contract is to bring the full output into context on demand.
+        if @output_offload_threshold && message.length > @output_offload_threshold &&
+           tool_call.name != "output_read"
+          message = offload_message(message, tool_call.id)
+        end
+
         inner = result[:result]
         status = if result[:is_error] == true
           "error"
@@ -236,6 +247,15 @@ module Ask
         { result: e.message, is_error: true, error: e.class.name }
       end
 
+      # Store a large tool message in the output store and return a short
+      # preview that references it, so the transcript never carries the full
+      # output.
+      def offload_message(message, tool_call_id)
+        @output_store.store(@session_id, tool_call_id, message)
+        preview = message[0, 300]
+        "#{preview}\n...(output truncated: #{message.length} chars — full output via output_read id: \"#{tool_call_id}\")"
+      end
+
       def retryable_error_name?(error_name)
         return false unless error_name
 

data/lib/ask/agent/tool_output_store.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module Agent
+    # State-backed storage for large tool outputs, keeping them out of the
+    # conversation transcript.
+    #
+    # When a tool result exceeds the session's offload threshold, the
+    # executor stores the full output here and the transcript keeps a short
+    # preview plus a reference the model can retrieve with the output_read
+    # tool (and the web UI can fetch from the same store).
+    #
+    # Storage shape (pure KV — works with every Ask::State::Adapter backend
+    # including custom get/set/delete adapters):
+    #   output:<session_id>:<call_id>   — one key per offloaded output
+    #   output:<session_id>:index       — JSON array of call ids (write order)
+    #
+    #   store = Ask::Agent::ToolOutputStore.new(state: adapter)
+    #   store.store(session_id, "call_1", huge_output)
+    #   store.fetch(session_id, "call_1")   # => huge_output
+    #   store.delete(session_id)            # session cleanup
+    class ToolOutputStore
+      KEY_PREFIX = "output:"
+      INDEX_SUFFIX = ":index"
+
+      # @param state [Ask::State::Adapter] backing store
+      # @param max_size [Integer] stored outputs are truncated to this many
+      #   characters (with a truncation marker)
+      def initialize(state:, max_size: 50_000)
+        @state = state
+        @max_size = max_size
+        @mutex = Monitor.new
+      end
+
+      # @return [Ask::State::Adapter] the underlying adapter
+      attr_reader :state
+
+      # Store an output for a tool call (idempotent per call id — a later
+      # store with the same call id replaces the earlier one).
+      #
+      # @param session_id [String]
+      # @param call_id [String]
+      # @param content [String]
+      # @return [String] the stored content (possibly truncated)
+      def store(session_id, call_id, content)
+        stored = content.to_s
+        stored = "#{stored[0, @max_size]}\n...(output truncated)" if stored.length > @max_size
+
+        @mutex.synchronize do
+          @state.set(entry_key(session_id, call_id), stored)
+          index = load_index(session_id)
+          @state.set(index_key(session_id), (index + [call_id]).uniq.to_json)
+        end
+        stored
+      end
+
+      # @param session_id [String]
+      # @param call_id [String]
+      # @return [String, nil] the stored output, or nil when absent
+      def fetch(session_id, call_id)
+        @state.get(entry_key(session_id, call_id))
+      end
+
+      # Remove every output for a session (called by Session#delete).
+      #
+      # @param session_id [String]
+      # @return [void]
+      def delete(session_id)
+        @mutex.synchronize do
+          load_index(session_id).each { |call_id| @state.delete(entry_key(session_id, call_id)) }
+          @state.delete(index_key(session_id))
+        end
+        nil
+      end
+
+      private
+
+      def load_index(session_id)
+        raw = @state.get(index_key(session_id))
+        raw ? JSON.parse(raw) : []
+      end
+
+      def entry_key(session_id, call_id)
+        "#{KEY_PREFIX}#{session_id}:#{call_id}"
+      end
+
+      def index_key(session_id)
+        "#{KEY_PREFIX}#{session_id}#{INDEX_SUFFIX}"
+      end
+    end
+  end
+end

data/lib/ask/agent/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Agent
-    VERSION = "0.33.0"
+    VERSION = "0.36.0"
   end
 end

data/lib/ask/agent.rb

@@ -46,6 +46,9 @@ module Ask
     autoload :Memory, "ask/agent/memory"
     autoload :MemoryWrite, "ask/agent/memory_write"
     autoload :MemorySearch, "ask/agent/memory_search"
+    autoload :MemoryExtractor, "ask/agent/memory_extractor"
+    autoload :ToolOutputStore, "ask/agent/tool_output_store"
+    autoload :OutputRead, "ask/agent/output_read"
 
     module Middleware
       autoload :Base, "ask/agent/middleware/base"
@@ -80,14 +83,16 @@ module Ask
       # Create a new agent session from a named definition.
       #
       # @param name [String, Symbol] the agent name (directory name under +agents/+)
+      # @param opts [Hash] runtime overrides — model, provider, api_key, api_base,
+      #   max_turns, etc. Caller-supplied options win over the definition's config.
       # @return [Session] a configured, ready-to-run session
-      def new(name)
+      def new(name, **opts)
         discover!
         entry = @registry[name.to_s]
         raise UnknownAgent, "Unknown agent: #{name.inspect}. Searched agents/ and app/agents/." unless entry
 
         klass, dir = entry
-        build_session_from_definition(klass, dir)
+        build_session_from_definition(klass, dir, opts)
       end
 
       # Force re-discovery of agent definitions.
@@ -182,7 +187,7 @@ module Ask
         end
       end
 
-      def build_session_from_definition(klass, dir)
+      def build_session_from_definition(klass, dir, opts = {})
         config = klass._config
         session_opts = { model: config[:model] || Ask::Agent.configuration.default_model }
 
@@ -218,6 +223,10 @@ module Ask
           Ask::Agent.configuration.scheduler.every(schedule, name: File.basename(dir), &task_block)
         end
 
+        # Caller-supplied runtime options (model/provider/api_key/api_base/...)
+        # win over the definition's config.
+        session_opts.merge!(opts) unless opts.empty?
+
         Session.new(**session_opts)
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-agent
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.36.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -179,6 +179,7 @@ files:
 - lib/ask/agent/hooks.rb
 - lib/ask/agent/loop.rb
 - lib/ask/agent/memory.rb
+- lib/ask/agent/memory_extractor.rb
 - lib/ask/agent/memory_search.rb
 - lib/ask/agent/memory_write.rb
 - lib/ask/agent/meta_agent.rb
@@ -188,6 +189,7 @@ files:
 - lib/ask/agent/middleware/model_fallback.rb
 - lib/ask/agent/middleware/pipeline.rb
 - lib/ask/agent/middleware/retry_on_failure.rb
+- lib/ask/agent/output_read.rb
 - lib/ask/agent/persistence/base.rb
 - lib/ask/agent/persistence/in_memory.rb
 - lib/ask/agent/policies/approval_policy.rb
@@ -214,6 +216,7 @@ files:
 - lib/ask/agent/tool_abort_controller.rb
 - lib/ask/agent/tool_call_repair.rb
 - lib/ask/agent/tool_executor.rb
+- lib/ask/agent/tool_output_store.rb
 - lib/ask/agent/version.rb
 homepage: https://github.com/ask-rb/ask-agent
 licenses: