mistri 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05f65dbeaf12ad0dc59334e300a2ecd2febc01607d528c0d8e7a95003c49e608
-  data.tar.gz: f1c261e05ee6e433f3b08f6c129841b6b25a44ee935671d3314681de792d0da5
+  metadata.gz: 820753fb8dd64f485da060568e6dbc8a7af3fa24d63a2cc7dc957b5dbfc9f1d6
+  data.tar.gz: c3e7432802801d19979c3d2906f700fbe3170a1d4950d22f0da88e01b276b905
 SHA512:
-  metadata.gz: 852c0bc7b87c7aa8b09b6862b88babbdbe3ddd6bd3e9736d8429818a3daaa98279fbe4f7703fd45e371ab78d7e76b0660ee19c47f183c760bcdba41d58bb6929
-  data.tar.gz: 2e97b19dfee548042488c16d4d37ddcdf5adf3959de7cd90d076e29c667021f2c07aec603eb8d6d0316ce944a027b55da9ca13f2adf3bc1647dac38b16316c0c
+  metadata.gz: 78959db170082e7264a3657dec0ff1e21ebf496a2e2603fe98ca6a7b263f68f980456df3f2881d798f2a8e7a296902700b2dc4e155a9ef43f54a32df5ca75eb7
+  data.tar.gz: 565be0a187d2651d92d43e59351090e0d6623dff13d70bbd1747e5c35f5167f162a4182c111e265734eadbc9aa465be003d5704da61495af281b321036eb0f26

data/CHANGELOG.md

@@ -5,6 +5,40 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-07-06
+
+- Terminal events are loop-owned: each attempt's :done or :error is held at
+  a gate and only the accepted attempt's terminal reaches the subscriber. A
+  transient failure that retries and recovers no longer shows the host an
+  error it then walks back, and repeated empty completions no longer emit a
+  :done per attempt.
+- The :retry event carries structure: attempt, max_attempts, and delay ride
+  the event (and its wire form), so a sink can render "Retrying (2/3) in
+  1.3s" without parsing prose. The prose note stays as content. The event
+  no longer carries a stop reason, because a retry is not a stop.
+- RetryPolicy owns attempt classification: error_for(message) returns the
+  provider's error or a synthesized EmptyCompletion for a blank answer.
+  RetryPolicy::EMPTY_COMPLETION replaces the agent-internal constant.
+- The MCP client advertises protocol 2025-11-25, the current spec revision
+  it already negotiated.
+- README: the :retry event and the terminal-events invariant are documented
+  in the reliability section; the MCP section documents eager listing,
+  refresh:, and the duplicate-name raise at Agent.new.
+
+## [0.4.0] - 2026-07-05
+
+- Mistri::Definition: agents as frontmatter markdown files. Config in
+  YAML, prompt in the body, {placeholders} filled at build time and
+  unfilled ones raise. Tool names and extra keys stay the host's
+  vocabulary.
+- Agent context: Mistri.agent(context: anything) rides the run and reaches
+  every tool handler and hook as context.app, untouched.
+- Content::Image.from_data_uri accepts base64 data: URIs directly.
+
+- OpenAI reasoning summaries keep their paragraph structure: a reasoning
+  item's summary parts join with a blank line, and the boundary streams as
+  a thinking delta, so live views match the finished text.
+
 ## [0.3.0] - 2026-07-05
 
 - Sessions heal at replay: a run killed mid-tool (deploy, crash) leaves

data/README.md

@@ -12,7 +12,7 @@
 <p align="center">
   <a href="https://rubygems.org/gems/mistri"><img alt="Gem Version" src="https://img.shields.io/gem/v/mistri"></a>
   <a href="https://github.com/mcheemaa/mistri/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/mcheemaa/mistri/actions/workflows/ci.yml/badge.svg"></a>
-  <a href="https://codecov.io/gh/mcheemaa/mistri"><img alt="Coverage" src="https://codecov.io/gh/mcheemaa/mistri/graph/badge.svg"></a>
+  <a href="https://codecov.io/gh/mcheemaa/mistri"><img alt="Coverage" src="https://img.shields.io/codecov/c/github/mcheemaa/mistri"></a>
   <a href="mistri.gemspec"><img alt="Ruby >= 3.2" src="https://img.shields.io/badge/ruby-%3E%3D%203.2-CC342D"></a>
   <a href="Gemfile"><img alt="Runtime dependencies: zero" src="https://img.shields.io/badge/runtime_deps-0-brightgreen"></a>
   <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
