igniter 0.4.3 → 0.5.0

data/lib/igniter/integrations/llm/transcription/providers/openai.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Igniter
+  module LLM
+    module Transcription
+      module Providers
+        # OpenAI Whisper transcription provider.
+        #
+        # API: POST /v1/audio/transcriptions (multipart/form-data)
+        # Docs: https://platform.openai.com/docs/api-reference/audio
+        #
+        # Limitations vs other providers:
+        #   - No speaker diarization (speakers will be nil in result)
+        #   - 20 MB file size limit
+        #   - Only word-level granularity (no sentence-level)
+        #
+        # Extra options passed through:
+        #   prompt:          String  — context hint to guide spelling/vocabulary
+        #   response_format: Symbol  — :srt or :vtt stores raw subtitles in result.raw[:subtitle_text]
+        class OpenAI < Base
+          API_BASE = "https://api.openai.com"
+
+          def initialize(api_key: ENV["OPENAI_API_KEY"], base_url: API_BASE, timeout: 120)
+            super()
+            @api_key  = api_key
+            @base_url = base_url.to_s.chomp("/")
+            @timeout  = timeout
+          end
+
+          def transcribe(audio_source, model:, language: nil, _diarize: false, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
+                         word_timestamps: true, **options)
+            validate_api_key!
+
+            audio = read_audio(audio_source)
+            fname = filename_from(audio_source)
+            ctype = audio_content_type(fname)
+
+            fields = {
+              "file" => { data: audio, filename: fname, content_type: ctype },
+              "model" => model,
+              "response_format" => "verbose_json"
+            }
+            fields["language"] = language if language
+            fields["prompt"]   = options[:prompt] if options[:prompt]
+            # Request word-level timestamps
+            fields["timestamp_granularities[]"] = "word" if word_timestamps
+
+            body, boundary = build_multipart(fields)
+            raw = post_multipart("/v1/audio/transcriptions", body, boundary)
+            build_result(raw, model: model)
+          end
+
+          private
+
+          def build_result(raw, model:) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+            words = (raw["words"] || []).map do |w|
+              TranscriptWord.new(
+                word: w["word"].to_s.strip,
+                start_time: w["start"].to_f,
+                end_time: w["end"].to_f,
+                confidence: w["confidence"]&.to_f,
+                speaker: nil # Whisper has no diarization
+              )
+            end
+
+            TranscriptResult.new(
+              text: raw["text"].to_s,
+              words: words,
+              speakers: nil,
+              language: raw["language"],
+              duration: raw["duration"]&.to_f,
+              provider: :openai,
+              model: model,
+              raw: raw
+            )
+          end
+
+          def post_multipart(path, body, boundary)
+            uri  = URI.parse("#{@base_url}#{path}")
+            http = http_for(uri)
+
+            request = Net::HTTP::Post.new(uri.path)
+            request["Authorization"] = "Bearer #{@api_key}"
+            request["Content-Type"]  = "multipart/form-data; boundary=#{boundary}"
+            request.body             = body
+
+            handle_response(http.request(request))
+          rescue Errno::ECONNREFUSED, SocketError, Net::OpenTimeout => e
+            raise Igniter::LLM::ProviderError, "Cannot connect to OpenAI API: #{e.message}"
+          end
+
+          def validate_api_key!
+            return if @api_key && !@api_key.empty?
+
+            raise Igniter::LLM::ConfigurationError,
+                  "OpenAI API key not configured. Set OPENAI_API_KEY or pass api_key: to the provider."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/integrations/llm/transcription/transcriber.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Igniter
+  module LLM
+    # Base class for audio transcription executors.
+    #
+    # A Transcriber is a fully-fledged Igniter::Executor — it can be used as a
+    # compute node in a Contract graph, paired with cache_ttl:, and composed
+    # with downstream LLM::Executor skills:
+    #
+    #   class CallTranscriber < Igniter::LLM::Transcriber
+    #     transcription_provider :deepgram
+    #     model "nova-3"
+    #     language "ru"
+    #     diarize true
+    #
+    #     def call(audio_path:)
+    #       transcribe(audio_path)
+    #     end
+    #   end
+    #
+    #   # Standalone
+    #   result = CallTranscriber.call(audio_path: "call_123.mp3")
+    #   result.text          # => "Добрый день, чем могу помочь?"
+    #   result.speakers      # => [#<SpeakerSegment speaker=0 ...>, ...]
+    #
+    #   # Inside a Contract graph
+    #   compute :transcript, call: CallTranscriber, with: :audio_path, cache_ttl: 3600
+    class Transcriber < Igniter::Executor
+      PROVIDERS = %i[openai deepgram assemblyai].freeze
+      DEFAULT_MODELS = { openai: "whisper-1", deepgram: "nova-3", assemblyai: "universal-2" }.freeze
+
+      class << self
+        def inherited(subclass)
+          super
+          TRANSCRIBER_IVARS.each do |ivar|
+            subclass.instance_variable_set(ivar, instance_variable_get(ivar))
+          end
+        end
+
+        # ── Provider DSL ───────────────────────────────────────────────────
+
+        def transcription_provider(name = nil)
+          return @transcription_provider if name.nil?
+
+          name = name.to_sym
+          unless PROVIDERS.include?(name)
+            raise ArgumentError, "Unknown transcription provider #{name.inspect}. Available: #{PROVIDERS.inspect}"
+          end
+
+          @transcription_provider = name
+        end
+
+        def model(name = nil)
+          return @transcription_model if name.nil?
+
+          @transcription_model = name.to_s
+        end
+
+        def language(lang = nil)
+          return @language if lang.nil?
+
+          @language = lang.to_s
+        end
+
+        def diarize(bool = nil)
+          return @diarize.nil? ? false : @diarize if bool.nil?
+
+          @diarize = bool
+        end
+        alias diarize? diarize
+
+        def word_timestamps(bool = nil)
+          return @word_timestamps.nil? || @word_timestamps if bool.nil?
+
+          @word_timestamps = bool
+        end
+
+        # ── Polling DSL (AssemblyAI) ───────────────────────────────────────
+
+        # Seconds between poll attempts (uses exponential backoff up to 30s).
+        def poll_interval(secs = nil)
+          return @poll_interval || 2 if secs.nil?
+
+          @poll_interval = secs.to_f
+        end
+
+        # Maximum total seconds to wait for async transcription.
+        def poll_timeout(secs = nil)
+          return @poll_timeout || 300 if secs.nil?
+
+          @poll_timeout = secs.to_f
+        end
+      end
+
+      # All instance variables the DSL manages — copied in inherited hook.
+      TRANSCRIBER_IVARS = %i[
+        @transcription_provider @transcription_model @language
+        @diarize @word_timestamps @poll_interval @poll_timeout
+      ].freeze
+      private_constant :TRANSCRIBER_IVARS
+
+      protected
+
+      # Transcribe audio and return a TranscriptResult.
+      # Call this from your #call implementation.
+      #
+      # @param audio_source [String, Pathname, IO] File path or IO object.
+      # @param options [Hash] Provider-specific extras forwarded verbatim.
+      # @return [Transcription::TranscriptResult]
+      def transcribe(audio_source, **options)
+        provider_instance.transcribe(
+          audio_source,
+          model: current_model,
+          language: self.class.language,
+          diarize: self.class.diarize?,
+          word_timestamps: self.class.word_timestamps,
+          poll_interval: self.class.poll_interval,
+          poll_timeout: self.class.poll_timeout,
+          **options
+        )
+      end
+
+      private
+
+      def provider_instance
+        pname = self.class.transcription_provider
+        unless pname
+          raise Igniter::LLM::ConfigurationError,
+                "#{self.class.name}: transcription_provider not configured. " \
+                "Call transcription_provider :openai, :deepgram, or :assemblyai in your class."
+        end
+
+        @provider_instance ||= Igniter::LLM.transcription_provider_instance(pname)
+      end
+
+      def current_model
+        self.class.model ||
+          Transcriber::DEFAULT_MODELS[self.class.transcription_provider] ||
+          raise(Igniter::LLM::ConfigurationError,
+                "No model configured for provider #{self.class.transcription_provider}")
+      end
+    end
+  end
+end

