phronomy 0.30.1 → 0.31.0

data/lib/phronomy/agent/base.rb

@@ -400,6 +400,31 @@ module Phronomy
         end
       end
 
+      # Materializes the current durable transcript as immutable Message values.
+      # Application authorization and presentation filtering remain caller-owned.
+      # @return [Array<LLMAdapter::Message>]
+      # @api public
+      def transcript_messages
+        _check_event_loop_reentrancy(:transcript_messages, :transcript_messages_async)
+        transcript_messages_async.wait_result
+      end
+
+      # Holds Agent ownership until the submitted read physically completes.
+      # @return [TaskResult<Array<LLMAdapter::Message>>]
+      # @api public
+      def transcript_messages_async
+        __with_operation(async: true, read_only: true) do
+          __execution_environment.submit(on_full: :raise) do
+            root, records = persistence.transaction do |tx|
+              current = tx.agents.load(agent_id)
+              [current, tx.journals.read(agent_id, limit: current.journal_position)]
+            end
+            RuntimeInput.new(agent: self, persistence: persistence)
+              .materialize_transcript(root: root, records: records)
+          end
+        end
+      end
+
       def clear_transcript!
         __with_operation do
           mutate_context!(:transcript_cleared) do |root|
@@ -730,8 +755,8 @@ module Phronomy
       def _prepare_invocation_config(config, invocation_context)
         __assert_live_agent!
         _reject_removed_generic_identity_keys!(config)
-        if config.keys.any? { |key| %w[output_schema response_schema phronomy_output_contract].include?(key.to_s) }
-          raise ArgumentError, "Use the output_schema keyword on a new Agent execution"
+        if config.keys.any? { |key| %w[output_schema schema_delivery response_schema phronomy_output_contract].include?(key.to_s) }
+          raise ArgumentError, "Use the output_schema and schema_delivery keywords on a new Agent execution"
         end
         invocation_context ?
           config.merge(invocation_context: invocation_context) : config

data/lib/phronomy/agent/composition/run_once.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# This convenience API composes a fresh ephemeral Persistence with an Agent.
+# This convenience API owns a fresh ephemeral Persistence and a scoped Agent.
 # The application entry loads the method definition; Agent execution does not
 # delegate to or require this higher-level composition implementation.
 module Phronomy
@@ -18,15 +18,16 @@ module Phronomy
         raise ArgumentError, "Provide either on_event: or a block, not both"
       end
 
-      persistence = Phronomy::PersistenceComposition.agent
-      agent = definition.create(
-        context: context,
-        knowledge: knowledge,
-        persistence: persistence,
-        on_event: on_event,
-        &event_block
-      )
-      agent.invoke(input, **invoke_options)
+      open_scope do |scope|
+        persistence = Phronomy::PersistenceComposition.agent
+        agent = scope.create(definition,
+          context: context,
+          knowledge: knowledge,
+          persistence: persistence,
+          on_event: on_event,
+          &event_block)
+        agent.invoke(input, **invoke_options)
+      end
     end
   end
 end

data/lib/phronomy/agent/context_preparation.rb

@@ -251,6 +251,7 @@ module Phronomy
         tools:,
         current_input:
       )
