pwn 0.5.666 → 0.5.668

data/lib/pwn/ai/ollama.rb

@@ -7,17 +7,31 @@ require 'tty-spinner'
 
 module PWN
   module AI
-    # This plugin is used for interacting w/ Ollama's REST API using
-    # the 'rest' browser type of PWN::Plugins::TransparentBrowser.
-    # This is based on the following Ollama API Specification:
-    # https://api.openai.com/v1
+    # Direct client for a local/remote Ollama server REST API.
+    # No API key is required for a stock ollama serve (http://127.0.0.1:11434).
+    # Paths are native Ollama:
+    #   GET  /api/tags
+    #   POST /api/chat          (native tool_calls, options.num_ctx / num_predict)
+    #   POST /api/embed
+    #   POST /v1/chat/completions (OpenAI-compat shim)
+    # Spec: https://github.com/ollama/ollama/blob/main/docs/api.md
     module Ollama
+      DEFAULT_BASE_URI = 'http://127.0.0.1:11434'
+
+      private_class_method def self.real_config_value?(opts = {})
+        s = opts[:value].to_s.strip
+        return false if s.empty?
+        return false if s.match?(/\A(optional|required)\b/i)
+        return false if s.match?(/REDACTED/i)
+        return false if s.match?(/\A<{3}.*>{3}\z/)
+
+        true
+      end
+
       # Supported Method Parameters::
       # ollama_rest_call(
-      #   base_uri: 'required - base URI for the Ollama API',
-      #   token: 'required - ollama bearer token',
-      #   http_method: 'optional HTTP method (defaults to GET)
-      #   rest_call: 'required rest call to make per the schema',
+      #   http_method: 'optional HTTP method (defaults to GET)',
+      #   rest_call: 'required rest call path relative to base_uri (e.g. api/chat)',
       #   params: 'optional params passed in the URI or HTTP Headers',
       #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST',
       #   timeout: 'optional timeout in seconds (defaults to 900)',
@@ -26,24 +40,28 @@ module PWN
 
       private_class_method def self.ollama_rest_call(opts = {})
         engine = PWN::Env[:ai][:ollama]
-        raise 'ERROR: Jira Server Hash not found in PWN::Env.  Run i`pwn -Y default.yaml`, then `PWN::Env` for usage.' if engine.nil?
+        raise 'ERROR: Ollama engine hash not found in PWN::Env[:ai][:ollama]. Run `pwn -Y default.yaml`, then `PWN::Env` for usage.' if engine.nil?
 
-        base_uri = engine[:base_uri]
-        raise 'ERROR: base_uri must be provided in PWN::Env[:ai][:ollama][:base_uri]' if base_uri.nil?
+        base_uri = engine[:base_uri].to_s.strip
+        base_uri = DEFAULT_BASE_URI if base_uri.empty? || base_uri.match?(/\A(optional|required)\b/i)
+        base_uri = base_uri.chomp('/')
+
+        # Stock ollama needs no key. Only attach Authorization when the operator
+        # set a real key (e.g. reverse-proxy basic/JWT in front of ollama).
+        token = real_config_value?(value: engine[:key]) ? engine[:key].to_s.strip : nil
 
-        token = engine[:key] ||= PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Ollama (i.e. OpenAPI) Key')
         http_method = if opts[:http_method].nil?
                         :get
                       else
                         opts[:http_method].to_s.scrub.to_sym
                       end
-        rest_call = opts[:rest_call].to_s.scrub
+        rest_call = opts[:rest_call].to_s.scrub.sub(%r{\A/}, '')
         params = opts[:params]
 
         headers = {
-          content_type: 'application/json; charset=UTF-8',
-          authorization: "Bearer #{token}"
+          content_type: 'application/json; charset=UTF-8'
         }
+        headers[:authorization] = "Bearer #{token}" if token
 
         http_body = opts[:http_body]
         http_body ||= {}
@@ -101,9 +119,8 @@ module PWN
               #
               # ABSOLUTE DEADLINE: Net::HTTP read_timeout only fires on *idle*
               # gaps between chunks. A thinking model that dribbles tokens
-              # forever never idles out — the hung pwn-ai spinner on pts/8
-              # (2026-07-23) had already received 17MB+ after 25 minutes.
-              # Enforce a wall-clock deadline independent of chunk cadence.
+              # forever never idles out. Enforce a wall-clock deadline
+              # independent of chunk cadence.
               assembled = nil
               stream_err = nil
               deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout.to_f
@@ -123,7 +140,6 @@ module PWN
                     now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
                     if now > deadline
                       stream_err = "ERROR: Ollama stream absolute timeout after #{timeout}s for #{rest_call} (received #{bytes} bytes - model likely stuck in unbounded thinking; lower num_ctx / set num_predict)"
