pwn 0.5.783 → 0.5.785

data/lib/pwn/ai/cli.rb

@@ -109,12 +109,13 @@ module PWN
           prompt = (opts[:input] || $stdin).read if prompt == '-'
           raise ArgumentError, '--ai requires a non-empty prompt' if prompt.strip.empty?
 
-          outcome = nil
           contract = JSON.parse(File.read(parsed[:verification_contract]), symbolize_names: true) if parsed[:verification_contract]
-          output.puts(PWN::AI::Agent::Loop.run(request: prompt, session_id: session[:id], enabled_toolsets: PWN::Env.dig(:ai, :agent, :toolsets),
-                                               verification_contract: contract,
-                                               require_resumable: parsed.key?(:resume_session),
-                                               on_outcome: ->(row) { outcome = row }))
+          response = mission_request(request: prompt, session_id: session[:id], enabled_toolsets: PWN::Env.dig(:ai, :agent, :toolsets),
+                                     verification_contract: contract, require_resumable: parsed.key?(:resume_session))
+          return response[:exit_status] if response[:exit_status]
+
+          output.puts(response[:final])
+          outcome = response[:outcome]
           return outcome && outcome[:status] == 'complete' ? 0 : 1
         else
           PWN::Plugins::REPL.start(ai_session_id: session[:id], ai_session_lease: session[:lease])
@@ -124,6 +125,34 @@ module PWN
         PWN::Sessions.deactivate(lease: session[:lease]) if session
       end
 
+      private_class_method def self.mission_request(opts = {})
+        reader, writer = IO.pipe
+        mission = PWN::AI::Agent::MissionNamespace.new(descriptor: { operation: :loop, options: opts }, fds: { 4 => writer })
+        writer.close
+        raw = reader.read
+        mission.wait
+        return { exit_status: mission.status.exitstatus || 1 } if raw.empty?
+
+        response = JSON.parse(raw, symbolize_names: true)
+        raise IOError, response[:error] if response[:error]
+
+        response
+      ensure
+        mission&.close
+        [reader, writer].compact.each { |io| io.close unless io.closed? }
+      end
+
+      private_class_method def self.mission_entry(opts = {})
+        writer = PWN::AI::Agent::MissionNamespace.io(4)
+        outcome = nil
+        final = PWN::AI::Agent::Loop.run(opts.fetch(:options).merge(on_outcome: ->(row) { outcome = row }))
+        writer.write(JSON.generate(final: final, outcome: outcome))
+      rescue StandardError => e
+        writer.write(JSON.generate(error: "#{e.class}: #{e.message}"))
+      ensure
+        writer.close
+      end
+
       private_class_method def self.validate_request_options(opts = {})
         parsed = opts[:parsed]
         selected = parsed[:resume_session] || parsed[:replace_session]

data/lib/pwn/ai/gemini.rb

@@ -238,6 +238,7 @@ module PWN
           }]
           http_body[:toolConfig] = gemini_tool_config(choice: opts[:tool_choice]) if opts[:tool_choice]
         end
