ace-llm-providers-cli 0.34.0 → 0.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a2381e3344c0e1e229d1a2594761f92eec1f8af7bee3950bbccd6edd06edd34
-  data.tar.gz: 60e39f3cc0468a797a75affc1254703c99f6b49dd41cba8c1f8f141fe2654b01
+  metadata.gz: f25fb8b3c59151cc9e4e46f49cd9eae4d2d06b6fca7052422a60b1ab0129cc24
+  data.tar.gz: 4f37a1d94452b1f3fb06f37d47d3407c2c3e1c3e0e8cf40eb2d38756f1920b16
 SHA512:
-  metadata.gz: df4f6c5788a4a461ce1dab3be11ba0c9644c584308f6d553d28a3c97ec4e2248fa9a936765815cf4c64407cd37ec9d11b2e6a054459a7aa924c7b391dd7d9d2a
-  data.tar.gz: af0ccb22aee51c204e5ec9c932c41e6a1f2369e75574511175f0d939fcedf8ec0c24acfe305ddf2a4fc2622a5c41981b2a26359711538b2f8371971418ce21d3
+  metadata.gz: 2124492c17917caf053a5ad03014087c5c1fe75c3336cb9e44777d6858829ff6b1e02cf1552c05b1f2c9c4afed6b573f83b1df61c6bf06c444435b171731d35d
+  data.tar.gz: a77c73150b6f49caa994f793a6608c4be21d6c2bc46f30d0b475078568c6f0e7e35345cb974c2aa4ddeef0b17d0ad2cbdc2c372862ad4375aa401965d2f9aac3

data/.ace-defaults/llm/providers/pi.yml

@@ -27,6 +27,7 @@ aliases:
     pi: pi:zai/glm-5.3-flash
   model:
     glm: zai/glm-5.3
+    glm5: zai/glm-5.3
     glmflash: zai/glm-5.3-flash
     glmhighspeed: zai/glm-5.3-highspeed
     gpt: openai-codex/gpt-5.4

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.35.0] - 2026-09-27
+
+### Changed
+
+- Pi client reports measured per-model token usage — input, output, cached (`cacheRead`) and total (`totalTokens`) — instead of character-based estimates. When the CLI supplies no usage, the session records an explicit `usage_status: unavailable` (with the pi version when known) and no fabricated token counts; measured zeros are preserved and absent fields stay absent.
+
+## [0.34.1] - 2026-09-24
+
+### Fixed
+
+- Preserve completed Codex responses when copying the optional last-message diagnostic fails, and handle Pi retry streams without accepting partial output.
+- Reject unresolved Pi model selectors before CLI execution and keep the `glm5` alias synchronized across provider registries.
+- Preserve Codex JSON response text containing a preset path without mistaking it for the CLI banner.
+- Reject directory destinations for Codex last-message capture and preserve the final Pi stop reason when earlier turns appear in terminal events.
+
+### Changed
+
+- Restrict Pi `@ro` to read-only tools (`read`, `grep`, `find`, `ls`) and disable extensions.
+
 ## [0.34.0] - 2026-09-13
 
 ### Changed

data/lib/ace/llm/providers/cli/cli_args_support.rb

@@ -18,7 +18,7 @@ module Ace
             conflict = find_conflicting_cli_arg(args, forbidden_flags)
             return args unless conflict
 
-            raise Ace::LLM::ProviderError, "#{label} interactive mode does not support cli arg #{conflict}"
+            raise Ace::LLM::ProviderError, "#{label} does not support cli arg #{conflict} in this invocation"
           end
 
           def find_conflicting_cli_arg(args, forbidden_flags)

data/lib/ace/llm/providers/cli/codex_client.rb

@@ -3,6 +3,8 @@
 require "json"
 require "open3"
 require "shellwords"
+require "tempfile"
+require "fileutils"
 
 require_relative "cli_args_support"
 require_relative "atoms/execution_context"
@@ -59,11 +61,42 @@ module Ace
               subprocess_env: subprocess_env
             )
             prompt = rewrite_skill_commands(prompt, working_dir: working_dir)