data/lib/igniter/integrations/llm/transcription/transcript_result.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Igniter
+  module LLM
+    module Transcription
+      # Single word with timing and optional speaker label.
+      # end_time is used instead of `end` to avoid the Ruby keyword conflict.
+      TranscriptWord = Struct.new(:word, :start_time, :end_time, :confidence, :speaker, keyword_init: true)
+
+      # A contiguous block of speech from one speaker.
+      SpeakerSegment = Struct.new(:speaker, :start_time, :end_time, :text, keyword_init: true)
+
+      # Normalised result returned by every Transcription provider.
+      #
+      # @attr text      [String]                   Full transcript text.
+      # @attr words     [Array<TranscriptWord>]     Word-level timestamps (empty Array if not requested).
+      # @attr speakers  [Array<SpeakerSegment>, nil] Speaker segments or nil when diarization was not requested.
+      # @attr language  [String, nil]               BCP-47 language code detected/specified (e.g. "en", "ru").
+      # @attr duration  [Float, nil]                Audio duration in seconds.
+      # @attr provider  [Symbol]                    Provider used (:openai, :deepgram, :assemblyai).
+      # @attr model     [String]                    Model string (e.g. "whisper-1", "nova-3").
+      # @attr raw       [Hash]                      Original provider response — provider-specific extras live here.
+      TranscriptResult = Struct.new(
+        :text, :words, :speakers, :language, :duration, :provider, :model, :raw,
+        keyword_init: true
+      )
+    end
+  end
+end