+        http_body = PWN::AI::ServerTools.attach(engine: :gemini, http_body: http_body, request: opts)
 
         response = gemini_rest_call(
           http_method: :post,

data/lib/pwn/ai/grok.rb

@@ -167,27 +167,13 @@ module PWN
         dec_path = dec_path.to_s.strip
         dec_path = "#{env_path}.decryptor" if dec_path.empty?
 
-        unless File.exist?(env_path) && File.exist?(dec_path) && File.readable?(dec_path)
+        unless File.exist?(env_path)
           puts '[*] INFO: Grok OAuth tokens updated in this session only; ' \
-               "persistence to #{env_path} skipped (missing decryption artifacts" \
-               "#{" at #{dec_path}" unless dec_path.empty?})."
+               "persistence to #{env_path} skipped (missing vault)."
           return false
         end
 
-        decryptor = YAML.load_file(dec_path, symbolize_names: true)
-        key = decryptor.is_a?(Hash) ? decryptor[:key] : nil
-        iv  = decryptor.is_a?(Hash) ? decryptor[:iv]  : nil
-        unless real_config_value?(value: key) && real_config_value?(value: iv)
-          puts '[*] INFO: Grok OAuth tokens updated in this session only; ' \
-               "persistence to #{env_path} skipped (decryptor at #{dec_path} " \
-               'has no usable key/iv).'
-          return false
-        end
-
-        PWN::Plugins::Vault.decrypt(file: env_path, key: key, iv: iv)
-        begin
-          cfg = YAML.load_file(env_path, symbolize_names: true)
-          cfg = {} unless cfg.is_a?(Hash)
+        PWN::Plugins::Vault.update(file: env_path, decryptor_file: dec_path) do |cfg|
           cfg[:ai] = {} unless cfg[:ai].is_a?(Hash)
           cfg[:ai][:grok] = {} unless cfg[:ai][:grok].is_a?(Hash)
           vault_oauth = cfg[:ai][:grok][:oauth]
@@ -196,19 +182,11 @@ module PWN
           vault_oauth[:bearer_token] = oauth[:bearer_token]
           vault_oauth[:refresh_token] = oauth[:refresh_token] if real_config_value?(value: oauth[:refresh_token])
           vault_oauth[:expires_at] = oauth[:expires_at] if oauth.key?(:expires_at) && !oauth[:expires_at].nil?
-
-          # Match PWN::Config.default_env YAML style (string keys, no leading ':').
-          yaml_env = YAML.dump(cfg).gsub(/^(\s*):/, '\1')
-          File.write(env_path, yaml_env)
-          File.chmod(0o600, env_path)
-        ensure
-          # Always re-encrypt with the IDENTICAL key + iv — never rotate.
-          PWN::Plugins::Vault.encrypt(file: env_path, key: key, iv: iv)
         end
 
         true
       rescue StandardError => e
-        warn "[!] Grok OAuth vault persistence failed (session tokens still updated): #{e.class}: #{e.message}"
+        warn "[!] Grok OAuth vault persistence failed (session tokens still updated): #{e.class}"
         false
       end
 
@@ -496,7 +474,7 @@ module PWN
           end
           retry if retry_count < max_attempts
 
-          raise e if Thread.current[:pwn_provider_attempt_owner]
+          raise e if Thread.current[:pwn_provider_attempt_owner] || Thread.current[:pwn_session_title]
 
           nil
         end
@@ -554,6 +532,30 @@ module PWN
         nil
       end
 
+      private_class_method def self.hosted_responses(opts = {})
+        input = Array(opts[:messages]).filter_map do |msg|
+          next unless msg.is_a?(Hash)
+
+          role = (msg[:role] || msg['role']).to_s
+          content = msg[:content] || msg['content']
+          next if content.to_s.empty?
+
+          { role: role, content: content.to_s }
+        end
+        raw = grok_rest_call(
+          http_method: :post,
+          rest_call: 'responses',
+          http_body: { model: opts[:model], input: input, tools: PWN::AI::ServerTools.wire(engine: :grok, names: opts[:names]), stream: false },
+          timeout: opts[:timeout],
+          spinner: opts[:spinner],
+          quiet: opts[:quiet]
+        )
+        parsed = JSON.parse(raw.to_s, symbolize_names: true)
+        text = parsed[:output_text].to_s
+        message = { role: 'assistant', content: text }
+        { choices: [{ message: message }], assistant_message: message }
+      end
+
       # Supported Method Parameters::
       # response = PWN::AI::Grok.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -611,6 +613,12 @@ module PWN
         http_body[:tool_choice] = opts[:tool_choice] if opts[:tool_choice]
         effort = opts[:reasoning_effort].to_s
         http_body[:reasoning_effort] = effort unless effort.empty? || effort == 'none'
+        hosted = Array(opts[:server_tools]).map(&:to_s).reject(&:empty?)
+        if hosted.any?
+          raise ArgumentError, 'xAI hosted tools use the Responses API and are not mixed into chat/completions client tools' if opts[:tools] && !opts[:tools].empty?
+
+          return hosted_responses(model: model, messages: messages, names: hosted, timeout: timeout, spinner: spinner, quiet: opts[:quiet])
+        end
 
         response = grok_rest_call(
           http_method: :post,
@@ -690,6 +698,8 @@ module PWN
           temperature: temp,
           stream: false
         }
+        effort = opts[:reasoning_effort].to_s
+        http_body[:reasoning_effort] = effort unless effort.empty?
 
         if response_history[:choices].length > 1
           response_history[:choices][1..-1].each do |message|
@@ -787,7 +797,8 @@ module PWN
             timeout: 'optional - seconds (default 180)',
             spinner: 'optional - display spinner (default false)',
             quiet: 'optional - quiet value consumed by #chat_with_tools',
-            reasoning_effort: 'optional - Grok reasoning effort (default medium; none disables thinking)'
+            reasoning_effort: 'optional - Grok reasoning effort (default medium; none disables thinking)',
+            server_tools: 'optional - hosted tool names such as web_search; sent on the Responses API only when client tools are omitted'
           )
 
           # Run chat and return its result

data/lib/pwn/ai/ollama.rb

@@ -198,7 +198,7 @@ module PWN
           end
           retry if retry_count < max_attempts
 
-          raise e if Thread.current[:pwn_provider_attempt_owner]
+          raise e if Thread.current[:pwn_provider_attempt_owner] || Thread.current[:pwn_session_title]
 
           nil
         rescue StandardError => e
@@ -671,6 +671,7 @@ module PWN
         end
         http_body[:tool_choice] = opts[:tool_choice] if opts[:tool_choice]
         http_body[:think] = think_wire(reasoning_effort: opts[:reasoning_effort], think: opts[:think])
+        raise ArgumentError, 'Ollama has no server-side tool workspace. Its tools are client-executed.' if Array(opts[:server_tools]).any?
 
         response = ollama_rest_call(
           http_method: :post,
@@ -837,7 +838,8 @@ module PWN
             timeout: 'optional - seconds (default 900)',
             spinner: 'optional - display spinner (default false)',
             think: 'optional - true enables Ollama think (default true; false disables)',
-            reasoning_effort: 'optional - think level from /api/show thinking.values'
+            reasoning_effort: 'optional - think level from /api/show thinking.values',
+            server_tools: 'optional - rejected; Ollama has no server-side tool workspace'
           )
 
           # Run chat and return its result

data/lib/pwn/ai/open_ai.rb

@@ -172,7 +172,6 @@ module PWN
       # bearer lives in-session only.
       private_class_method def self.persist_oauth_to_vault(opts = {})
         oauth = opts[:oauth]
-        return false if Thread.current[:pwn_request_runtime]
         return false unless oauth.is_a?(Hash)
         return false unless real_config_value?(value: oauth[:bearer_token])
 
@@ -187,32 +186,15 @@ module PWN
         dec_path = dec_path.to_s.strip
         dec_path = "#{env_path}.decryptor" if dec_path.empty?
 
-        unless File.exist?(env_path) && File.exist?(dec_path) && File.readable?(dec_path)
+        unless File.exist?(env_path)
           puts '[*] INFO: OpenAI OAuth tokens updated in this session only; ' \
-               "persistence to #{env_path} skipped (missing decryption artifacts" \
-               "#{" at #{dec_path}" unless dec_path.empty?})."
+               "persistence to #{env_path} skipped (missing vault)."
           return false
         end
 
-        decryptor = YAML.load_file(dec_path, symbolize_names: true)
-        key = decryptor.is_a?(Hash) ? decryptor[:key] : nil
-        iv  = decryptor.is_a?(Hash) ? decryptor[:iv]  : nil
-        unless real_config_value?(value: key) && real_config_value?(value: iv)
-          puts '[*] INFO: OpenAI OAuth tokens updated in this session only; ' \
-               "persistence to #{env_path} skipped (decryptor at #{dec_path} " \
-               'has no usable key/iv).'
-          return false
-        end
-
-        # Work on a private sibling; never decrypt the live vault in place.
-        # Rename only after encryption succeeds, preserving the old vault on
-        # write/encryption errors and keeping the existing key + iv intact.
-        Tempfile.create(['.pwn-openai-oauth-', '.yaml'], File.dirname(env_path)) do |temp|
-          temp.write(File.binread(env_path))
-          temp.flush
-          PWN::Plugins::Vault.decrypt(file: temp.path, key: key, iv: iv)
-          cfg = YAML.load_file(temp.path, symbolize_names: true)
-          cfg = {} unless cfg.is_a?(Hash)
+        # The shared updater resolves hardware or legacy credentials, keeps
+        # plaintext in memory and publishes only encrypted bytes atomically.
+        PWN::Plugins::Vault.update(file: env_path, decryptor_file: dec_path) do |cfg|
           cfg[:ai] = {} unless cfg[:ai].is_a?(Hash)
           cfg[:ai][:openai] = {} unless cfg[:ai][:openai].is_a?(Hash)
           vault_oauth = cfg[:ai][:openai][:oauth]
@@ -223,13 +205,6 @@ module PWN
           vault_oauth[:id_token] = oauth[:id_token] if real_config_value?(value: oauth[:id_token])
           vault_oauth[:account_id] = oauth[:account_id] if real_config_value?(value: oauth[:account_id])
           vault_oauth[:expires_at] = oauth[:expires_at] if oauth.key?(:expires_at) && !oauth[:expires_at].nil?
-
-          # Match PWN::Config.default_env YAML style (string keys, no leading ':').
-          yaml_env = YAML.dump(cfg).gsub(/^(\s*):/, '\1')
-          File.write(temp.path, yaml_env)
-          PWN::Plugins::Vault.encrypt(file: temp.path, key: key, iv: iv)
-          temp.fsync
-          File.rename(temp.path, env_path)
         end
 
         true
@@ -563,7 +538,7 @@ module PWN
           end
           retry if retry_count < max_attempts
 
-          raise e if oauth_selected || Thread.current[:pwn_provider_attempt_owner]
+          raise e if oauth_selected || Thread.current[:pwn_provider_attempt_owner] || Thread.current[:pwn_session_title]
 
           nil
         end
@@ -717,6 +692,7 @@ module PWN
             reasoning_effort: effort
           )
         end
+        http_body = PWN::AI::ServerTools.attach(engine: :openai, http_body: http_body, request: opts)
 
         response = open_ai_rest_call(
           http_method: :post,
@@ -1039,7 +1015,10 @@ module PWN
         }
         # Reasoning models reject sampler params (temperature, top_p, etc.)
         http_body[:temperature] = temp unless reasoning
-        http_body[:reasoning_effort] = opts[:reasoning_effort] if reasoning && opts[:reasoning_effort]
+        effort = opts[:reasoning_effort].to_s
+        if reasoning && !effort.empty?
+          http_body[:reasoning_effort] = effort == 'none' ? 'minimal' : effort
+        end
 
         response = open_ai_rest_call(
           http_method: :post,

data/lib/pwn/ai/open_web_ui.rb

@@ -223,7 +223,7 @@ module PWN
           end
           retry if retry_count < max_attempts
 
-          raise e if Thread.current[:pwn_provider_attempt_owner]
+          raise e if Thread.current[:pwn_provider_attempt_owner] || Thread.current[:pwn_session_title]
 
           nil
         end
@@ -650,6 +650,47 @@ module PWN
         effort
       end
 
+      # Supported Method Parameters::
+      # rows = PWN::AI::OpenWebUI.workspace_tools(
+      #   refresh: 'optional - true ignores a cached workspace tool list',
+      #   timeout: 'optional - seconds for the tool list request (default 30)'
+      # )
+      public_class_method def self.workspace_tools(opts = {})
+        refresh = opts[:refresh]
+        cached = Thread.current[:pwn_openwebui_workspace_tools]
+        return cached if cached && !refresh
+
+        raw = openwebui_rest_call(http_method: :get, rest_call: 'api/v1/tools/', timeout: opts[:timeout] || 30, quiet: true)
+        text = raw.is_a?(String) ? raw : raw.to_s
+        parsed = text.strip.empty? ? [] : JSON.parse(text)
+        rows = parsed.is_a?(Hash) ? (parsed['data'] || parsed[:data] || []) : parsed
+        listed = Array(rows).filter_map do |row|
+          next unless row.is_a?(Hash)
+
+          id = row['id'] || row[:id]
+          name = row['name'] || row[:name]
+          next if id.to_s.empty?
+
+          meta = row['meta'] || row[:meta] || {}
+          { id: id.to_s, name: name.to_s, description: meta['description'] || meta[:description] || row['description'] || row[:description] }
+        end
+        Thread.current[:pwn_openwebui_workspace_tools] = listed
+        listed
+      end
+
+      private_class_method def self.server_tool_ids(opts = {})
+        names = Array(opts[:names]).map(&:to_s).reject(&:empty?)
+        return [] if names.empty?
+
+        listed = workspace_tools
+        names.map do |name|
+          row = listed.find { |item| item[:id] == name || item[:name].casecmp?(name) }
+          raise ArgumentError, "Open WebUI workspace has no tool #{name}" unless row
+
+          row[:id]
+        end
+      end
+
       # Supported Method Parameters::
       # response = PWN::AI::OpenWebUI.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -704,6 +745,7 @@ module PWN
         end
         http_body[:tool_choice] = opts[:tool_choice] if opts[:tool_choice]
         http_body[:think] = think_wire(reasoning_effort: opts[:reasoning_effort], think: opts[:think])
+        raise ArgumentError, 'Open WebUI workspace tools do not run on the proxied Ollama chat path. Use chat(server_tools:) or workspace_tool.' if Array(opts[:server_tools]).any?
 
         response = openwebui_rest_call(
           http_method: :post,
@@ -797,6 +839,13 @@ module PWN
           messages: http_body[:messages],
           fold_into_user: strict_system_template?(model: model)
         )
+        server_ids = server_tool_ids(names: opts[:server_tools])
+        if server_ids.any?
+          http_body[:stream] = false
+          http_body[:tool_ids] = server_ids
+          http_body[:params] = { function_calling: 'legacy' }
+          http_body.delete(:tools)
+        end
 
         timeout = opts[:timeout]
         spinner = opts[:spinner]
@@ -809,7 +858,8 @@ module PWN
           spinner: spinner
         )
 
-        json_resp = JSON.parse(response, symbolize_names: true)
+        raw = response.is_a?(String) ? response : response.to_s
+        json_resp = JSON.parse(raw, symbolize_names: true)
         assistant_resp = json_resp[:choices].first[:message]
         if assistant_resp.is_a?(Hash)
           content = assistant_resp[:content].to_s
@@ -857,6 +907,12 @@ module PWN
             fallback: 'optional - false skips the catalog list when the direct route misses'
           )
 
+          # List workspace tools installed for this Open WebUI user, including Ask Jev.
+          #{self}.workspace_tools(
+            refresh: 'optional - true ignores a cached workspace tool list',
+            timeout: 'optional - seconds for the tool list request (default 30)'
+          )
+
           # Run chat with tools and return its result
           #{self}.chat_with_tools(
             messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -867,7 +923,8 @@ module PWN
             timeout: 'optional - seconds (default 900)',
             spinner: 'optional - display spinner (default false)',
             think: 'optional - true enables backend think (default true; false disables)',