+            requested_last_message = File.expand_path(options[:last_message_file], working_dir) if options[:last_message_file]
+            if requested_last_message && File.directory?(requested_last_message)
+              raise Ace::LLM::ProviderError, "last_message_file must name a file, not a directory: #{requested_last_message}"
+            end
 
-            cmd = build_codex_command(prompt, options, working_dir: working_dir)
-            stdout, stderr, status = execute_codex_command(cmd, prompt, options)
-
-            parse_codex_response(stdout, stderr, status, prompt, options)
+            Tempfile.create(["ace-codex-last-", ".md"]) do |last_message|
+              last_message.close
+              direct_capture = requested_last_message && File.writable?(File.dirname(requested_last_message)) && !File.directory?(requested_last_message)
+              execution_options = options.merge(last_message_file: direct_capture ? requested_last_message : last_message.path)
+              cmd = build_codex_command(prompt, execution_options, working_dir: working_dir)
+              if direct_capture && File.exist?(requested_last_message)
+                begin
+                  File.delete(requested_last_message)
+                rescue SystemCallError
+                  direct_capture = false
+                  execution_options = options.merge(last_message_file: last_message.path)
+                  cmd = build_codex_command(prompt, execution_options, working_dir: working_dir)
+                end
+              end
+              completed = false
+              result = nil
+              begin
+                stdout, stderr, status = execute_codex_command(cmd, prompt, execution_options)
+                result = parse_codex_response(stdout, stderr, status, prompt, execution_options)
+                completed = true
+                result
+              ensure
+                if requested_last_message && !direct_capture && (completed || File.size?(last_message.path))
+                  begin
+                    FileUtils.cp(last_message.path, requested_last_message)
+                  rescue => copy_error
+                    result[:metadata][:last_message_copy_error] = copy_error.message if completed
+                  end
+                end
+              end
+            end
           rescue => e
             handle_codex_error(e)
           end
@@ -200,8 +233,15 @@ module Ace
               cmd << "--output-last-message" << options[:last_message_file]
             end
 
-            # User CLI args last so they take precedence (last-wins in most CLIs)
-            cmd.concat(normalized_cli_args(options))
+            cli_args = normalized_cli_args_without_conflicts(
+              options,
+              forbidden_flags: ["--model", "-m", "--profile", "--output-last-message"],
+              label: "Codex"
+            )
+            if codex_cli_args_override_model?(cli_args)
+              raise Ace::LLM::ProviderError, "Codex cli args cannot override the resolved model"
+            end
+            cmd.concat(cli_args)
 
             cmd
           end
@@ -233,17 +273,23 @@ module Ace
               cmd << "-c" << trust_override
             end
 