data/lib/igniter/integrations/llm.rb

@@ -8,6 +8,12 @@ require_relative "llm/providers/ollama"
 require_relative "llm/providers/anthropic"
 require_relative "llm/providers/openai"
 require_relative "llm/executor"
+require_relative "llm/transcription/transcript_result"
+require_relative "llm/transcription/providers/base"
+require_relative "llm/transcription/providers/openai"
+require_relative "llm/transcription/providers/deepgram"
+require_relative "llm/transcription/providers/assemblyai"
+require_relative "llm/transcription/transcriber"
 
 module Igniter
   module LLM
@@ -32,14 +38,21 @@ module Igniter
         @provider_instances[name.to_sym] ||= build_provider(name.to_sym)
       end
 
+      # Returns a memoized transcription provider instance.
+      def transcription_provider_instance(name)
+        @transcription_provider_instances ||= {}
+        @transcription_provider_instances[name.to_sym] ||= build_transcription_provider(name.to_sym)
+      end
+
       # Reset cached provider instances (useful after reconfiguration).
       def reset_providers!
         @provider_instances = nil
+        @transcription_provider_instances = nil
       end
 
       private
 
-      def build_provider(name)
+      def build_provider(name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         case name
         when :ollama
           cfg = config.ollama
@@ -54,6 +67,29 @@ module Igniter
           raise ConfigurationError, "Unknown LLM provider: #{name}. Available: #{AVAILABLE_PROVIDERS.inspect}"
         end
       end
+
+      def build_transcription_provider(name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        case name
+        when :openai
+          cfg = config.openai
+          Transcription::Providers::OpenAI.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        when :deepgram
+          cfg = config.deepgram
+          Transcription::Providers::Deepgram.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        when :assemblyai
+          cfg = config.assemblyai
+          Transcription::Providers::AssemblyAI.new(
+            api_key: cfg.api_key,
+            base_url: cfg.base_url,
+            timeout: cfg.timeout,
+            poll_interval: cfg.poll_interval,
+            poll_timeout: cfg.poll_timeout
+          )
+        else
+          raise ConfigurationError,
+                "Unknown transcription provider: #{name}. Available: #{Config::TRANSCRIPTION_PROVIDERS.inspect}"
+        end
+      end
     end
   end
 end

data/lib/igniter/memory/agent_memory.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Memory
+    # Facade that pre-fills +agent_id+ on all Store operations.
+    #
+    # Callers interact with AgentMemory instead of the raw Store so they never
+    # have to pass +agent_id:+ explicitly. An optional +session_id+ groups
+    # episodes within a single interaction session.
+    #
+    # @example
+    #   store  = Igniter::Memory::Stores::InMemory.new
+    #   memory = Igniter::Memory::AgentMemory.new(store: store, agent_id: "MyAgent:1")
+    #
+    #   memory.record(type: :tool_call, content: "searched web for Ruby docs")
+    #   memory.recall(query: "Ruby")      # => [Episode, ...]
+    #   memory.remember(:user_tz, "UTC")
+    #   memory.facts                      # => { "user_tz" => Fact }
+    class AgentMemory
+      # @param store      [Store]         backing store implementation
+      # @param agent_id   [String]        identifier for this agent
+      # @param session_id [String, nil]   optional session grouping key
+      def initialize(store:, agent_id:, session_id: nil)
+        @store      = store
+        @agent_id   = agent_id
+        @session_id = session_id
+      end
+
+      # Record a new episode.
+      #
+      # @param type       [String, Symbol] category tag
+      # @param content    [String]         textual description of the event
+      # @param outcome    [String, nil]    result label, e.g. "success"/"failure"
+      # @param importance [Float]          relevance weight 0.0–1.0
+      # @return [Episode]
+      def record(type:, content:, outcome: nil, importance: 0.5)
+        @store.record(
+          agent_id: @agent_id,
+          type: type,
+          content: content,
+          session_id: @session_id,
+          outcome: outcome,
+          importance: importance
+        )
+      end
+
+      # Keyword-search episodes for this agent.
+      #
+      # @param query [String, nil] search term; nil returns most recent
+      # @param limit [Integer]     maximum results (default 10)
+      # @param type  [String, Symbol, nil] optional type filter
+      # @return [Array<Episode>]
+      def recall(query: nil, limit: 10, type: nil)
+        @store.retrieve(agent_id: @agent_id, query: query, limit: limit, type: type)
+      end
+
+      # Store or update a named fact.
+      #
+      # @param key        [String, Symbol]  fact name
+      # @param value      [Object]          fact value
+      # @param confidence [Float]           confidence score 0.0–1.0
+      # @return [Fact]
+      def remember(key, value, confidence: 1.0)
+        @store.store_fact(agent_id: @agent_id, key: key, value: value, confidence: confidence)
+      end
+
+      # Returns all stored facts for this agent.
+      #
+      # @return [Hash{String => Fact}]
+      def facts
+        @store.facts(agent_id: @agent_id)
+      end
+
+      # Returns recent episodes.
+      #
+      # @param last [Integer]              maximum episodes to return
+      # @param type [String, Symbol, nil]  optional type filter
+      # @return [Array<Episode>]
+      def recent(last: 20, type: nil)
+        @store.episodes(agent_id: @agent_id, last: last, type: type)
+      end
+
+      # Run a reflection cycle and record the result.
+      #
+      # @param current_system_prompt [String, nil] current prompt to compare against
+      # @return [ReflectionRecord]
+      def reflect(current_system_prompt: nil)
+        ReflectionCycle.new(store: @store).reflect(
+          agent_id: @agent_id,
+          current_system_prompt: current_system_prompt
+        )
+      end
+
+      # Check whether the agent should run a reflection cycle.
+      #
+      # Returns true when the recent failure rate exceeds the threshold.
+      #
+      # @return [Boolean]
+      def should_reflect?
+        ReflectionCycle.new(store: @store).should_reflect?(agent_id: @agent_id)
+      end
+    end
+  end
+end

data/lib/igniter/memory/episode.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Memory
+    # Immutable value object representing a single recorded event in agent history.
+    #
+    # @!attribute [r] id
+    #   @return [Integer] unique identifier within the store
+    # @!attribute [r] agent_id
+    #   @return [String] identifier of the agent that recorded this episode
+    # @!attribute [r] session_id
+    #   @return [String, nil] optional session grouping identifier
+    # @!attribute [r] ts
+    #   @return [Integer] Unix timestamp of when the episode was recorded
+    # @!attribute [r] type
+    #   @return [String, Symbol] category of the episode (e.g. :tool_call, :response)
+    # @!attribute [r] content
+    #   @return [String] textual description of what happened
+    # @!attribute [r] outcome
+    #   @return [String, nil] result descriptor, e.g. "success" or "failure"
+    # @!attribute [r] importance
+    #   @return [Float] relevance weight in [0.0, 1.0], default 0.5
+    Episode = Struct.new(
+      :id, :agent_id, :session_id, :ts,
+      :type, :content, :outcome, :importance,
+      keyword_init: true
+    )
+  end
+end

data/lib/igniter/memory/fact.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Memory
+    # Immutable value object representing a persisted learned fact for an agent.
+    #
+    # Facts represent stable knowledge extracted from experience, keyed by a
+    # string name and associated with a confidence score.
+    #
+    # @!attribute [r] id
+    #   @return [Integer] unique identifier within the store
+    # @!attribute [r] agent_id
+    #   @return [String] identifier of the agent that owns this fact
+    # @!attribute [r] key
+    #   @return [String] fact name (e.g. "user_timezone", "preferred_format")
+    # @!attribute [r] value
+    #   @return [Object] the fact's value
+    # @!attribute [r] confidence
+    #   @return [Float] confidence score in [0.0, 1.0], default 1.0
+    # @!attribute [r] updated_at
+    #   @return [Integer] Unix timestamp of last upsert
+    Fact = Struct.new(
+      :id, :agent_id, :key, :value, :confidence, :updated_at,
+      keyword_init: true
+    )
+  end
+end

data/lib/igniter/memory/memorable.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Memory
+    # Mixin that adds episodic memory capabilities to Igniter::Agent and
+    # Igniter::LLM::Executor subclasses (or any class that includes it).
+    #
+    # Including +Memorable+ adds:
+    # * A class-level +enable_memory+ DSL method for opt-in activation
+    # * A +memory+ instance accessor returning a bound AgentMemory facade
+    # * Automatic agent_id derived from the class name and object_id
+    #
+    # Memory is NOT enabled by default — call +enable_memory+ in the class body.
+    #
+    # == Example
+    #
+    #   class MyAgent < Igniter::Agent
+    #     include Igniter::Memory::Memorable
+    #
+    #     enable_memory store: Igniter::Memory::Stores::InMemory.new
+    #
+    #     on :task do |state:, payload:, **|
+    #       memory.record(type: :task, content: payload[:description])
+    #       # ... handle task
+    #       state
+    #     end
+    #   end
+    #
+    # == Inheritance
+    #
+    # Subclasses inherit +memory_enabled?+ and +memory_store+ from their parent.
+    # Each subclass can override them independently.
+    module Memorable
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.instance_variable_set(:@memory_store, nil)
+        base.instance_variable_set(:@memory_enabled, false)
+      end
+
+      module ClassMethods
+        # Enable episodic memory for this class.
+        #
+        # @param store [Store, nil] backing store; falls back to Igniter::Memory.default_store
+        # @return [void]
+        def enable_memory(store: nil)
+          @memory_enabled = true
+          @memory_store   = store || Igniter::Memory.default_store
+        end
+
+        # Returns the configured memory store, walking up the inheritance chain
+        # if none is set on this class.
+        #
+        # @return [Store]
+        def memory_store
+          @memory_store ||
+            (superclass.respond_to?(:memory_store) ? superclass.memory_store : Igniter::Memory.default_store)
+        end
+
+        # Returns whether memory has been enabled for this class or any ancestor.
+        #
+        # @return [Boolean]
+        def memory_enabled?
+          @memory_enabled ||
+            (superclass.respond_to?(:memory_enabled?) && superclass.memory_enabled?)
+        end
+      end
+
+      # Returns the AgentMemory facade bound to this instance.
+      #
+      # Lazily initialised on first access. The agent_id incorporates the class
+      # name and object_id to keep instances isolated.
+      #
+      # @return [AgentMemory]
+      def memory
+        @memory ||= AgentMemory.new(
+          store: self.class.memory_store,
+          agent_id: memory_agent_id,
+          session_id: respond_to?(:session_id, true) ? session_id : nil
+        )
+      end
+
+      private
+
+      def memory_agent_id
+        cls_name = self.class.name || "anonymous"
+        "#{cls_name}:#{object_id}"
+      end
+    end
+  end
+end

data/lib/igniter/memory/reflection_cycle.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Memory
+    # Evaluates recent episodes and produces a ReflectionRecord.
+    #
+    # ReflectionCycle can operate in two modes:
+    #
+    # * **Rule-based** (default) — analyses failure rates using simple heuristics,
+    #   requiring no LLM. Always available.
+    # * **LLM-assisted** — delegates to an LLM executor for a richer summary and
+    #   an optional system-prompt patch. Enabled by passing an +llm:+ object.
+    #
+    # @example Rule-based reflection
+    #   cycle = Igniter::Memory::ReflectionCycle.new(store: store)
+    #   rec   = cycle.reflect(agent_id: "MyAgent:1")
+    #   # => ReflectionRecord (summary describes failure breakdown)
+    #
+    # @example With failure threshold check
+    #   cycle.should_reflect?(agent_id: "MyAgent:1")
+    #   # => true when recent failures >= DEFAULT_FAILURE_THRESHOLD
+    class ReflectionCycle
+      DEFAULT_FAILURE_THRESHOLD = 5
+      DEFAULT_WINDOW            = 50
+
+      # @param store             [Store]    backing episode store
+      # @param failure_threshold [Integer]  minimum failures to trigger reflection
+      # @param window            [Integer]  how many recent episodes to inspect
+      # @param llm               [#call, nil] optional LLM executor for smart reflection
+      def initialize(store:, failure_threshold: DEFAULT_FAILURE_THRESHOLD,
+                     window: DEFAULT_WINDOW, llm: nil)
+        @store             = store
+        @failure_threshold = failure_threshold
+        @window            = window
+        @llm               = llm
+      end
+
+      # Check whether a reflection cycle should be triggered.
+      #
+      # Returns true when the number of recent "failure" outcomes meets or
+      # exceeds the configured +failure_threshold+.
+      #
+      # @param agent_id [String]
+      # @return [Boolean]
+      def should_reflect?(agent_id:)
+        recent   = @store.episodes(agent_id: agent_id, last: @window)
+        failures = recent.count { |e| e.outcome == "failure" }
+        failures >= @failure_threshold
+      end
+
+      # Run a reflection cycle and persist the result.
+      #
+      # Analyses the most recent +window+ episodes and produces a
+      # ReflectionRecord with a summary (and optional system-prompt patch when
+      # an LLM is configured).
+      #
+      # @param agent_id              [String]
+      # @param current_system_prompt [String, nil] passed to the LLM if available
+      # @return [ReflectionRecord]
+      def reflect(agent_id:, current_system_prompt: nil) # rubocop:disable Metrics/MethodLength
+        recent = @store.episodes(agent_id: agent_id, last: @window)
+        summary, patch = if @llm
+                           smart_reflect(recent, current_system_prompt)
+                         else
+                           rule_based_reflect(recent)
+                         end
+
+        @store.record_reflection(
+          agent_id: agent_id,
+          summary: summary,
+          system_patch: patch
+        )
+      end
+
+      private
+
+      def rule_based_reflect(episodes) # rubocop:disable Metrics/CyclomaticComplexity
+        failures      = episodes.select { |e| e.outcome == "failure" }
+        failure_types = failures.group_by(&:type).transform_values(&:count)
+        top           = failure_types.max_by { |_, v| v }
+
+        summary = "#{failures.size}/#{episodes.size} failures. " \
+                  "Top failure type: #{top&.first || "none"} (#{top&.last || 0}\xc3\x97)"
+        [summary, nil]
+      end
+
+      def smart_reflect(episodes, current_system_prompt)
+        result = @llm.call(
+          episodes: episodes.map { |e| { type: e.type, content: e.content, outcome: e.outcome } },
+          current_system_prompt: current_system_prompt
+        )
+        [result[:summary], result[:system_patch]]
+      end
+    end
+  end
+end