+        OutputContract.validate_model_config!(model_config) if execution.metadata.key?("output_contract")
         token_budget = Phronomy::Agent::Settings.current.llm_adapter.input_budget(model_config)
         policy_input = @input_builder.build(
           agent_id: agent_root.agent_id,

data/lib/phronomy/agent/execution/dispatch_preparation.rb

@@ -123,7 +123,7 @@ module Phronomy
         manifest, manifest_ref = @persistence.transaction do |tx|
           assert_local_durable_base!(tx, operation.root)
           Phronomy::Context::Assembly.new.store(prepared, contents: tx.contents,
-            response_schema_ref: recorded.metadata.dig("output_contract", "schema_ref"))
+            response_schema_ref: OutputContract.response_schema_ref(recorded.metadata))
         end
         updated = execution_with_provider_manifest(recorded, manifest_ref)
         change = ExecutionChange.new(agent: @agent, current: operation.execution,

data/lib/phronomy/agent/execution/exact_execution.rb

@@ -122,9 +122,11 @@ module Phronomy
           raise Phronomy::Persistence::StateConflictError, "Reserved execution #{@id} correlation mismatch"
         end
         unless @resume_only
-          expected_digest = @config[:phronomy_output_contract]&.digest
-          if expected_digest != execution.metadata.dig("output_contract", "schema_digest")
-            raise Phronomy::Persistence::StateConflictError, "Reserved execution output schema mismatch"
+          expected_contract = @config[:phronomy_output_contract]
+          saved_contract = OutputContract.restore(execution, @agent.persistence.contents)
+          if expected_contract&.digest != saved_contract&.digest ||
+              expected_contract&.schema_delivery != saved_contract&.schema_delivery
+            raise Phronomy::Persistence::StateConflictError, "Reserved execution output contract mismatch"
           end
         end
         ref = execution.metadata["current_input_ref"]

data/lib/phronomy/agent/execution/execution_coordinator.rb

@@ -1703,6 +1703,12 @@ module Phronomy
           execution_id,
           fallback: fallback_task
         )
+        # All these waiters observe the same terminal execution. A synchronous
+        # completion callback may request unload immediately, so acknowledge
+        # every finished operation before publishing any logical result. Each
+        # OperationResult still retains its lease until tracked physical work
+        # ends; unrelated operations remain protected by their own leases.
+        waiters.each { |task| task.finish_operation! if task.respond_to?(:finish_operation!) }
         waiters.each do |task|
           settle_after_terminal(
             task, callback_error, event_type, result, execution_error

data/lib/phronomy/agent/execution/execution_outcome_committer.rb

@@ -286,12 +286,7 @@ module Phronomy
           agent: @agent,
           persistence: persistence
         )
-        materializer.materialize_journal_records(
-          JournalProjection.new(
-            agent_root: root,
-            records: journal_records
-          ).transcript_records
-        )
+        materializer.materialize_transcript(root: root, records: journal_records)
       end
 
       def result_base(execution, root)

data/lib/phronomy/agent/execution/initial_preparation.rb