-            cmd.concat(
-              normalized_cli_args_without_conflicts(
-                options,
-                forbidden_flags: ["exec", "review", "-C", "--cd", "--output-last-message"],
-                label: "Codex"
-              )
+            cli_args = normalized_cli_args_without_conflicts(
+              options,
+              forbidden_flags: ["exec", "review", "-C", "--cd", "--output-last-message", "--model", "-m", "--profile"],
+              label: "Codex"
             )
+            raise Ace::LLM::ProviderError, "Codex cli args cannot override the resolved model" if codex_cli_args_override_model?(cli_args)
+            cmd.concat(cli_args)
             cmd << prompt.to_s unless prompt.to_s.empty?
             cmd
           end
 
+          def codex_cli_args_override_model?(args)
+            args.any? { |arg| arg.match?(/\A-m.+/) } ||
+              args.each_cons(2).any? { |flag, value| %w[-c --config].include?(flag) && value.match?(/\A(?:model|model_provider|profiles\.[^.]+\.(?:model|model_provider))\s*=/) } ||
+              args.any? { |arg| arg.match?(/\A(?:-c|--config)=?(?:model|model_provider|profiles\.[^.]+\.(?:model|model_provider))\s*=/) }
+          end
+
           def execute_codex_command(cmd, prompt, options)
             # Prepare the input - combine system prompt with user prompt if needed
             input = prompt.to_s
@@ -280,16 +326,28 @@ module Ace
               raise Ace::LLM::ProviderError, "Codex CLI failed: #{error_msg}"
             end
 
-            # Parse Codex output format to extract the actual response
+            # The native last-message file contains only the final response,
+            # unlike stdout's transcript of tools and status messages.
+            last_message_path = options[:last_message_file]
+            if last_message_path
+              text = File.file?(last_message_path) ? File.read(last_message_path).strip : ""
+              raise Ace::LLM::ProviderError, "Codex CLI produced no final message" if text.empty?
+
+              return {text: text, metadata: build_synthetic_metadata(text, prompt)}
+            end
+
+            # Older CLI wrappers may supply stdout only. Parse its transcript
+            # only when a real CLI banner is present, not when report prose
+            # happens to contain a standalone `codex` line.
             # Codex output includes metadata lines and the actual response
             lines = stdout.split("\n")
 
-            # Find where the actual response starts (after "codex" header)
-            response_start = lines.find_index { |line| line.include?("codex") }
+            has_cli_banner = lines.first(20).any? { |line| line.start_with?("OpenAI Codex v") }
+            response_start = lines.find_index { |line| line.strip == "codex" } if has_cli_banner
 
             if response_start && response_start < lines.length - 1
               # Extract text after the "codex" line, skipping empty lines
-              response_lines = lines[(response_start + 1)..-1]
+              response_lines = lines[(response_start + 1)..]
               # Remove token usage lines at the end
               response_lines = response_lines.reject { |line| line.include?("tokens used") }
               text = response_lines.join("\n").strip

data/lib/ace/llm/providers/cli/pi_client.rb

@@ -183,6 +183,10 @@ module Ace
             # No session (stateless)
             cmd << "--no-session"
 
+            # Keep the terminal stop reason so truncated responses cannot pass
+            # as successful plain-text output.
+            cmd << "--mode" << "json"
+
             # No skills (we handle skill content ourselves in one-shot mode)
             cmd << "--no-skills"
 
@@ -194,13 +198,16 @@ module Ace
             # Provider/model from the model string (format: "provider/model")
             model_to_use = @model || @generation_config[:model] || DEFAULT_MODEL
             provider_name, model_id = split_provider_model(model_to_use)
-            if provider_name && model_id
-              cmd << "--provider" << provider_name
-              cmd << "--model" << model_id
-            end
+            cmd << "--provider" << provider_name
+            cmd << "--model" << model_id
 
-            # User CLI args after generated flags (last-wins precedence)
-            cmd.concat(normalized_cli_args(options))
+            cmd.concat(
+              normalized_cli_args_without_conflicts(
+                options,
+                forbidden_flags: ["--mode", "--provider", "--model", "--models"],
+                label: "Pi"
+              )
+            )
 
             cmd
           end
@@ -214,15 +221,13 @@ module Ace
 
             model_to_use = @model || @generation_config[:model] || DEFAULT_MODEL
             provider_name, model_id = split_provider_model(model_to_use)
-            if provider_name && model_id
-              cmd << "--provider" << provider_name
-              cmd << "--model" << model_id
-            end
+            cmd << "--provider" << provider_name
+            cmd << "--model" << model_id
 
             cmd.concat(
               normalized_cli_args_without_conflicts(
                 options,
-                forbidden_flags: ["-p", "--print", "--no-session", "--no-skills", "--mode"],
+                forbidden_flags: ["-p", "--print", "--no-session", "--no-skills", "--mode", "--provider", "--model", "--models"],
                 label: "Pi"
               )
             )
@@ -234,20 +239,25 @@ module Ace
           # Handles multi-segment providers like "google-gemini-cli/gemini-2.5-pro"
           # Also handles nested providers like "openrouter:openai/gpt-oss-120b"
           def split_provider_model(model_string)
-            return [nil, nil] unless model_string
+            raise Ace::LLM::ProviderError, "Pi model must resolve to provider/model" unless model_string
+            raise Ace::LLM::ProviderError, "Pi model must resolve to provider/model: #{model_string}" if model_string.start_with?(":")
 
             # Check for nested provider pattern (e.g., "openrouter:openai/model")
-            if model_string.count(":") > 0
+            colon = model_string.index(":")
+            slash = model_string.index("/")
+            if colon && (!slash || colon < slash)
               parts = model_string.split(":", 2)
-              if parts.length == 2 && parts[1].include?("/")
+              nested_parts = parts[1]&.split("/", 2)
+              if parts.length == 2 && !parts[0].empty? && nested_parts&.length == 2 && nested_parts.all? { |part| !part.empty? }
                 # Nested provider: "openrouter:openai/model" -> ["openrouter", "openai/model"]
                 return [parts[0], parts[1]]
               end
+              raise Ace::LLM::ProviderError, "Pi model must resolve to provider/model: #{model_string}"
             end
 
             # Standard provider/model format
             parts = model_string.split("/", 2)
-            return [nil, nil] unless parts.length == 2
+            raise Ace::LLM::ProviderError, "Pi model must resolve to provider/model: #{model_string}" unless parts.length == 2 && parts.all? { |part| !part.empty? }
 
             [parts[0], parts[1]]
           end
@@ -276,15 +286,8 @@ module Ace
               raise Ace::LLM::ProviderError, "Pi CLI failed: #{error_msg}"
             end
 
-            # Detect NDJSON: starts with {"type":"
-            if stdout.strip.start_with?('{"type":"')
-              text, usage = parse_ndjson(stdout)
-              response = {"usage" => normalize_usage(usage)}
-            else
-              # Plain text output
-              text = stdout.strip
-              response = {}
-            end
+            text, usage, finish_reason = parse_ndjson(stdout)
+            response = {"usage" => normalize_usage(usage), "finish_reason" => finish_reason}
 
             metadata = build_metadata(response, text, prompt, options)
 
@@ -294,21 +297,48 @@ module Ace
             }
           end
 