-            reasoning_effort: 'optional - think level when the proxied model publishes named levels'
+            reasoning_effort: 'optional - think level when the proxied model publishes named levels',
+            server_tools: 'optional - rejected here; workspace tools use chat(server_tools:) or workspace_tool'
           )
 
           # Run chat and return its result
@@ -879,7 +936,8 @@ module PWN
             response_history: 'optional - pass response back in to have a conversation',
             speak_answer: 'optional - optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
             timeout: 'optional - optional timeout in seconds (defaults to 900)',
-            spinner: 'optional - display spinner (defaults to false)'
+            spinner: 'optional - display spinner (defaults to false)',
+            server_tools: 'optional - workspace tool names or ids, such as Ask Jev; the server executes them and this request omits client tools'
           )
 
           # Print the AUTHOR(S) string for this module.

data/lib/pwn/ai/router.rb

@@ -59,7 +59,7 @@ module PWN
 
         extractive(text: text)
       rescue StandardError
-        return '' if session
+        raise if session
 
         extractive(text: text)
       end
@@ -162,15 +162,65 @@ module PWN
         mod = Object.const_get(const)
         return nil unless mod.respond_to?(:chat)
 
-        resp = mod.chat(request: opts[:request], model: endpoint[:model], spinner: false, quiet: true, timeout: 8)
-        text = resp.is_a?(Hash) ? (resp[:content] || resp['content'] || resp.dig(:choices, -1, :content)).to_s : resp.to_s
+        resp = mod.chat(
+          request: opts[:request],
+          model: endpoint[:model],
+          spinner: false,
+          quiet: true,
+          timeout: opts[:session] ? 90 : 8,
+          reasoning_effort: (opts[:session] ? 'none' : nil)
+        )
+        text = response_text(response: resp)
         text.strip.empty? ? nil : text
       rescue StandardError
+        raise if opts[:session]
+
         nil
       ensure
         Thread.current[:pwn_session_title] = previous_title_worker
       end
 
+      # Only decode documented assistant-content locations, never container inspect
+      # strings, reasoning blocks, tool arguments or echoed user messages.
+      private_class_method def self.response_text(opts = {})
+        response = opts[:response]
+        return response if response.is_a?(String)
+        return '' unless response.is_a?(Hash)
+
+        row = response.transform_keys(&:to_s)
+        return JSON.generate(row) if row['title'].is_a?(String) && row['summary'].is_a?(String)
+        return content_text(content: row['content']) if row.key?('content')
+
+        choice = Array(row['choices']).last
+        if choice.is_a?(Hash)
+          choice = choice.transform_keys(&:to_s)
+          message = choice['message'] || choice
+          if message.is_a?(Hash)
+            message = message.transform_keys(&:to_s)
+            return '' if message['role'] && message['role'] != 'assistant'
+
+            return content_text(content: message['content'])
+          end
+        end
+        message = row['message']
+        return content_text(content: message[:content] || message['content']) if message.is_a?(Hash)
+
+        ''
+      end
+
+      private_class_method def self.content_text(opts = {})
+        content = opts[:content]
+        return content if content.is_a?(String)
+        return '' unless content.is_a?(Array)
+
+        content.filter_map do |block|
+          next unless block.is_a?(Hash)
+
+          block = block.transform_keys(&:to_s)
+          block['text'] if %w[text output_text].include?(block['type']) && block['text'].is_a?(String)
+        end.join
+      end
+
       private_class_method def self.active_session_endpoint
         engine = env_dig(keys: %i[ai active]).to_s.downcase
         { engine: engine, model: env_dig(keys: [:ai, engine.to_sym, :model]) }