@@ -102,6 +102,20 @@ Mistri::Tool.define("edit_page", "Applies a page edit.") do |args|
 end
 ```
 
+Handlers and hooks can take the run's context as a second argument, and
+`context.app` carries whatever object you pass as `Mistri.agent(context:)`
+— the acting user, a tenant, a request — so tools stay authorization-aware
+without closure gymnastics:
+
+```ruby
+agent = Mistri.agent("claude-opus-4-8", tools: tools,
+                     context: { traveler: current_traveler })
+
+Mistri::Tool.define("book_hotel", "Books the chosen hotel.") do |args, context|
+  Bookings.create!(args, traveler: context.app[:traveler])
+end
+```
+
 ## Human approval
 
 Mark a tool `needs_approval: true` (or a predicate on its arguments) and the
@@ -110,12 +124,12 @@ The decision is a one-line session write from any process, any time later;
 `resume` settles it and carries on.
 
 ```ruby
-send_gift = Mistri::Tool.define("send_gift", "Sends a real gift.",
-                                needs_approval: ->(args) { args["amount"].to_i > 100 }) do |args|
-  Gifts.send!(args)
+book_hotel = Mistri::Tool.define("book_hotel", "Books the chosen hotel.",
+                                 needs_approval: ->(args) { args["total_usd"].to_i > 500 }) do |args|
+  Bookings.create!(args)
 end
 
-result = agent.run("Send Ana a $200 gift")
+result = agent.run("Book the corner suite for the Lisbon trip")
 result.awaiting_approval?   # => true; nothing executed
 
 # Days later, in a controller:
@@ -215,6 +229,20 @@ A skill is a `SKILL.md` (or flat `.md`) with `name:`/`description:`
 frontmatter, or built from database rows with
 `Mistri::Skill.new(name:, description:, body:)`.
 
+## Definitions
+
+An agent as a markdown file: YAML frontmatter for config, the body as the
+prompt, `{placeholders}` filled at build time (unfilled ones raise). Tool
+names and any extra keys stay your vocabulary; the gem only reads the
+file.
+
+```ruby
+definition = Mistri::Definition.load("app/agents/trip_planner.md")
+agent = Mistri.agent(definition.model,
+                     system: definition.render(first_name: traveler.first_name),
+                     tools: registry.build(definition.tools, traveler))
+```
+
 ## Sub-agents
 
 Delegate to a child agent with a clean context: exploration fills the