@@ -192,7 +192,7 @@ module Phronomy
         @persistence.transaction do |tx|
           assert_local_durable_base!(tx, root)
           manifest, manifest_ref = Phronomy::Context::Assembly.new.store(prepared, contents: tx.contents,
-            response_schema_ref: staged.metadata.dig("output_contract", "schema_ref"))
+            response_schema_ref: OutputContract.response_schema_ref(staged.metadata))
           active = execution_with_initial_manifest(staged, manifest_ref)
           tx.executions.save(
             staged.execution_id,

data/lib/phronomy/agent/execution/invocation_actions.rb

@@ -6,46 +6,48 @@ module Phronomy
     # Session construction and resource selection are supplied by the environment.
     # @api private
     class InvocationActions
-      def self.build_entry_actions(agent, environment, mode:, event_sink:)
+      def self.build_entry_actions(environment, mode:, event_sink:)
+        # Generated machine callbacks can outlive a session through VM method
+        # caches. Resolve the Agent from the current invocation, never capture it.
         calling_action = if mode.to_sym == :stream
-          method(:calling_llm_stream_action).curry.call(agent, environment, event_sink)
+          method(:calling_llm_stream_action).curry.call(environment, event_sink)
         else
-          method(:calling_llm_action).curry.call(agent, environment, event_sink)
+          method(:calling_llm_action).curry.call(environment, event_sink)
         end
 
         {
-          filtering_input: [method(:apply_prepared_input_action).curry.call(agent)],
-          building_context: [method(:prepare_runtime_input_action).curry.call(agent)],
+          filtering_input: [method(:apply_prepared_input_action)],
+          building_context: [method(:prepare_runtime_input_action)],
           calling_llm: [calling_action],
           starting_tools: [method(:starting_tools_action).curry.call(environment, event_sink)],
           dispatching_tools: [method(:dispatching_tools_action).curry.call(environment, event_sink)],
           recording_tool_results: [method(:recording_tool_results_action)],
           suspended: [method(:suspended_action)],
-          output_filtering: [method(:output_filtering_action).curry.call(agent)],
+          output_filtering: [method(:output_filtering_action)],
           failed: [method(:failed_action)]
         }
       end
 
-      def self.apply_prepared_input_action(_agent, invocation)
+      def self.apply_prepared_input_action(invocation)
         invocation.input = invocation.config.fetch(:phronomy_filtered_input)
         invocation
       end
       private_class_method :apply_prepared_input_action
 
-      def self.prepare_runtime_input_action(agent, invocation)
+      def self.prepare_runtime_input_action(invocation)
         projection = invocation.config.fetch(:phronomy_runtime_projection)
-        agent.send(:prepare_runtime_input, projection, invocation: invocation)
+        invocation.agent.send(:prepare_runtime_input, projection, invocation: invocation)
       end
       private_class_method :prepare_runtime_input_action
 
-      def self.calling_llm_action(agent, environment, event_sink, invocation)
-        prepare_and_start_llm_call(agent, environment, event_sink, invocation, streaming: false)
+      def self.calling_llm_action(environment, event_sink, invocation)
+        prepare_and_start_llm_call(invocation.agent, environment, event_sink, invocation, streaming: false)
         invocation
       end
       private_class_method :calling_llm_action
 
-      def self.calling_llm_stream_action(agent, environment, event_sink, invocation)
-        prepare_and_start_llm_call(agent, environment, event_sink, invocation, streaming: true)
+      def self.calling_llm_stream_action(environment, event_sink, invocation)
+        prepare_and_start_llm_call(invocation.agent, environment, event_sink, invocation, streaming: true)
         invocation
       end
       private_class_method :calling_llm_stream_action
@@ -354,8 +356,8 @@ module Phronomy
       end
       private_class_method :failed_action
 
-      def self.output_filtering_action(agent, invocation)
-        invocation.output = agent.send(:run_output_filters!, invocation.output)
+      def self.output_filtering_action(invocation)
+        invocation.output = invocation.agent.send(:run_output_filters!, invocation.output)
         invocation
       rescue Phronomy::FilterBlockError => error
         invocation.output_blocked = true

data/lib/phronomy/agent/execution_change.rb

@@ -75,6 +75,10 @@ module Phronomy
         return @result if outcome.disposition == :committed
         raise error if outcome.disposition == :not_committed
         raise Phronomy::ExecutionRehydrationRequiredError, "Execution change outcome is unknown: #{(outcome.read_error || error).message}"
+      ensure
+        # A completed synchronous change may remain on a worker's native stack.
+        # Release live execution wiring only after commit/readback has finished.
+        @agent = @write = @participant = nil
       end
 
       private :perform_once

data/lib/phronomy/agent/output_contract.rb

@@ -9,13 +9,17 @@ module Phronomy
     class OutputContract
       FACTORIES = {}
       private_constant :FACTORIES
-      attr_reader :schema, :digest
+      attr_reader :schema, :digest, :schema_delivery
 
       def self.install_factory(factory)
         FACTORIES.replace(parser: factory).freeze
       end
 
-      def initialize(schema)
+      def initialize(schema, schema_delivery: :native)
+        unless %i[native none].include?(schema_delivery)
+          raise ArgumentError, "schema_delivery must be :native or :none"
+        end
+        @schema_delivery = schema_delivery
         @parser = FACTORIES.fetch(:parser).call(schema)
         @schema = @parser.json_schema
         @digest = Digest::SHA256.hexdigest(JSON.generate(@schema, sort_keys: true)).freeze
@@ -23,20 +27,58 @@ module Phronomy
       end
 
       def metadata(contents)
-        {"output_contract" => {"version" => 1, "schema_ref" => contents.put_text(JSON.generate(schema, sort_keys: true)), "schema_digest" => digest}}
+        {"output_contract" => {"version" => 2, "schema_ref" => contents.put_text(JSON.generate(schema, sort_keys: true)),
+                               "schema_digest" => digest, "schema_delivery" => schema_delivery.to_s}}
       end
 
       def self.restore(execution, contents)
         stored = execution.metadata["output_contract"]
         return nil unless stored
-        raise ArgumentError, "unsupported Agent output contract version" unless stored.fetch("version") == 1
-        contract = new(contents.fetch_json(stored.fetch("schema_ref")))
+        contract = new(contents.fetch_json(stored.fetch("schema_ref")), schema_delivery: delivery(stored))
         unless contract.digest == stored.fetch("schema_digest")
           raise Phronomy::ContentStore::IntegrityError, "Agent output schema digest mismatch"
         end
         contract
       end
 
+      # The schema stays durable even when the provider receives no schema.
+      def self.response_schema_ref(metadata)
+        stored = metadata["output_contract"]
+        stored.fetch("schema_ref") if stored && delivery(stored) == :native
+      end
+
+      def self.delivery(stored)
+        case stored.fetch("version")
+        when 1 then :native
+        when 2
+          value = stored.fetch("schema_delivery")
+          unless %w[native none].include?(value)
+            raise ArgumentError, "unsupported Agent schema delivery"
+          end
+          value.to_sym
+        else
+          raise ArgumentError, "unsupported Agent output contract version"
+        end
+      end
+
+      # Agent owns the final-output contract, including bypass prevention when
+      # no native schema is sent. Provider configuration cannot replace it.
+      def self.validate_model_config!(value)
+        case value
+        when Hash
+          value.each do |key, child|
+            if %w[schema schema_delivery output_schema response_schema response_format responseJsonSchema responseSchema
+              text.format output_config.format].include?(key.to_s) ||
+                (%w[text output_config].include?(key.to_s) && child.is_a?(Hash) && child.keys.any? { |name| name.to_s == "format" })
+              raise ArgumentError, "model configuration cannot override the Agent output contract"
+            end
+            validate_model_config!(child)
+          end
+        when Array
+          value.each { |child| validate_model_config!(child) }
+        end
+      end
+
       def validate(output, response:, execution_id:)
         raw = response&.content
         reason = if response&.refusal || response&.finish_reason == :refusal

data/lib/phronomy/agent/persistence/codec.rb

@@ -12,6 +12,7 @@ module Phronomy
         AGENT_ROOT_FORMAT_VERSION = "0.1"
         AGENT_EXECUTION_RECORD_TYPE = "phronomy.agent_execution"
         AGENT_EXECUTION_FORMAT_VERSION = "0.2"
+        OUTPUT_CONTRACT_FORMAT_VERSION = "0.3"
         JOURNAL_RECORD_TYPE = "phronomy.journal_record"
         JOURNAL_FORMAT_VERSION = "0.1"
         AGENT_ROOT_KEYS = %w[
@@ -88,7 +89,7 @@ module Phronomy
           validate_agent_execution_payload!(payload)
           build_record(
             AGENT_EXECUTION_RECORD_TYPE,
-            AGENT_EXECUTION_FORMAT_VERSION,
+            execution_format_version(payload),
             payload
           )
         rescue Phronomy::Storage::SerializationError
@@ -101,11 +102,15 @@ module Phronomy
           payload = current_payload!(
             record,
             record_type: AGENT_EXECUTION_RECORD_TYPE,
-            format_version: AGENT_EXECUTION_FORMAT_VERSION,
+            format_version: (record.respond_to?(:format_version) && record.format_version == OUTPUT_CONTRACT_FORMAT_VERSION) ?
+              OUTPUT_CONTRACT_FORMAT_VERSION : AGENT_EXECUTION_FORMAT_VERSION,
             keys: AGENT_EXECUTION_KEYS,
             label: "AgentExecution payload"
           )
           validate_agent_execution_payload!(payload)
+          unless record.format_version == execution_format_version(payload)
+            raise Phronomy::Storage::SerializationError, "Agent output contract does not match execution format version"
+          end
           Phronomy::Agent::AgentExecution.from_h(payload)
         rescue Phronomy::Storage::SerializationError
           raise
@@ -113,6 +118,15 @@ module Phronomy
           serialization_error("cannot decode AgentExecution", error)
         end
 
+        # Old readers reject the new envelope before interpreting any execution.
+        # Freeform and version-one records retain their original envelope.
+        def execution_format_version(payload)
+          stored = payload.fetch("metadata")["output_contract"]
+          return AGENT_EXECUTION_FORMAT_VERSION unless stored
+          Phronomy::Agent::OutputContract.delivery(stored)
+          (stored.fetch("version") == 2) ? OUTPUT_CONTRACT_FORMAT_VERSION : AGENT_EXECUTION_FORMAT_VERSION
+        end
+
         def encode_journal_record(journal_record)
           payload = journal_payload(journal_record, require_sequence: true)
           build_record(JOURNAL_RECORD_TYPE, JOURNAL_FORMAT_VERSION, payload)

data/lib/phronomy/agent/recovery/recovery_coordinator/continuation.rb

@@ -28,6 +28,7 @@ module Phronomy
         # operation-local projections transferred to the new invocation, never a
         # shared cache or a second source of continuation decisions.
         def prepare_recovery_material(execution, projection: nil)
+          OutputContract.restore(execution, agent.persistence.contents)
           action = recovery_action(execution)
           suspended = execution.status == :suspended || execution.phase.to_sym == :resuming
           return if !suspended && %i[resolution_required failed_terminal].include?(action)

data/lib/phronomy/agent/runtime_binding/engine_session_builder.rb

@@ -9,8 +9,8 @@ module Phronomy
       def self.build(invocation:, environment:, event_loop:, resume_event: nil, resume_phase: nil)
         event_sink = Phronomy::FSMSession::EventSink.new(event_loop: event_loop)
         invocation.bind_event_sink!(event_sink)
-        actions = InvocationActions.build_entry_actions(invocation.agent,
-          environment, mode: invocation.mode, event_sink: event_sink)
+        actions = InvocationActions.build_entry_actions(environment,
+          mode: invocation.mode, event_sink: event_sink)
         phase_machine = PhaseMachineBuilder.new(entry_actions: actions).build
 
         Phronomy::FSMSession.new(

data/lib/phronomy/agent/runtime_input.rb

@@ -54,6 +54,13 @@ module Phronomy
         )
       end
 
+      # One interpretation for execution results and public transcript reads.
+      def materialize_transcript(root:, records:)
+        materialize_journal_records(
+          JournalProjection.new(agent_root: root, records: records).transcript_records
+        )
+      end
+
       def materialize_journal_record(record)
         materialize_segment(segment_from_record(record))
       end

data/lib/phronomy/engine/fsm_session.rb

@@ -165,6 +165,10 @@ module Phronomy
       end
     rescue => error
       finish_with_error(error)
+    ensure
+      # The session owns its context between events. A tracker retained by the
+      # state-machine library or VM must not retain that live context as well.
+      @tracker.context = nil if @tracker
     end
 
     def handle(event)
@@ -190,6 +194,9 @@ module Phronomy
       fire_and_advance!(event)
     rescue => error
       finish_with_error(error)
+    ensure
+      # fire_and_advance! rebinds the context for the next accepted transition.
+      @tracker.context = nil if @tracker
     end
 
     private

data/lib/phronomy/execution/async_operation.rb

@@ -25,6 +25,22 @@ module Phronomy
       map(source, name: name, on_error: on_error, &transform)
     end
 
+    # Finalize owned work after its logical and physical boundaries. Cleanup is
+    # asynchronous too. The owner supplies cleanup and combined-error meaning;
+    # neither observer cancellation nor an Execution scope can skip cleanup.
+    # @api private
+    def self.finalize(name:, cleanup:, on_cleanup_error:)
+      source = begin
+        value = yield
+        raise TypeError, "finalized operation must return a TaskResult" unless value.is_a?(TaskResult)
+        value
+      rescue => error
+        TaskResult.failed(error, name: name)
+      end
+      Concurrency::ResultFinalization.new(source, name: name,
+        cleanup: cleanup, on_cleanup_error: on_cleanup_error).start
+    end
+
     # Short synchronous fallback/validation only; never offloads or awaits work.
     def self.capture(name:, on_error: nil)
       value = yield

data/lib/phronomy/execution/concurrency/result_finalization.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Concurrency
+    # Completion composition for an owner-supplied asynchronous finalizer.
+    # This has no cancellation authority and no domain release policy.
+    # @api private
+    class ResultFinalization
+      def initialize(source, name:, cleanup:, on_cleanup_error:)
+        @source = source
+        @cleanup = cleanup
+        @on_cleanup_error = on_cleanup_error
+        @result = PhysicalCompletionTask.deferred(name: name)
+        @mutex = Mutex.new
+        @phase = :source
+        @outcomes = {}
+        @physical = {}
+      end
+
+      def start
+        observe(@source, :source)
+        @result
+      end
+
+      private
+
+      def observe(task, phase)
+        physical = task.respond_to?(:on_physical_complete)
+        @mutex.synchronize { @physical[phase] = !physical }
+        if physical
+          task.on_physical_complete do
+            @mutex.synchronize { @physical[phase] = true unless @phase == :finished }
+            advance
+          end
+        end
+        task.on_complete do |value, error|
+          @mutex.synchronize do
+            if @phase == phase && !@outcomes.key?(phase)
+              status = if error
+                (task.status == :cancelled) ? :cancelled : :failed
+              else
+                :completed
+              end
+              @outcomes[phase] = [status, value, error]
+            end
+          end
+          advance
+        end
+      end
+
+      def advance
+        action = @mutex.synchronize do
+          phase = @phase
+          next unless @outcomes.key?(phase) && @physical[phase]
+          @phase = (phase == :source) ? :cleanup : :finished
+          phase
+        end
+        case action
+        when :source then start_cleanup
+        when :cleanup then finish
+        end
+      end
+
+      def start_cleanup
+        task = begin
+          value = @cleanup.call
+          raise TypeError, "asynchronous cleanup must return a TaskResult" unless value.is_a?(TaskResult)
+          value
+        rescue => error
+          TaskResult.failed(error)
+        end
+        observe(task, :cleanup)
+      end
+
+      def finish
+        status, value, error = @outcomes.fetch(:source)
+        cleanup_error = @outcomes.fetch(:cleanup).last
+        if cleanup_error
+          begin
+            error = @on_cleanup_error.call(value, error, cleanup_error)
+            raise TypeError, "cleanup error policy must return or raise an Exception" unless error.is_a?(Exception)
+          rescue => policy_error
+            error = policy_error
+          end
+          status = :failed
+        end
+        # Completed handles must not keep the owner or its source/cleanup
+        # closures alive. A domain cleanup error may deliberately retain them.
+        @source = @cleanup = @on_cleanup_error = nil
+        @mutex.synchronize do
+          @outcomes.clear
+          @physical.clear
+        end
+        begin
+          @result.mark_physical_complete!
+        ensure
+          case status
+          when :completed then @result.complete(value)
+          when :cancelled then @result.cancel!(error)
+          else @result.fail(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phronomy/generation/generator_verifier/agent_operation.rb

@@ -8,8 +8,8 @@ module Phronomy
     # still pending. Generation owns the request-to-Workflow correlation.
     # @api private
     class AgentOperation
-      def initialize(agent_class, output_schema:)
-        @output_schema = output_schema
+      def initialize(agent_class, output_schema:, schema_delivery:)
+        @output_schema, @schema_delivery = output_schema, schema_delivery
         @mutex = Mutex.new
         @pending = []
         @agent = agent_class.new(on_event: method(:receive_event))
@@ -21,7 +21,7 @@ module Phronomy
         # own result settles: Agent admission itself may run after an earlier
         # request completes, so a pending submission is not necessarily busy.
         @mutex.synchronize { @pending << [request, listener] }
-        task = @agent.invoke_async(input, config: config, output_schema: @output_schema)
+        task = @agent.invoke_async(input, config: config, output_schema: @output_schema, schema_delivery: @schema_delivery)
         task.on_complete do |result, error|
           release(request)
           remember_execution(result[:execution_id]) if result.is_a?(Hash)

data/lib/phronomy/generation/generator_verifier.rb

@@ -34,10 +34,13 @@ module Phronomy
     end
 
     def initialize(draft_agent:, review_agent:, draft_prompt_builder:, review_prompt_builder:,
-      citation_schema: Protocol::DEFAULT_CITATION,
+      citation_schema: Protocol::DEFAULT_CITATION, schema_delivery: :native,
       confidence_threshold: DEFAULT_CONFIDENCE_THRESHOLD,
       max_iterations: DEFAULT_MAX_ITERATIONS, raise_if_unaccepted: false, on_approval: nil)
       ensure_blocking_allowed!(:new)
+      unless %i[native none].include?(schema_delivery)
+        raise ArgumentError, "schema_delivery must be :native or :none"
+      end
       unless confidence_threshold.is_a?(Numeric) && confidence_threshold.real? && confidence_threshold.to_f.finite? &&
           (0.0..1.0).cover?(confidence_threshold)
         raise ArgumentError, "confidence_threshold must be a finite number in 0..1"
@@ -62,8 +65,8 @@ module Phronomy
       @draft_prompt_builder, @review_prompt_builder = draft_prompt_builder, review_prompt_builder
       draft_schema = Protocol.draft(citation_schema)
       begin
-        @operations[:draft] = AgentOperation.new(draft_agent, output_schema: draft_schema)
-        @operations[:review] = AgentOperation.new(review_agent, output_schema: Protocol::REVIEW)
+        @operations[:draft] = AgentOperation.new(draft_agent, output_schema: draft_schema, schema_delivery: schema_delivery)
+        @operations[:review] = AgentOperation.new(review_agent, output_schema: Protocol::REVIEW, schema_delivery: schema_delivery)
       rescue Exception => primary # rubocop:disable Lint/RescueException -- release partially acquired resources
         begin
           release!

data/lib/phronomy/llm_adapter/backends/ruby_llm.rb

@@ -63,7 +63,7 @@ module Phronomy
         callback_error = nil
         chat = build_chat(request)
         capture = StructuredResponseCapture.new
-        capture.bind(chat) if request.response_schema && block_given?
+        capture.bind(chat) if block_given?
         token&.raise_if_cancelled!
         chat.after_message do |message|
           raise ToolsRequested.new(message) if message.tool_call?

data/lib/phronomy/llm_adapter/backends/structured_response_capture.rb

@@ -24,7 +24,9 @@ module Phronomy
 
       def record(data)
         choice = data.dig("choices", 0) || {}
-        @raw_finish_reason = choice["finish_reason"] || data.dig("delta", "stop_reason") ||
+        provider_delta = data["delta"]
+        stop_reason = provider_delta["stop_reason"] if provider_delta.is_a?(Hash)
+        @raw_finish_reason = choice["finish_reason"] || stop_reason ||
           data.dig("candidates", 0, "finishReason") || @raw_finish_reason
         delta = choice.dig("delta", "refusal")
         delta ||= data["delta"] if data["type"] == "response.refusal.delta"