pwn 0.5.705 → 0.5.706

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a46dbcdcfe0fb82880e81cbe531199c9cbcba65da71abf609b392afbfab55356
-  data.tar.gz: 49ff3675f07a0fd8f81ce86230ee7651316c772289ec9138a14862a92393f7e5
+  metadata.gz: f9233042c1c9518d8cfdcbfe6499eb521cb0348384554e03ab6641abdda253b9
+  data.tar.gz: 51b81fd36f292bc54e762d4bb47f5641c9b263addf9f37997aaa4c2f6a00c49f
 SHA512:
-  metadata.gz: 14ffb11e8613dcc5d24830514d4efd2ddaf7c584df93671d41843bb42c6d927d62af7703da63e54e8b4fe7d2d0bf91dc76c140b404bced65a87b57b78adfd4a5
-  data.tar.gz: abf7797752f082aa8d032fea627a72ceb81e2859672679f9f05898ef68d7ee4463184be9dc94c1ba45c2cada205e859566185d75ce40bac24bd9d4662ec48b4b
+  metadata.gz: 370d8b9305f7dcd2a692061b6708feca282546109533131d244cd97d207d1b216afac16baf44847a8a098c9847467208dd30e81084729f79ee7e3c16c050ae32
+  data.tar.gz: 97725299f78baef12d73614b7258ebf5cc3664316c82d2bf53d6a82e3d9e0e0d2542a3143cbc686fc75b46b6883fb8edc0174cfd38ce74b88a0c908ab4864642

data/lib/pwn/ai/agent/loop.rb

@@ -584,6 +584,10 @@ module PWN
           live = effects.reject { |fx| %i[recall store].include?(fx) }
           return true if live.empty?
           return true if duration_unsatisfied?(request: request)
+          return true if declared_contract_unsatisfied?(
+            request: request,
+            messages: opts[:messages]
+          )
           return true if need == :write && !write_verified?(effects: effects)
           return true if need == :browse && !effects.include?(:browse)
           return true if need == :any && !effects.intersect?(%i[write browse eval])
@@ -613,23 +617,157 @@ module PWN
         }.freeze
 
         private_class_method def self.duration_unsatisfied?(opts = {})
-          req = opts[:request].to_s
-          hours = nil
-          if (m = req.match(/\b(\d+)\s*(?:hours?|hrs?)\b/i))
-            hours = m[1].to_i
-          elsif (m = req.match(/\b(twenty-four|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*(?:hours?|hrs?)\b/i))
-            hours = HOUR_WORDS[m[1].downcase]
+          secs = declared_min_seconds(request: opts[:request])
+          if secs <= 0
+            req = opts[:request].to_s
+            hours = nil
+            if (m = req.match(/\b(\d+)\s*(?:hours?|hrs?)\b/i))
+              hours = m[1].to_i
+            elsif (m = req.match(/\b(twenty-four|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*(?:hours?|hrs?)\b/i))
+              hours = HOUR_WORDS[m[1].downcase]
+            end
+            secs = hours.to_i * 3600
           end
-          return false if hours.to_i <= 0
+          return false if secs <= 0
 
           t0 = Thread.current[:pwn_loop_t0]
           return false unless t0
 
-          (Time.now - t0) < (hours * 3600)
+          (Time.now - t0) < secs
+        rescue StandardError
+          false
+        end
+
+        EMPTY_CONTRACT = {
+          paths: [],
+          min_seconds: 0,
+          skills: [],
+          proofs: [],
+          hosts: []
+        }.freeze
+
+        private_class_method def self.declared_min_seconds(opts = {})
+          declared_contract(request: opts[:request])[:min_seconds].to_i
+        end
+
+        private_class_method def self.declared_contract_unsatisfied?(opts = {})
+          contract = declared_contract(request: opts[:request])
+          files = Array(contract[:paths]) + Array(contract[:proofs])
+          return true if files.any? { |path| deliverable_missing?(path: path) }
+          return true if declared_skills_missing?(skills: contract[:skills])
+          return true if declared_hosts_missing?(hosts: contract[:hosts], messages: opts[:messages])
+
+          false
         rescue StandardError
           false
         end
 
+        private_class_method def self.declared_skills_missing?(opts = {})
+          names = Array(opts[:skills]).map(&:to_s).reject(&:empty?)
+          return false if names.empty?
+          return true unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash)
+
+          have = PWN::Skills.keys.map(&:to_s)
+          names.any? { |name| !have.include?(name) }
+        end
+
+        private_class_method def self.declared_hosts_missing?(opts = {})
+          hosts = Array(opts[:hosts]).map(&:to_s).reject(&:empty?)
+          return false if hosts.empty?
+
+          blob = Array(opts[:messages]).select { |msg| msg.is_a?(Hash) && msg[:role].to_s == 'tool' }
+                                       .map { |msg| msg[:content].to_s }
+                                       .join("\n")
+                                       .downcase
+          hosts.any? { |host| !blob.include?(host.to_s.downcase) }
+        end
+
+        private_class_method def self.declared_deliverables(opts = {})
+          Array(declared_contract(request: opts[:request])[:paths])
+        end
+
+        private_class_method def self.declared_contract(opts = {})
+          cached = Thread.current[:pwn_loop_deliverables]
+          return normalize_contract(raw: cached) if cached.is_a?(Array) || cached.is_a?(Hash)
+          return EMPTY_CONTRACT.dup unless Thread.current[:pwn_loop_active]
+
+          contract = infer_deliverables(request: opts[:request])
+          Thread.current[:pwn_loop_deliverables] = contract
+          contract
+        end
+
+        private_class_method def self.normalize_contract(opts = {})
+          raw = opts[:raw]
+          return EMPTY_CONTRACT.merge(paths: raw.map(&:to_s).select { |p| p.start_with?('/') }) if raw.is_a?(Array)
+          return EMPTY_CONTRACT.dup unless raw.is_a?(Hash)
+
+          hours = raw[:hours] || raw['hours']
+          secs = (raw[:min_seconds] || raw['min_seconds']).to_i
+          secs = hours.to_i * 3600 if secs <= 0 && hours.to_i.positive?
+          {
+            paths: abs_paths(rows: raw[:paths] || raw['paths']),
+            min_seconds: secs,
+            skills: Array(raw[:skills] || raw['skills']).map(&:to_s).reject(&:empty?).uniq,
+            proofs: abs_paths(rows: raw[:proofs] || raw['proofs']),
+            hosts: Array(raw[:hosts] || raw['hosts']).map(&:to_s).reject(&:empty?).uniq
+          }
+        end
+
+        private_class_method def self.abs_paths(opts = {})
+          Array(opts[:rows]).map(&:to_s).select { |path| path.start_with?('/') }.uniq
+        end
+
+        private_class_method def self.infer_deliverables(opts = {})
+          request = opts[:request].to_s
+          return EMPTY_CONTRACT.dup if request.strip.empty?
+
+          reply = call_engine(
+            messages: [
+              {
+                role: 'system',
+                content: 'Reply with JSON only. No markdown. No tools.'
+              },
+              {
+                role: 'user',
+                content: "Operator request:\n#{request}\n\n" \
+                         'When that request is complete, what must be true on this host? ' \
+                         'JSON only: {"paths":["/abs/file"],"min_seconds":0,"skills":["name"],' \
+                         '"proofs":["/abs/poc"],"hosts":["ip-or-hostname"]}. ' \
+                         'Use [] or 0 when a field is not required. Do not invent work. Paths must be absolute.'
+              }
+            ],
+            tools: nil
+          )
+          text = reply.is_a?(Hash) ? (reply[:content] || reply['content']).to_s : reply.to_s
+          parse_contract(text: text)
+        rescue StandardError
+          EMPTY_CONTRACT.dup
+        end
+
+        private_class_method def self.parse_contract(opts = {})
+          text = opts[:text].to_s
+          json = nil
+          begin
+            json = JSON.parse(text, symbolize_names: true)
+          rescue JSON::ParserError
+            start = text.index('{')
+            stop = text.rindex('}')
+            return EMPTY_CONTRACT.dup unless start && stop && stop > start
+
+            json = JSON.parse(text[start..stop], symbolize_names: true)
+          end
+          normalize_contract(raw: json)
+        rescue StandardError
+          EMPTY_CONTRACT.dup
+        end
+
+        private_class_method def self.deliverable_missing?(opts = {})
+          path = opts[:path].to_s
+          path.empty? || !File.file?(path) || File.size(path) <= 0
+        rescue StandardError
+          true
+        end
+
         private_class_method def self.may_finalize?(opts = {})
           return false if incomplete_final?(text: opts[:text], last_iter: false)
           return false if request_unsatisfied?(
@@ -2434,6 +2572,10 @@ module PWN
           Thread.current[:pwn_extinguished] = {}
           Thread.current[:pwn_same_payload] = Hash.new(0)
           Thread.current[:pwn_loop_t0] = Time.now unless nested
+          unless nested
+            Thread.current[:pwn_loop_active] = true
+            Thread.current[:pwn_loop_deliverables] = nil
+          end
           debug_progress(msg: "intent=#{intent} engine=#{engine}", debug: opts[:debug])
           expose_current_session(session_id: session_id)
           Mistakes.check_user_correction(request: request, session_id: session_id) if defined?(Mistakes)
@@ -2672,12 +2814,20 @@ module PWN
             # commit that as the answer; drop the empty assistant turn,
             # inject a one-shot nudge, and keep iterating.
             if calls.empty? && text.strip.empty?
+              unsat = request_unsatisfied?(request: request, messages: messages)
               warn "[pwn-ai/loop] empty final from #{engine} on iter=#{i}; nudging" if local
+              empty_nudge = if unsat
+                              'Your previous reply was empty (no tool_calls and no content). ' \
+                                'The original request is not evidenced yet. Emit NATIVE tool_calls NOW. ' \
+                                'Do not write a final answer until that request is done or a tool returned failure evidence.'
+                            else
+                              'Your previous reply was empty (no tool_calls and no content). ' \
+                                'Either call a tool now, or write the final answer for the user as plain text. ' \
+                                'Do not reply with an empty message.'
+                            end
               messages << {
                 role: 'user',
-                content: 'Your previous reply was empty (no tool_calls and no content). ' \
-                         'Either call a tool now, or write the final answer for the user as plain text. ' \
-                         'Do not reply with an empty message.'
+                content: empty_nudge
               }
               turn_fails['empty_final'] += 1
               debug_progress(msg: "bounce empty_final snippet=#{debug_snippet(text: text)}")
@@ -2830,6 +2980,10 @@ module PWN
           end
           raise
         ensure
+          unless nested
+            Thread.current[:pwn_loop_active] = nil
+            Thread.current[:pwn_loop_deliverables] = nil
+          end
           Thread.current[:pwn_loop_no_tools] = nil
           finish_debug_request!(
             iter: i,

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.705'
+  VERSION = '0.5.706'
 end

data/spec/lib/pwn/ai/agent/loop_spec.rb

@@ -910,6 +910,113 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       Thread.current[:pwn_loop_t0] = nil
     end
 
+    it 'keeps LLM-declared deliverable paths unsatisfied until those files exist' do
+      path = "/tmp/pwn-deliv-#{Process.pid}.bin"
+      FileUtils.rm_f(path)
+      Thread.current[:pwn_loop_deliverables] = [path]
+      req = 'Exhaustively analyze the docker app. 100% coverage. Store the PDF in /tmp/container_pentest-p4-PWN-122B.pdf'
+      recap = 'Good! Let me continue the penetration test with more aggressive testing now.'
+      msgs = [
+        { role: 'user', content: req },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"File.write(\"/tmp/pentest_report.json\",\"x\")"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'pwn_eval',
+          content: '{"success":true,"result":{"stdout":"Report saved to /tmp/pentest_report.json"},"effect":"write"}'
+        },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'shell', arguments: '{"command":"curl -s http://127.0.0.1:5000/auth/login"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'shell',
+          content: '{"success":true,"result":{"stdout":"<form>"},"effect":"read"}'
+        },
+        { role: 'assistant', content: recap }
+      ]
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      expect(described_class.send(:may_finalize?, request: req, messages: msgs, text: recap)).to eq(false)
+      File.write(path, 'any bytes')
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+    ensure
+      FileUtils.rm_f(path)
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'parses a full acceptance contract from one engine JSON hop' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).not_to match(/NAMED_PATH_RX/)
+      expect(src).not_to include('%PDF')
+      expect(src).to match(/infer_deliverables|pwn_loop_deliverables/)
+      payload = {
+        paths: ['/tmp/out.json'],
+        min_seconds: 28_800,
+        skills: ['penetration-testing'],
+        proofs: ['/tmp/poc.sh'],
+        hosts: ['127.0.0.1']
+      }
+      allow(described_class).to receive(:call_engine).and_return(payload.to_json)
+      Thread.current[:pwn_loop_active] = true
+      Thread.current[:pwn_loop_deliverables] = nil
+      paths = described_class.send(:declared_deliverables, request: 'write a report somewhere')
+      expect(paths).to eq(['/tmp/out.json'])
+      contract = described_class.send(:declared_contract, request: 'write a report somewhere')
+      expect(contract[:min_seconds]).to eq(28_800)
+      expect(contract[:skills]).to eq(['penetration-testing'])
+      expect(contract[:proofs]).to eq(['/tmp/poc.sh'])
+      expect(contract[:hosts]).to eq(['127.0.0.1'])
+      expect(described_class).to have_received(:call_engine).once
+    ensure
+      Thread.current[:pwn_loop_active] = nil
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'verifies LLM-declared duration, skills, proofs, and hosts in the world' do
+      proof = "/tmp/pwn-proof-#{Process.pid}.txt"
+      FileUtils.rm_f(proof)
+      req = 'black-box test 127.0.0.1 using penetration-testing'
+      recap = 'done'
+      msgs = [
+        { role: 'user', content: req },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"1"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'pwn_eval',
+          content: '{"success":true,"result":{"value":"1","stdout":"scanned 10.0.0.1"},"effect":"eval"}'
+        },
+        { role: 'assistant', content: recap }
+      ]
+      Thread.current[:pwn_loop_t0] = Time.now
+      Thread.current[:pwn_loop_deliverables] = {
+        paths: [],
+        min_seconds: 60,
+        skills: ['no-such-bundled-skill'],
+        proofs: [proof],
+        hosts: ['127.0.0.1']
+      }
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      Thread.current[:pwn_loop_deliverables][:min_seconds] = 0
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      Thread.current[:pwn_loop_deliverables][:skills] = []
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      File.write(proof, 'poc')
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      msgs[2][:content] = '{"success":true,"result":{"value":"1","stdout":"open 127.0.0.1:5000"},"effect":"eval"}'
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+      expect(described_class.send(:may_finalize?, request: req, messages: msgs, text: recap)).to eq(true)
+    ensure
+      FileUtils.rm_f(proof)
+      Thread.current[:pwn_loop_t0] = nil
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
     it 'forces tool_choice required on host-work before any tool result, for every engine' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/tool_choice/)