+          # Measured usage only. When the pi CLI supplies usage the token counts
+          # are recorded as-is (cached 0 means "no cache read", distinct from
+          # absent); when it does not, tokens are absent entirely and the
+          # session records an explicit "unavailable" state — never an estimate.
           def build_metadata(response, text, prompt, options)
             usage = response["usage"] || {}
 
-            prompt_tokens = usage["input_tokens"] || (prompt.to_s.length / 4).round
-            output_tokens = usage["output_tokens"] || (text.length / 4).round
-
-            {
+            metadata = {
               provider: "pi",
               model: @model || DEFAULT_MODEL,
-              input_tokens: prompt_tokens,
-              output_tokens: output_tokens,
-              total_tokens: prompt_tokens + output_tokens,
               finish_reason: response["finish_reason"] || "success",
               timestamp: Time.now.utc.iso8601
             }
+
+            if usage["input_tokens"] || usage["output_tokens"]
+              metadata[:input_tokens] = usage["input_tokens"] unless usage["input_tokens"].nil?
+              metadata[:output_tokens] = usage["output_tokens"] unless usage["output_tokens"].nil?
+              metadata[:cached_tokens] = usage["cached_tokens"] if usage.key?("cached_tokens")
+              metadata[:total_tokens] = usage["total_tokens"] ||
+                (usage["input_tokens"].to_i + usage["output_tokens"].to_i)
+              metadata[:usage_status] = "measured"
+            else
+              metadata[:usage_status] = "unavailable"
+              version = pi_version
+              metadata[:pi_version] = version if version
+            end
+
+            metadata
+          end
+
+          # Best-effort pi CLI version for the usage-unavailable record. Runs
+          # outside SafeCapture (a bare --version probe) and is memoized per
+          # instance so retries don't re-spawn the process.
+          def pi_version
+            return @pi_version if defined?(@pi_version)
+
+            @pi_version = begin
+              stdout, _stderr, status = Open3.capture3("pi", "--version")
+              status.success? ? stdout.strip : nil
+            rescue StandardError
+              nil
+            end
           end
 
           # Parse NDJSON output from Pi CLI when --mode json is used.
@@ -320,40 +350,72 @@ module Ace
             lines = stdout.split("\n")
             text_parts = []
             usage = nil
+            terminal_event = nil
+            settled = false
+            message_stop_reason = nil
 
             lines.each do |line|
               next if line.strip.empty?
               event = JSON.parse(line)
+              raise Ace::LLM::ProviderError, "Pi JSON stream contains a non-object event" unless event.is_a?(Hash)
               case event["type"]
               when "message_end"
                 # Extract text from content array
-                content = event.dig("message", "content") || []
-                content.each do |c|
-                  text_parts << c["text"] if c["type"] == "text"
+                message = event["message"] || {}
+                if message["role"].nil? || message["role"] == "assistant"
+                  text_parts = extract_message_text(message)
+                  usage = message["usage"]
+                  message_stop_reason = message["stopReason"] if message["stopReason"]
                 end
-                usage = event.dig("message", "usage")
               when "agent_end"
-                # Fallback: extract from messages array
+                settled = false
+                if event["willRetry"]
+                  text_parts.clear
+                  usage = nil
+                  terminal_event = nil
+                  message_stop_reason = nil
+                  next
+                end
+                terminal_event = event
                 messages = event["messages"] || []
-                messages.each do |msg|
-                  content = msg["content"] || []
-                  content.each do |c|
-                    text_parts << c["text"] if c["type"] == "text"
-                  end
+                if (last_assistant = messages.reverse.find { |msg| (msg["role"].nil? || msg["role"] == "assistant") && extract_message_text(msg).any? })
+                  text_parts = extract_message_text(last_assistant)
+                  usage ||= last_assistant["usage"]
+                  message_stop_reason ||= last_assistant["stopReason"]
                 end
-                usage = messages.dig(0, "usage") if usage.nil?
+              when "agent_settled"
+                settled = true if terminal_event
               end
             end
 
+            raise Ace::LLM::ProviderError, "Pi JSON stream ended without agent_end" unless terminal_event
+            raise Ace::LLM::ProviderError, "Pi JSON stream ended without agent_settled" unless settled
+
             text = text_parts.join("")
-            [text, usage || {}]
+            raise Ace::LLM::ProviderError, "Pi JSON stream produced no final assistant message" if text.strip.empty?
+            terminal_reason = terminal_event["stopReason"] || terminal_event.dig("messages", -1, "stopReason")
+            successful_reasons = Ace::LLM::SUCCESSFUL_FINISH_REASONS
+            finish_reason = if %w[error aborted].include?(terminal_reason.to_s.downcase)
+              terminal_reason
+            elsif message_stop_reason && !successful_reasons.include?(message_stop_reason.to_s.downcase)
+              message_stop_reason
+            else
+              terminal_reason || message_stop_reason || "success"
+            end
+            [text, usage || {}, finish_reason]
           rescue JSON::ParserError
-            # If parsing fails, treat as plain text
-            [stdout.strip, {}]
+            raise Ace::LLM::ProviderError, "Pi JSON stream contains invalid events"
+          end
+
+          def extract_message_text(message)
+            Array(message["content"]).filter_map { |content| content["text"] if content["type"] == "text" }
           end
 
           # Normalize Pi usage field names to our standard format.
-          # Pi uses "input"/"output", we normalize to "input_tokens"/"output_tokens".
+          # Pi reports input/output/cacheRead/cacheWrite/totalTokens on the
+          # assistant message; we map them to *_tokens keys. A measured zero
+          # cacheRead is kept (distinguishing "no cache" from "unknown"); a
+          # missing key stays missing.
           #
           # @param usage [Hash] Raw usage hash from Pi response
           # @return [Hash] Normalized usage hash
@@ -361,7 +423,9 @@ module Ace
             return {} unless usage
             {
               "input_tokens" => usage["input"] || usage["input_tokens"],
-              "output_tokens" => usage["output"] || usage["output_tokens"]
+              "output_tokens" => usage["output"] || usage["output_tokens"],
+              "cached_tokens" => (usage["cacheRead"] if usage.key?("cacheRead")),
+              "total_tokens" => (usage["totalTokens"] if usage.key?("totalTokens"))
             }.compact
           end
 

data/lib/ace/llm/providers/cli/version.rb

@@ -4,7 +4,7 @@ module Ace
   module LLM
     module Providers
       module CLI
-        VERSION = "0.34.0"
+        VERSION = "0.35.0"
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-llm-providers-cli
 version: !ruby/object:Gem::Version
-  version: 0.34.0
+  version: 0.35.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-llm
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.39'
+        version: '0.41'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.39'
+        version: '0.41'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement