pwn 0.5.741 → 0.5.742

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eb74de135994d78ce8af6b31729ef0622495f0cbe6ff72ddb5ecce5662a5aa7
-  data.tar.gz: 3f2d855056ef2cce6424ac399393e38492970850baa36fde37419d5e798ca2f8
+  metadata.gz: aae26246e4b23381c5f727d27100f6a10d37d955f2c9a875ad63274d3397219b
+  data.tar.gz: 1a0abc7df30321bd4618a8db3d356fa72e9b6cc13f6055b5f71bf4fb1b4ec90a
 SHA512:
-  metadata.gz: 995de4dfb6c55750ed90c2f8c282c4d6ca14e876f41ec207b71aecdc1d162ab69359a20d3d479115c4aea9b9eee7d04d9c3bd1678ff73d1e1c06dbefcbef7c46
-  data.tar.gz: 30c2d6602caa5d1fef740508751d4457d69c7f51d861a6260e57f65251c5050d2425c21dad3e946181aa1776345f413e2a035ec3bcf411ae4eedce21441d61d4
+  metadata.gz: 5b680d2d2d3eb756642d68a6309a36a5d551100131b58323954bd402c73f554515304ecfb005a42e96ab15a385f16d717495cf527c2bf17c87434567401d0dd0
+  data.tar.gz: 7b51570ad19e664e45ca69925619fdbdda6272f985d8627f4c247815b469de19cb11bdfa942433480bbc38792127a8b39e45e56c08c8c73ffe517318ad004396

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

@@ -144,12 +144,31 @@ module PWN
 
           pool = apply_preference({ items: pool }.merge(pref_fwd))
           pool.map do |entry|
-            schema = entry.schema
+            schema = entry.schema.merge(parameters: explicit_root_types(schema: entry.schema[:parameters]))
             schema = schema.merge(description: "#{schema[:description]} #{mcp[:description]}") if entry.name == 'mcp'
             { type: 'function', function: schema }
           end
         end
 
+        # Providers inspect union branches independently of their object parent.
+        # Inherit only along same-instance combinators, never into properties or
+        # array items (which may legitimately be scalar/object unions).
+        private_class_method def self.explicit_root_types(opts = {})
+          schema = opts[:schema]
+          return schema unless schema.is_a?(Hash)
+
+          result = schema.dup
+          type = schema[:type] || schema['type'] || opts[:inherited_type]
+          result[:type] = type if type && !schema.key?(:type) && !schema.key?('type')
+          %i[anyOf oneOf allOf].each do |combiner|
+            key = schema.key?(combiner) ? combiner : combiner.to_s
+            next unless schema[key].is_a?(Array)
+
+            result[key] = schema[key].map { |branch| explicit_root_types(schema: branch, inherited_type: type) }
+          end
+          result
+        end
+
         # Supported Method Parameters::
         # order = PWN::AI::Agent::Registry.preference_order(
         #   order: 'optional - Array of tool names; explicit nil/[] disables',

data/lib/pwn/ai/grok.rb

@@ -476,7 +476,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
@@ -497,8 +497,10 @@ module PWN
           nil
         end
       rescue RestClient::ExceptionWithResponse => e
-        puts "ERROR: #{e.message}: #{e.response}" unless opts[:quiet]
-        "#{e.message}: #{e.response}" if opts[:quiet]
+        # Keep the HTTP type/response for callers, and surface provider diagnostics
+        # instead of turning failed requests into nil or unparseable JSON text.
+        e.message = "Grok HTTP #{e.http_code} (#{http_method.to_s.upcase} #{rest_call}): #{e.response&.body}"
+        raise
       rescue StandardError => e
         case e.message
         when '400 Bad Request', '404 Resource Not Found'

data/lib/pwn/ai/ollama.rb

@@ -182,7 +182,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry

data/lib/pwn/ai/open_web_ui.rb

@@ -207,7 +207,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry

data/lib/pwn/version.rb

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

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

@@ -47,6 +47,33 @@ describe PWN::AI::Agent::Registry do
     expect(names.length).to eq(described_class::CORE_TOOLS.length)
   end
 
+  it 'exports explicitly object-typed root alternatives without changing registered schemas' do
+    described_class.discover
+    original = Marshal.dump(described_class.lookup(name: 'artifact_read').schema)
+    definitions = described_class.definitions(core_only: false, top_k: 0)
+    check = lambda do |schema|
+      %i[anyOf oneOf allOf].each do |key|
+        Array(schema[key]).each do |branch|
+          expect(branch[:type]).to eq('object')
+          check.call(branch)
+        end
+      end
+    end
+    definitions.each { |tool| check.call(tool[:function][:parameters]) }
+    tool = definitions.find { |entry| entry[:function][:name] == 'artifact_read' }
+    expect(tool[:function][:parameters][:anyOf].map { |branch| branch[:required] }).to eq([%w[handle], %w[path], %w[ref]])
+    expect(Marshal.dump(described_class.lookup(name: 'artifact_read').schema)).to eq(original)
+  end
+
+  it 'preserves property-level scalar unions and explicit branch types' do
+    schema = { 'type' => 'object', 'oneOf' => [{ 'required' => ['value'] }],
+               'properties' => { 'value' => { 'anyOf' => [{ 'type' => 'string' }, { 'type' => 'object' }] } } }
+    normalized = described_class.send(:explicit_root_types, schema: schema)
+    expect(normalized['oneOf'].first[:type]).to eq('object')
+    expect(normalized['properties']).to eq(schema['properties'])
+    expect(schema['oneOf'].first).to eq('required' => ['value'])
+  end
+
   it 'advertises the MCP broker for a named backend in the normal core-only prompt path' do
     described_class.discover
     request = 'Use combo.nation to inspect the menu catalog'

data/spec/lib/pwn/ai/grok_spec.rb

@@ -18,6 +18,111 @@ describe PWN::AI::Grok do
     expect(src).to match(/openai_wire_messages/)
   end
 
+  describe '.chat_with_tools HTTP failures' do
+    let(:messages) { [{ role: 'user', content: 'hello' }] }
+    let(:body) { '{"error":"Invalid schema: tools[0].function.parameters requires properties"}' }
+    let(:response) { instance_double(RestClient::Response, code: 400, body: body, to_s: body) }
+    let(:error) { RestClient::BadRequest.new(response) }
+
+    before do
+      stub_const('PWN::Env', { ai: { grok: { key: 'test-key', model: 'test-model' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).with(browser_type: :rest).and_return(browser: RestClient)
+      allow(PWN::AI::Agent::ToolGuard).to receive(:protect_http!)
+      allow(PWN::AI::Agent::PromptCache).to receive(:enabled?).and_return(false)
+      allow(PWN::Plugins::TTYSpinner).to receive(:stop)
+      allow(RestClient::Request).to receive(:execute).and_raise(error)
+    end
+
+    it 'serializes explicit artifact_read branch types from the real registry' do
+      tools = PWN::AI::Agent::Registry.definitions(core_only: true)
+      allow(RestClient::Request).to receive(:execute).and_return(
+        '{"choices":[{"message":{"role":"assistant","content":"hello"}}]}'
+      )
+
+      described_class.chat_with_tools(messages: messages, tools: tools)
+
+      expect(RestClient::Request).to have_received(:execute) do |request|
+        payload = JSON.parse(request[:payload])
+        artifact_read = payload.fetch('tools').find { |tool| tool.dig('function', 'name') == 'artifact_read' }
+        expect(artifact_read).not_to be_nil
+        branches = artifact_read.fetch('function').fetch('parameters').fetch('anyOf')
+        expect(branches).not_to be_empty
+        expect(branches).to all(include('type' => 'object'))
+      end
+    end
+
+    context 'when rate limits exhaust the retry budget' do
+      let(:body) { '{"error":"rate limit exceeded"}' }
+      let(:response) { instance_double(RestClient::Response, code: 429, body: body, to_s: body, headers: { retry_after: '2' }) }
+      let(:error) { RestClient::TooManyRequests.new(response) }
+
+      it 'raises the HTTP error after five attempts and four Retry-After waits' do
+        allow(described_class).to receive(:rand).with(0.3..5.0).and_return(0.5)
+        allow(described_class).to receive(:sleep)
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+
+        expect do
+          described_class.chat_with_tools(messages: messages)
+        end.to raise_error(RestClient::TooManyRequests) { |raised|
+          expect(raised.message).to include('HTTP 429', body)
+        }
+        expect(RestClient::Request).to have_received(:execute).exactly(5).times
+        expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+      end
+    end
+
+    context 'when the request times out' do
+      let(:error) { RestClient::Exceptions::ReadTimeout.new }
+
+      it 'preserves the default five attempts and nil on exhaustion' do
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).with(hash_including(timeout: 180)).exactly(5).times
+      end
+
+      it 'keeps quiet sidecars single-shot and silent' do
+        expect(PWN::AI::HttpRetry).not_to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages, quiet: true)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).once
+      end
+
+      it 'keeps short timeouts single-shot' do
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages, timeout: 10)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).with(hash_including(timeout: 10)).once
+      end
+
+      it 'returns the successful response after a transient timeout' do
+        calls = 0
+        allow(RestClient::Request).to receive(:execute) do
+          calls += 1
+          raise error if calls == 1
+
+          '{"choices":[{"message":{"role":"assistant","content":"hello"}}]}'
+        end
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        result = described_class.chat_with_tools(messages: messages)
+        expect(result.dig(:assistant_message, :content)).to eq('hello')
+        expect(RestClient::Request).to have_received(:execute).twice
+      end
+    end
+
+    [false, true].each do |quiet|
+      it "propagates actionable schema errors without printing (quiet=#{quiet})" do
+        expect do
+          expect do
+            described_class.chat_with_tools(messages: messages, quiet: quiet)
+          end.to raise_error(RestClient::BadRequest) { |raised|
+            expect(raised.response).to equal(response)
+            expect(raised.message).to include('Grok', 'HTTP 400', 'chat/completions', body)
+          }
+        end.not_to output.to_stdout
+        expect(RestClient::Request).to have_received(:execute).once
+        expect(PWN::Plugins::TTYSpinner).to have_received(:stop)
+      end
+    end
+  end
+
   it 'does not expose get_plan_usage' do
     expect(described_class).not_to respond_to(:get_plan_usage)
   end

data/spec/lib/pwn/ai/ollama_spec.rb

@@ -3,6 +3,23 @@
 require 'spec_helper'
 
 describe PWN::AI::Ollama do
+  [false, true].each do |quiet|
+    it "raises an actionable exhausted 429 instead of parsing error text (quiet=#{quiet})" do
+      stub_const('PWN::Env', { ai: { ollama: { model: 'fixture', base_uri: 'http://example.test' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).and_return(browser: RestClient)
+      response = instance_double(RestClient::Response, code: 429, body: 'rate limit exceeded', to_s: 'rate limit exceeded', headers: { retry_after: '2' })
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::TooManyRequests.new(response))
+      allow(described_class).to receive(:sleep)
+      allow(described_class).to receive(:rand).and_return(0.5)
+      allow(PWN::AI::HttpRetry).to receive(:report_event)
+      expect do
+        described_class.chat_with_tools(messages: [{ role: 'user', content: 'hello' }], quiet: quiet)
+      end.to raise_error(RuntimeError, /Ollama.*429.*rate limit exceeded/)
+      expect(RestClient::Request).to have_received(:execute).exactly(5).times
+      expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+    end
+  end
+
   it 'should display information for authors' do
     authors_response = PWN::AI::Ollama
     expect(authors_response).to respond_to :authors

data/spec/lib/pwn/ai/open_web_ui_spec.rb

@@ -3,6 +3,23 @@
 require 'spec_helper'
 
 describe PWN::AI::OpenWebUI do
+  [false, true].each do |quiet|
+    it "raises an actionable exhausted 429 instead of parsing error text (quiet=#{quiet})" do
+      stub_const('PWN::Env', { ai: { openwebui: { model: 'fixture', base_uri: 'http://example.test', key: 'fixture-key' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).and_return(browser: RestClient)
+      response = instance_double(RestClient::Response, code: 429, body: 'rate limit exceeded', to_s: 'rate limit exceeded', headers: { retry_after: '2' })
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::TooManyRequests.new(response))
+      allow(described_class).to receive(:sleep)
+      allow(described_class).to receive(:rand).and_return(0.5)
+      allow(PWN::AI::HttpRetry).to receive(:report_event)
+      expect do
+        described_class.chat_with_tools(messages: [{ role: 'user', content: 'hello' }], quiet: quiet)
+      end.to raise_error(RuntimeError, /Open WebUI.*429.*rate limit exceeded/)
+      expect(RestClient::Request).to have_received(:execute).exactly(5).times
+      expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+    end
+  end
+
   it 'should display information for authors' do
     authors_response = PWN::AI::OpenWebUI
     expect(authors_response).to respond_to :authors

data/third_party/pwn_rdoc.jsonl

@@ -685,6 +685,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.discover Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.discover`: Supported Method Parameters\n\nnames = PWN::AI::Agent::Registry.discover(\n\nforce: 'optional - re-require tool files even if already discovered (default false)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.domain_pin_names Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.domain_pin_names`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.eager_load! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.eager_load!`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.explicit_root_types Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.explicit_root_types`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.lookup Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.lookup`: Supported Method Parameters\n\nentry = PWN::AI::Agent::Registry.lookup(\n\nname: 'required - registered tool name'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.mcp_routing Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.mcp_routing`: "}]}

metadata

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