-                      # Stop reading; RestClient will tear down the socket.
                       raise stream_err
                     end
                     buf << chunk
@@ -157,7 +173,7 @@ module PWN
             end
 
           else
-            raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
+            raise "Unsupported HTTP Method #{http_method} for #{self} Plugin"
           end
           response
         rescue RestClient::TooManyRequests => e
@@ -168,9 +184,6 @@ module PWN
           retry
         end
       rescue RestClient::ExceptionWithResponse => e
-        # Never return nil here — chat_with_tools used to `return nil if response.nil?`
-        # which made the agent loop print "[pwn-ai] engine returned no message"
-        # with no actionable error. Raise so the caller / REPL surfaces the body.
         body = begin
           e.response.to_s[0, 800]
         rescue StandardError
@@ -195,13 +208,11 @@ module PWN
         thinking = opts[:thinking].to_s
         return '' if thinking.strip.empty?
 
-        # Common end-of-reasoning markers across distill/abliterated builds.
         markers = [
           %r{</think>}i,
           %r{</thinking>}i,
           /(?:\A|\n)\s*Final\s*Answer\s*:\s*/i,
           /(?:\A|\n)\s*Answer\s*:\s*/i,
-          # Inline form: "... Final Answer: <text>"
           /Final\s*Answer\s*:\s*/i
         ]
         markers.each do |rx|
@@ -221,7 +232,6 @@ module PWN
         rest_call = opts[:rest_call].to_s
 
         lines = body.each_line.map(&:strip).reject(&:empty?)
-        # Strip SSE "data: " prefix when present; drop the terminal [DONE].
         payloads = lines.filter_map do |line|
           line = line.sub(/\Adata:\s*/, '')
           next if line.empty? || line == '[DONE]'
@@ -233,9 +243,6 @@ module PWN
           end
         end
         if payloads.empty?