@@ -276,6 +304,12 @@ tools = Mistri::MCP.tools(client, prefix: "linear",
 agent = Mistri.agent("claude-opus-4-8", tools: tools)
 ```
 
+The bridge lists the server's tools once, at build time; `client.tools(refresh: true)`
+re-lists when a host wants a changed toolset. `prefix:` namespaces local
+names (`linear__create_issue`) because duplicate tool names raise at
+`Agent.new`: collisions fail loud instead of one server's tool silently
+shadowing another's.
+
 Local stdio servers spawn as child processes, credentials in their
 environment. That is also the whole "give the agent a browser" story:
 
@@ -341,10 +375,28 @@ budget = Mistri::Budget.new(turns: 20, cost_usd: 2.00)
 policy = Mistri::RetryPolicy.new(attempts: 3)
 ```
 
+Retries are invisible to the model but not to your UI: each backoff emits a
+`:retry` event carrying `attempt`, `max_attempts`, and `delay`, so a sink can
+show a live "reconnecting" state instead of a silent spinner. Terminal events
+are loop-owned: `:done` and `:error` reach the subscriber only for the
+accepted attempt, so a recovered retry never flashes an error it then walks
+back.
+
+```ruby
+agent.run("Plan the itinerary.") do |event|
+  case event.type
+  when :text_delta then stream(event.delta)
+  when :retry then banner("Retrying (#{event.attempt}/#{event.max_attempts}) in #{event.delay}s")
+  when :done, :error then clear_banner
+  end
+end
+```
+
 ## Images and provider options
 
 ```ruby
 photo = Mistri::Content::Image.from_bytes(File.binread("chart.png"), mime_type: "image/png")
+photo = Mistri::Content::Image.from_data_uri(params[:image])   # canvases and uploads
 agent.run("What trend does this chart show?", images: [photo])
 
 Mistri.agent("gpt-5.5", provider_options: { reasoning: { effort: "high" } })

data/lib/mistri/agent.rb

@@ -30,7 +30,8 @@ module Mistri
     # return a replacement result, or nil to keep the original.
     def initialize(provider:, session: nil, system: nil, tools: [], budget: nil,
                    max_concurrency: 4, transform_context: nil, compaction: Compaction.new,
-                   retries: RetryPolicy.new, skills: [], before_tool: nil, after_tool: nil)
+                   retries: RetryPolicy.new, skills: [], before_tool: nil, after_tool: nil,
+                   context: nil)
       @provider = provider
       @session = session || Session.new(store: Stores::Memory.new)
       skills = skills.is_a?(String) ? Skills.load(skills) : Array(skills)
@@ -46,16 +47,11 @@ module Mistri
       @retries = retries || nil
       @before_tool = before_tool
       @after_tool = after_tool
+      @context = context
     end
 
     attr_reader :session
 
-    # What retries see when a completion answers nothing at all.
-    EMPTY_COMPLETION_ERROR = {
-      "type" => "EmptyCompletion",
-      "message" => "the provider returned an empty completion"
-    }.freeze
-
     # Run one exchange: append the user turn, then loop until the model
     # answers without tools, a gated tool suspends the run, the run aborts,
     # or a budget stops it.
@@ -64,10 +60,12 @@ module Mistri
     # on top; run alone does not validate.
     def run(input, images: [], signal: nil, output_schema: nil, &emit)
       if @session.open_approvals.any?
-        raise ConfigurationError, "session is awaiting approval decisions; call resume"
+        raise ConfigurationError,
+              "session is awaiting approvals; call resume"
       end
       if input.to_s.empty? && Array(images).empty?
-        raise ArgumentError, "run needs input text or images"
+        raise ArgumentError,
+              "run needs input text or images"
       end
 
       fold_steers # steers queued while idle arrived first; keep that order
@@ -206,44 +204,35 @@ module Mistri
     # the request.
     #
     # A transient failure retries the same request with backoff; the failed
-    # attempt is recorded as a retry entry, never as a message, so retries
-    # stay invisible to the model. Only the final outcome persists.
+    # attempt records as a retry entry, never as a message, and its terminal
+    # (:done or :error) holds at a gate, so retries stay invisible to the
+    # model and a recovered retry never shows the subscriber an error it
+    # walks back. Only the accepted attempt persists and terminates.
     def run_turn(signal, output_schema = nil, &emit)
       history = @transform_context.reduce(@session.messages) do |messages, transform|
         transform.call(messages)
       end
       attempt = 0
       loop do
+        held = nil
+        gate = emit && ->(event) { event.terminal? ? held = event : emit.call(event) }
         message = @provider.stream(messages: history, system: @system,
                                    tools: @tools.map(&:spec), signal: signal,
-                                   output_schema: output_schema, &emit)
+                                   output_schema: output_schema, &gate)
         attempt += 1
-        error = turn_error(message)
+        error = @retries&.error_for(message)
         if retry_turn?(error, attempt, signal)
           pause = @retries.delay(attempt, error["retry_after"])
           record_retry(message, error, attempt, pause, &emit)
           wait(pause, signal)
           next unless signal&.aborted?
         end
+        emit&.call(held) if held
         @session.append_message(message)
         return message
       end
     end
 
-    # The provider's own error when the turn failed, or a synthesized one
-    # for a completion that answers nothing: providers intermittently stop
-    # with an empty candidate, and a retry usually clears it.
-    def turn_error(message)
-      return message.error if message.stop_reason == StopReason::ERROR
-
-      EMPTY_COMPLETION_ERROR if empty_completion?(message)
-    end
-
-    def empty_completion?(message)
-      message.stop_reason == StopReason::STOP &&
-        message.content.all? { |block| block.is_a?(Content::Text) && block.text.to_s.strip.empty? }
-    end
-
     def retry_turn?(error, attempt, signal)
       return false unless @retries && error
       return false if signal&.aborted?
@@ -256,7 +245,8 @@ module Mistri
                                "delay" => pause.round(2))
       note = format("attempt %<attempt>d failed; retrying in %<pause>.1fs",
                     attempt: attempt, pause: pause)
-      emit&.call(Event.new(type: :retry, content: note, reason: StopReason::ERROR,
+      emit&.call(Event.new(type: :retry, content: note, attempt: attempt,
+                           max_attempts: @retries.attempts, delay: pause.round(2),
                            message: message))
     end
 
@@ -302,7 +292,8 @@ module Mistri
 
       results = ToolExecutor.call(calls, @tools_by_name, signal: signal,
                                                          max_concurrency: @max_concurrency,
-                                                         session: @session, emit: emit)
+                                                         session: @session, emit: emit,
+                                                         app: @context)
       context = hook_context(signal, emit)
       results.each do |call, result, seconds|
         result = rewrite(call, result, context) if @after_tool
@@ -337,7 +328,7 @@ module Mistri
     end
 
     def hook_context(signal, emit)
-      ToolContext.new(session: @session, signal: signal, emit: emit)
+      ToolContext.new(session: @session, signal: signal, emit: emit, app: @context)
     end
 
     # The tool message carries both channels; the :tool_result event exposes

data/lib/mistri/content.rb

@@ -50,6 +50,15 @@ module Mistri
       # second copy of what can be a multi-megabyte payload.
       def self.from_bytes(bytes, mime_type:) = new(data: [bytes.b].pack("m0").freeze, mime_type:)
 
+      # Browsers, canvases, and upload pipelines hand images around as
+      # data: URIs; accept them directly.
+      def self.from_data_uri(uri)
+        match = /\Adata:(?<mime>[^;,]+);base64,(?<data>.+)\z/m.match(uri.to_s)
+        raise ArgumentError, "not a base64 data: URI" unless match
+
+        new(data: match[:data].delete("\n").freeze, mime_type: match[:mime])
+      end
+
       def initialize(data:, mime_type:)
         super(data: Content.freeze_string(data), mime_type: Content.freeze_string(mime_type))
       end

data/lib/mistri/definition.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Mistri
+  # An agent definition: a markdown file whose YAML frontmatter carries the
+  # config and whose body is the prompt. Prompts stay editable prose in
+  # files a reviewer can diff; code stays out of them.
+  #
+  #   ---
+  #   role: Trip Planner
+  #   model: claude-opus-4-8
+  #   tools:
+  #     - search_flights
+  #     - book_hotel
+  #   ---
+  #   You plan trips end to end. Address the traveler as {first_name}.
+  #
+  #   definition = Mistri::Definition.load("app/agents/trip_planner.md")
+  #   agent = Mistri.agent(definition.model,
+  #                        system: definition.render(first_name: traveler.first_name),
+  #                        tools: registry.build(definition.tools, traveler))
+  #
+  # The gem reads the file; what tool names mean, and what any extra
+  # frontmatter keys mean, stays the host's vocabulary via #config.
+  class Definition
+    FRONTMATTER = /\A---\s*\n(?<yaml>.*?)\n---\s*\n(?<body>.*)\z/m
+
+    attr_reader :name, :body, :config
+
+    def self.load(path)
+      match = FRONTMATTER.match(File.read(path))
+      raise ConfigurationError, "#{path} has no frontmatter" unless match
+
+      config = YAML.safe_load(match[:yaml]) || {}
+      raise ConfigurationError, "#{path} frontmatter is not a mapping" unless config.is_a?(Hash)
+
+      new(name: File.basename(path.to_s, ".md"), config: config, body: match[:body].strip)
+    end
+
+    def initialize(name:, config:, body:)
+      @name = name.to_s
+      @config = config.freeze
+      @body = body
+      freeze
+    end
+
+    def model = config["model"]
+
+    def role = config["role"]
+
+    # Tool declarations as a name => options map. A bare list means no
+    # options; a map form carries per-tool options in the host's
+    # vocabulary (gates, caching, whatever the host honors).
+    def tools
+      raw = config["tools"]
+      entries = case raw
+                when Hash then raw.transform_values { |options| options || {} }
+                when Array then raw.to_h { |tool| [tool, {}] }
+                else {}
+                end
+      entries.transform_keys(&:to_s)
+    end
+
+    def tool_names = tools.keys
+
+    # The body with {placeholders} filled in. An unfilled placeholder
+    # raises: a prompt silently addressing "{first_name}" is worse than an
+    # error. A value of nil renders as empty, which lets optional context
+    # collapse cleanly.
+    def render(vars = {})
+      vars = vars.transform_keys(&:to_s)
+      body.gsub(/\{(\w+)\}/) do
+        vars.fetch(Regexp.last_match(1)) do |key|
+          raise ConfigurationError, "no value for {#{key}} in the #{name} definition"
+        end
+      end
+    end
+  end
+end

data/lib/mistri/event.rb

@@ -15,11 +15,14 @@ module Mistri
   # events; nil where nothing ran (denials, interruptions).
   class Event < Data.define(:type, :content_index, :delta, :content, :tool_call,
                             :reason, :message, :error_message, :partial, :origin,
-                            :duration)
+                            :duration, :attempt, :max_attempts, :delay)
     # The stream types come from a provider mid-turn; the loop adds
     # :tool_result after it runs each tool, :approval_needed when a gated
-    # call parks for a human, and :compacting/:compaction around a context
-    # compaction, so one subscription sees the whole exchange.
+    # call parks for a human, :compacting/:compaction around a context
+    # compaction, and :retry (with attempt, max_attempts, delay) before it
+    # waits out a transient failure, so one subscription sees the whole
+    # exchange. :done and :error are loop-owned and terminal: only the
+    # accepted attempt's terminal event reaches the subscriber.
     TYPES = %i[
       start
       text_start text_delta text_end
@@ -33,7 +36,7 @@ module Mistri
 
     def initialize(type:, content_index: nil, delta: nil, content: nil, tool_call: nil,
                    reason: nil, message: nil, error_message: nil, partial: nil, origin: nil,
-                   duration: nil)
+                   duration: nil, attempt: nil, max_attempts: nil, delay: nil)
       raise ArgumentError, "unknown event type #{type.inspect}" unless TYPES.include?(type)
 
       super
@@ -48,7 +51,8 @@ module Mistri
     # Partials are ephemeral streaming state and stay out of serialization.
     def to_h
       { type:, content_index:, delta:, content:, tool_call: tool_call&.to_h,
-        reason:, message: message&.to_h, error_message:, origin:, duration: }.compact
+        reason:, message: message&.to_h, error_message:, origin:, duration:,
+        attempt:, max_attempts:, delay: }.compact
     end
   end
 end

data/lib/mistri/mcp/client.rb

@@ -24,7 +24,7 @@ module Mistri
     # One client serializes its calls; parallel tool calls against one
     # server queue rather than interleave.
     class Client
-      PROTOCOL_VERSION = "2025-06-18"
+      PROTOCOL_VERSION = "2025-11-25"
       SUPPORTED_VERSIONS = %w[2025-11-25 2025-06-18 2025-03-26 2024-11-05].freeze
       LOOPBACK = %w[localhost 127.0.0.1 ::1].freeze
 

data/lib/mistri/providers/openai/assembler.rb

@@ -25,7 +25,8 @@ module Mistri
           case record["type"]
           when "response.output_item.added" then start_item(record["item"], &)
           when "response.output_text.delta" then text_delta(record["delta"], &)
-          when "response.reasoning_summary_text.delta" then thinking_delta(record["delta"], &)
+          when "response.reasoning_summary_text.delta"
+            thinking_delta(record["delta"], record["summary_index"], &)
           when "response.function_call_arguments.delta" then arguments_delta(record["delta"], &)
           when "response.output_item.done" then finish_item(record["item"], &)
           when "response.completed", "response.incomplete", "response.failed"
@@ -83,6 +84,7 @@ module Mistri
           return unless kind
 
           @current = Builder.new(kind, @blocks.size, +"", +"")
+          @summary_part = nil
           emit_event(:"#{kind}_start", content_index: @current.index, &)
         end
 
@@ -93,9 +95,17 @@ module Mistri
           emit_event(:text_delta, content_index: @current.index, delta: delta, &)
         end
 
-        def thinking_delta(delta, &)
+        # A reasoning item carries one or more summary parts, each its own
+        # paragraph; the boundary streams as a delta so live views keep the
+        # break the finished text will have.
+        def thinking_delta(delta, part, &)
           return unless @current
 
+          if @summary_part && part && part != @summary_part
+            @current.text << "\n\n"
+            emit_event(:thinking_delta, content_index: @current.index, delta: "\n\n", &)
+          end
+          @summary_part = part if part
           @current.text << delta.to_s
           emit_event(:thinking_delta, content_index: @current.index, delta: delta, &)
         end
@@ -131,7 +141,7 @@ module Mistri
             text = Array(item["content"]).filter_map { |part| part["text"] }.join
             Content::Text.new(text: text, signature: item["id"])
           when :thinking
-            summary = Array(item["summary"]).filter_map { |part| part["text"] }.join
+            summary = Array(item["summary"]).filter_map { |part| part["text"] }.join("\n\n")
             Content::Thinking.new(thinking: summary, signature: JSON.generate(item))
           when :toolcall
             ToolCall.new(id: item["call_id"], name: item["name"],

data/lib/mistri/retry_policy.rb

@@ -21,10 +21,25 @@ module Mistri
       @max_delay = max_delay
     end
 
+    # What retries see when a completion answers nothing at all.
+    EMPTY_COMPLETION = {
+      "type" => "EmptyCompletion",
+      "message" => "the provider returned an empty completion"
+    }.freeze
+
     def retry?(error, attempt)
       attempt <= attempts && retryable?(error)
     end
 
+    # The error a finished attempt carries: the provider's own error, or a
+    # synthesized one for a completion that answers nothing at all, which a
+    # retry usually clears.
+    def error_for(message)
+      return message.error if message.stop_reason == StopReason::ERROR
+
+      EMPTY_COMPLETION if empty?(message)
+    end
+
     # error is the ErrorData hash from an errored message. A status decides
     # when present; otherwise only known-transient types retry, so schema
     # violations and host bugs never loop.
@@ -43,5 +58,12 @@ module Mistri
       exponential = base * (2**(attempt - 1))
       (exponential * rand(0.5..1.0)).clamp(0.0, max_delay)
     end
+
+    private
+
+    def empty?(message)
+      message.stop_reason == StopReason::STOP &&
+        message.content.all? { |block| block.is_a?(Content::Text) && block.text.to_s.strip.empty? }
+    end
   end
 end

data/lib/mistri/tool_context.rb

@@ -2,13 +2,24 @@
 
 module Mistri
   # What a tool handler may know about the run it executes inside: the
-  # caller's session, the abort signal, and the event stream. Handlers take
-  # it as an optional second argument — a proc ignores it invisibly, a
-  # lambda opts in by accepting two parameters. Sub-agents are built on it;
-  # any tool that spawns work, links records to the session, or streams
-  # progress can use it the same way.
-  ToolContext = Data.define(:session, :signal, :emit) do
-    def initialize(session: nil, signal: nil, emit: nil)
+  # caller's session, the abort signal, the event stream, and the host's
+  # own context object. Handlers take it as an optional second argument — a
+  # proc ignores it invisibly, a lambda opts in by accepting two
+  # parameters. Sub-agents are built on it; any tool that spawns work,
+  # links records to the session, or streams progress can use it the same
+  # way.
+  #
+  # app carries whatever the host passes as Agent.new(context:) — the
+  # acting user, a tenant, a request — untouched. The gem provides the
+  # slot, never the vocabulary:
+  #
+  #   agent = Mistri.agent("claude-opus-4-8", tools: tools,
+  #                        context: { traveler: current_traveler })
+  #   Mistri::Tool.define("book_hotel", "Books the chosen hotel.") do |args, context|
+  #     Bookings.create(args, traveler: context.app[:traveler])
+  #   end
+  ToolContext = Data.define(:session, :signal, :emit, :app) do
+    def initialize(session: nil, signal: nil, emit: nil, app: nil)
       super
     end
   end

data/lib/mistri/tool_executor.rb

@@ -16,10 +16,12 @@ module Mistri
 
     module_function
 
-    def call(calls, tools_by_name, signal: nil, max_concurrency: 4, session: nil, emit: nil)
+    def call(calls, tools_by_name, signal: nil, max_concurrency: 4, session: nil, emit: nil,
+             app: nil)
       return [] if calls.empty?
 
-      context = ToolContext.new(session: session, signal: signal, emit: thread_safe(emit))
+      context = ToolContext.new(session: session, signal: signal, emit: thread_safe(emit),
+                                app: app)
       results = Array.new(calls.length)
       queue = Queue.new
       calls.each_with_index { |call, index| queue << [call, index] }

data/lib/mistri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mistri
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/mistri.rb

@@ -23,6 +23,7 @@ require_relative "mistri/workspace/directory"
 require_relative "mistri/workspace/single"
 require_relative "mistri/memory"
 require_relative "mistri/tools"
+require_relative "mistri/definition"
 require_relative "mistri/skill"
 require_relative "mistri/skills"
 require_relative "mistri/tool_executor"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mistri
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Muhammad Ahmed Cheema
@@ -34,6 +34,7 @@ files:
 - lib/mistri/compaction.rb
 - lib/mistri/compactor.rb
 - lib/mistri/content.rb
+- lib/mistri/definition.rb
 - lib/mistri/edit.rb
 - lib/mistri/errors.rb
 - lib/mistri/event.rb