data/third_party/pwn_rdoc.jsonl

@@ -309,6 +309,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.update_skill Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.update_skill`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.verdict_for_score Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.verdict_for_score`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.weighted_judge_mean Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.weighted_judge_mean`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.abs_paths Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.abs_paths`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.active_engine Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.active_engine`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.agent_flag Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.agent_flag`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.answer_greeting Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.answer_greeting`: "}]}
@@ -335,8 +336,15 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_snippet Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_snippet`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_tool_io! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_tool_io!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_tools_line Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_tools_line`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_contract`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_contract_unsatisfied? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_contract_unsatisfied?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_deliverables Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_deliverables`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_hosts_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_hosts_missing?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_min_seconds Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_min_seconds`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_skills_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_skills_missing?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.default_interactive_toolsets Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.default_interactive_toolsets`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.degrade_text_only Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.degrade_text_only`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.deliverable_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.deliverable_missing?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.dispatch_fail_n Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.dispatch_fail_n`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.duration_unsatisfied? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.duration_unsatisfied?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.emit_task_summary Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.emit_task_summary`: "}]}
@@ -349,6 +357,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.guard_repeated_failure Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.guard_repeated_failure`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.incomplete_final? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.incomplete_final?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.infer_deliverables Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.infer_deliverables`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.inject_task_focus! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.inject_task_focus!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.local_engine? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.local_engine?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.loud_debug_tui! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.loud_debug_tui!`: "}]}
@@ -361,12 +370,14 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.mistake_ts Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.mistake_ts`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.needs_host_work? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.needs_host_work?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.no_progress_result Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.no_progress_result`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.normalize_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.normalize_contract`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.normalize_llm Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.normalize_llm`: Supported Method Parameters\n\nmsg = PWN::AI::Agent::Loop.normalize_llm(\n\nresponse: 'required - chat_with_tools response Hash from any provider'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.note_same_payload! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.note_same_payload!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.ollama_wire_messages Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.ollama_wire_messages`: Supported Method Parameters\n\nwire = PWN::AI::Agent::Loop.ollama_wire_messages(\n\nmessages: 'required - in-memory OpenAI-ish messages (may have String args)'\n\n)\n\nReturns a deep-copied array safe for Ollama / Open WebUI ollama/api/chat:\n\nparses JSON-string function.arguments into Hash/Array objects\n\ncoerces nil assistant content to ” when tool_calls present (Open WebUI GenerateChatCompletionForm rejects content:null alone)\n\ndrops _native_content / _text_tool_coerced / thinking private keys\n\nstringifies Hash/Array message content (tool results) to JSON text\n\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.ollama_wire_tool_call Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.ollama_wire_tool_call`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.openai_wire_messages Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.openai_wire_messages`: Supported Method Parameters\n\nwire = PWN::AI::Agent::Loop.openai_wire_messages(\n\nmessages: 'required - in-memory OpenAI-ish messages (may have Hash args / internal keys)'\n\n)\n\nReturns a deep-copied array safe for OpenAI / xAI chat.completions:\n\ndrops _native_content / _text_tool_coerced / thinking private keys\n\nstringifies function.arguments maps\n\ncoerces Hash/non-string content to JSON/string (nil kept for assistant tool turns)\n\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.openai_wire_tool_call Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.openai_wire_tool_call`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.parse_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.parse_contract`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.parse_tool_arguments Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.parse_tool_arguments`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.payload_sig Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.payload_sig`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.plan_first Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.plan_first`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.705
+  version: 0.5.706
 platform: ruby
 authors:
 - 0day Inc.