-          # Preserve a parseable shape so callers don't NPE, but mark the
-          # failure explicitly — blank NDJSON previously became {} → nil msg
-          # → silent "[pwn-ai] engine returned no message".
           return {
             message: {
               role: 'assistant',
@@ -248,6 +255,7 @@ module PWN
         end
 
         openai_compat = rest_call.include?('/v1/') ||
+                        rest_call.start_with?('v1/') ||
                         payloads.any? { |p| p.key?(:choices) }
 
         if openai_compat
@@ -258,8 +266,6 @@ module PWN
       end
 
       # Native Ollama /api/chat NDJSON → single-object JSON string.
-      # Each chunk carries message.content delta (and optionally tool_calls);
-      # the final chunk has done:true plus timing/usage fields.
       private_class_method def self.assemble_native_chat_stream(opts = {})
         payloads = opts[:payloads]
         final = payloads.reverse.find { |p| p[:done] } || payloads.last
@@ -274,16 +280,10 @@ module PWN
           content << msg[:content].to_s if msg[:content]
           thinking << msg[:thinking].to_s if msg[:thinking]
           Array(msg[:tool_calls]).each do |tc|
-            # Tool calls typically arrive complete in one chunk; append uniques.
             tool_calls << tc unless tool_calls.any? { |existing| existing == tc }
           end
         end
 
-        # Thinking-only models (Qwen3 / DeepSeek-R1 style via Ollama) often
-        # emit message.thinking deltas with message.content left blank. The
-        # agent loop only displays msg[:content], so that looked like "no
-        # response". Promote thinking → content when there is nothing else
-        # visible and no tool_calls to act on.
         content = visible_from_thinking(thinking: thinking) if content.empty? && !thinking.empty? && tool_calls.empty?
 
         message = { role: role, content: content }
@@ -367,13 +367,92 @@ module PWN
       # response = PWN::AI::Ollama.get_models
 
       public_class_method def self.get_models
-        models = ollama_rest_call(rest_call: 'ollama/api/tags')
+        models = ollama_rest_call(rest_call: 'api/tags')
 
         JSON.parse(models, symbolize_names: true)[:models]
       rescue StandardError => e
         raise e
       end
 
+      # Coerce OpenAI-wire message history into Ollama-native shapes before
+      # POST /api/chat (or Open WebUI /ollama/api/chat):
+      # - function.arguments must be a Hash/Array object, not a JSON string
+      #   (string args → HTTP 400 "can't find closing '}' symbol")
+      # - assistant content nil + tool_calls → "" (Open WebUI form validation)
+      private_class_method def self.parse_tool_arguments_object(opts = {})
+        raw = opts[:arguments]
+        case raw
+        when Hash, Array then raw
+        when nil then {}
+        when String
+          s = raw.strip
+          return {} if s.empty?
+
+          begin
+            parsed = JSON.parse(s, symbolize_names: true)
+            return parsed if parsed.is_a?(Hash) || parsed.is_a?(Array)
+          rescue JSON::ParserError
+            nil
+          end
+          { value: s }
+        else
+          { value: raw.to_s }
+        end
+      end
+
+      private_class_method def self.normalize_messages_for_ollama(opts = {})
+        Array(opts[:messages]).filter_map do |m|
+          next unless m.is_a?(Hash)
+
+          role = (m[:role] || m['role']).to_s
+          out = { role: role }
+
+          tcs = m[:tool_calls] || m['tool_calls']
+          has_tcs = false
+          if tcs
+            wired = Array(tcs).filter_map do |tc|
+              next unless tc.is_a?(Hash)
+
+              fn = tc[:function] || tc['function'] || {}
+              name = fn[:name] || fn['name'] || tc[:name] || tc['name']
+              args = fn[:arguments] || fn['arguments'] || tc[:arguments] || tc['arguments']
+              {
+                id: (tc[:id] || tc['id'] || "call_#{SecureRandom.hex(4)}").to_s,
+                type: (tc[:type] || tc['type'] || 'function').to_s,
+                function: {
+                  name: name.to_s,
+                  arguments: parse_tool_arguments_object(arguments: args)
+                }
+              }
+            end
+            unless wired.empty?
+              out[:tool_calls] = wired
+              has_tcs = true
+            end
+          end
+
+          if m.key?(:content) || m.key?('content')
+            content = m.key?(:content) ? m[:content] : m['content']
+            out[:content] = case content
+                            when nil then has_tcs ? '' : nil
+                            when String then content
+                            when Hash, Array then JSON.generate(content)
+                            else content.to_s
+                            end
+          elsif has_tcs
+            out[:content] = ''
+          end
+
+          name = m[:name] || m['name']
+          out[:name] = name.to_s if name && !name.to_s.empty?
+
+          tcid = m[:tool_call_id] || m['tool_call_id']
+          out[:tool_call_id] = tcid.to_s if tcid && !tcid.to_s.empty?
+
+          out
+        end
+      end
+
       # Supported Method Parameters::
       # response = PWN::AI::Ollama.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -385,32 +464,13 @@ module PWN
       #   spinner: 'optional - display spinner (default false)'
       # )
       #
-      # Returns a Hash with :choices / :assistant_message intact (including
-      # :message[:tool_calls]) — used by PWN::AI::Agent::Loop.
-      #
-      # LOCAL-MODEL SCAFFOLDING
-      # -----------------------
-      # This hits Ollama's NATIVE /api/chat (not the OpenAI-compat shim) so
-      # the following actually take effect:
-      #   options.num_ctx     - Ollama defaults to 2048; the pwn-ai system
-      #                         prompt alone blows that. Defaults here to
-      #                         PWN::Env[:ai][:ollama][:num_ctx] || 32768.
-      #   options.temperature - forced to 0.1 on tool-bearing turns for
-      #                         deterministic tool selection; engine[:temp]
-      #                         (creative) on the final text-only turn.
-      #   format              - ONLY set when engine[:format] is explicitly
-      #                         configured. Never default to 'json' when
-      #                         tools: are present — that fights native
-      #                         tool_calls and kills mid-loop tool use.
-      #   keep_alive: '30m'   - avoids reload latency between iterations.
-      # tool_calls come back with function.arguments as a Hash (not a JSON
-      # string), which PWN::AI::Agent::Dispatch.parse_args handles.
-      # Streaming is ON (stream: true): ollama_rest_call assembles NDJSON
-      # chunks back into a single response so the return shape is unchanged.
+      # Hits Ollama NATIVE POST /api/chat so options.num_ctx / num_predict /
+      # keep_alive take effect. Streaming is ON; ollama_rest_call assembles
+      # NDJSON chunks back into a single response.
 
       public_class_method def self.chat_with_tools(opts = {})
         engine   = PWN::Env[:ai][:ollama]
-        messages = opts[:messages]
+        messages = normalize_messages_for_ollama(messages: opts[:messages])
         raise 'ERROR: messages array is required' if messages.nil? || messages.empty?
 
         model = opts[:model] ||= engine[:model]
@@ -422,10 +482,6 @@ module PWN
         tools_present = opts[:tools] && !opts[:tools].empty?
         tool_temp     = (engine[:tool_temp] || 0.1).to_f
         num_ctx       = (engine[:num_ctx]   || 32_768).to_i
-        # Hard cap generation length. Thinking models (Qwen3 / R1-style)
-        # otherwise stream unbounded message.thinking tokens until the
-        # idle read_timeout (default 900s) — which looks like a 15–25 min
-        # "stuck spinner" while bytes keep arriving on the socket.
         num_predict   = (engine[:num_predict] || 4_096).to_i
         keep_alive    = engine[:keep_alive] || '30m'
 
@@ -442,10 +498,6 @@ module PWN
         }
         if tools_present
           http_body[:tools] = opts[:tools]
-          # 0.2 — omit format when tools are present unless the operator
-          # explicitly set PWN::Env[:ai][:ollama][:format]. Forcing 'json'
-          # races the native tool_calls sampler and produces "can't call tools"
-          # mid-loop on many local models.
           fmt = engine[:format]
           http_body[:format] = fmt unless fmt.nil? || fmt.to_s.empty?
         end
@@ -453,7 +505,7 @@ module PWN
 
         response = ollama_rest_call(
           http_method: :post,
-          rest_call: 'ollama/api/chat',
+          rest_call: 'api/chat',
           http_body: http_body,
           timeout: opts[:timeout],
           spinner: opts[:spinner]
@@ -461,7 +513,6 @@ module PWN
         raise 'ERROR: Ollama chat_with_tools received empty response from ollama_rest_call' if response.nil? || (response.respond_to?(:empty?) && response.empty?)
 
         json_resp = JSON.parse(response, symbolize_names: true)
-        # Normalise native /api/chat shape to what Loop.normalize_llm expects.
         msg = json_resp[:message] || json_resp.dig(:choices, 0, :message)
         if msg.is_a?(Hash)
           content = msg[:content].to_s
@@ -482,7 +533,7 @@ module PWN
       # response = PWN::AI::Ollama.chat(
       #   request: 'required - message to Ollama'
       #   model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:ollama][:model])',
-      #   temp: 'optional - creative response float (deafults to PWN::Env[:ai][:ollama][:temp])',
+      #   temp: 'optional - creative response float (defaults to PWN::Env[:ai][:ollama][:temp])',
       #   system_role_content: 'optional - context to set up the model behavior for conversation (Default: PWN::Env[:ai][:ollama][:system_role_content])',
       #   response_history: 'optional - pass response back in to have a conversation',
       #   speak_answer: 'optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
@@ -503,12 +554,11 @@ module PWN
         temp = opts[:temp].to_f ||= engine[:temp].to_f
         temp = 1 if temp.zero?
 
-        rest_call = 'ollama/v1/chat/completions'
+        # OpenAI-compat shim on the ollama server (no api-key needed).
+        rest_call = 'v1/chat/completions'
 
         response_history = opts[:response_history]
 
-        max_tokens = response_history[:usage][:total_tokens] unless response_history.nil?
-
         system_role_content = opts[:system_role_content] ||= engine[:system_role_content]
 
         system_role = {
@@ -522,7 +572,6 @@ module PWN
         }
 
         response_history ||= { choices: [system_role] }
-        choices_len = response_history[:choices].length
 
         http_body = {
           model: model,
@@ -560,8 +609,6 @@ module PWN
         if speak_answer
           answer = assistant_resp[:content]
           text_path = "/tmp/#{SecureRandom.hex}.pwn_voice"
-          # answer = json_resp[:choices].last[:text]
-          # answer = json_resp[:choices].last[:content] if gpt
           File.write(text_path, answer)
           PWN::Plugins::Voice.text_to_speech(text_path: text_path)
           File.unlink(text_path)
@@ -597,6 +644,12 @@ module PWN
             spinner: 'optional - display spinner (defaults to false)'
           )
 
+          response = #{self}.chat_with_tools(
+            messages: 'required - messages array',
+            tools: 'optional - OpenAI tools array',
+            model: 'optional - overrides PWN::Env[:ai][:ollama][:model]'
+          )
+
           #{self}.authors
         "
       end

data/lib/pwn/ai/open_ai.rb

@@ -555,6 +555,9 @@ module PWN
         messages = opts[:messages]
         raise 'ERROR: messages array is required' if messages.nil? || messages.empty?
 
+        # OpenAI rejects Hash function.arguments / Hash content (422 map → string).
+        messages = PWN::AI::Agent::Loop.openai_wire_messages(messages: messages) if defined?(PWN::AI::Agent::Loop) && PWN::AI::Agent::Loop.respond_to?(:openai_wire_messages)
+
         model = opts[:model] ||= engine[:model]
 
         reasoning = reasoning_model?(model: model)