openclacky 1.5.5 → 1.5.7

data/lib/clacky/mcp/oauth/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Clacky
+  module Mcp
+    module OAuth
+      class Config
+        class Error < StandardError; end
+
+        attr_reader :resource
+
+        def self.from_server_spec(spec)
+          spec ||= {}
+          auth = spec["auth"]
+          enabled = auth.is_a?(Hash) && !auth.empty?
+          if enabled && auth["type"].to_s != "oauth"
+            raise Error, "unsupported MCP authentication type '#{auth['type']}'"
+          end
+
+          resource = enabled ? (auth["resource"] || spec["url"]) : spec["url"]
+          new(enabled: enabled, resource: resource, endpoint: spec["url"])
+        end
+
+        def initialize(enabled:, resource:, endpoint: nil)
+          @enabled = enabled
+          @resource = resource.to_s
+          @endpoint = (endpoint || resource).to_s
+          validate! if enabled?
+        end
+
+        def enabled?
+          @enabled == true
+        end
+
+        private def validate!
+          validate_https_url(@endpoint, "OAuth MCP endpoint")
+          validate_https_url(@resource, "OAuth MCP resource")
+        end
+
+        private def validate_https_url(value, label)
+          uri = URI.parse(value)
+          raise Error, "#{label} must be an HTTPS URL without credentials" unless
+            uri.scheme == "https" && uri.host && !uri.host.empty? && !uri.user && !uri.password
+        rescue URI::InvalidURIError
+          raise Error, "#{label} must be an HTTPS URL"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/mcp/oauth/credential_store.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "digest"
+
+module Clacky
+  module Mcp
+    module OAuth
+      class CredentialStore
+        class Error < StandardError; end
+
+        attr_reader :path
+
+        def initialize(server_name:, home: Dir.home)
+          original_name = server_name.to_s
+          safe_name = original_name.gsub(/[^a-zA-Z0-9_.-]/, "_")
+          safe_name = "server" if safe_name.empty?
+          safe_name = "#{safe_name}-#{Digest::SHA256.hexdigest(original_name)[0, 12]}" if safe_name != original_name
+          @path = File.join(File.expand_path(home), ".clacky", "mcp", "oauth", "#{safe_name}.json")
+        end
+
+        def load
+          return nil unless File.file?(@path)
+
+          with_lock(File::LOCK_SH) do
+            value = JSON.parse(File.read(@path))
+            raise JSON::ParserError unless value.is_a?(Hash)
+            value
+          end
+        rescue JSON::ParserError
+          raise Error, "invalid OAuth credential file; log in again"
+        end
+
+        def save(value)
+          ensure_directory
+          with_lock(File::LOCK_EX) do
+            temporary = "#{@path}.tmp-#{Process.pid}-#{rand(1_000_000)}"
+            File.open(temporary, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+              file.write(JSON.generate(value))
+              file.write("\n")
+              file.flush
+              file.fsync
+            end
+            File.rename(temporary, @path)
+            File.chmod(0o600, @path)
+          ensure
+            FileUtils.rm_f(temporary) if defined?(temporary) && temporary
+          end
+          value
+        end
+
+        def delete
+          return unless File.exist?(@path)
+
+          ensure_directory
+          with_lock(File::LOCK_EX) { FileUtils.rm_f(@path) }
+        end
+
+        def inspect
+          "#<#{self.class} path=#{@path.inspect}>"
+        end
+
+        private def ensure_directory
+          FileUtils.mkdir_p(File.dirname(@path), mode: 0o700)
+          File.chmod(0o700, File.dirname(@path))
+        end
+
+        private def with_lock(mode)
+          ensure_directory
+          lock_path = "#{@path}.lock"
+          File.open(lock_path, File::RDWR | File::CREAT, 0o600) do |lock|
+            lock.flock(mode)
+            yield
+          ensure
+            lock.flock(File::LOCK_UN) rescue nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clacky/mcp/oauth/session.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Clacky
+  module Mcp
+    module OAuth
+      class Session
+        EXPIRY_SKEW = 60
+
+        class Error < StandardError; end
+        class NotConnectedError < Error; end
+
+        def initialize(store:, manager:, clock: nil)
+          @store = store
+          @manager = manager
+          @clock = clock || -> { Time.now.to_i }
+          @force_refresh = false
+          @lock = Monitor.new
+        end
+
+        def authorization_headers
+          @lock.synchronize do
+            grant = @store.load
+            raise NotConnectedError, "OAuth MCP is not connected; run `clacky mcp login SERVER`" unless grant
+
+            if @force_refresh || expiring?(grant)
+              grant = @manager.refresh(grant)
+              @store.save(grant)
+              @force_refresh = false
+            end
+            token = grant["access_token"].to_s
+            raise Error, "stored OAuth grant has no access token; log in again" if token.empty?
+            { "Authorization" => "Bearer #{token}" }
+          end
+        rescue NotConnectedError, Error
+          raise
+        rescue StandardError => e
+          raise Error, "OAuth session failed (#{e.class}); log in again"
+        end
+
+        def invalidate!
+          @lock.synchronize { @force_refresh = true }
+        end
+
+        def login
+          @lock.synchronize do
+            grant = @manager.login
+            @force_refresh = false
+            grant
+          end
+        end
+
+        def logout
+          @lock.synchronize do
+            @store.delete
+            @force_refresh = false
+          end
+          true
+        end
+
+        def connected?
+          !@store.load.nil?
+        rescue StandardError
+          false
+        end
+
+        def status
+          grant = @store.load
+          return { "connected" => false } unless grant
+          {
+            "connected" => true,
+            "expires_at" => grant["expires_at"],
+            "expired" => grant.fetch("expires_at", 0).to_i <= @clock.call
+          }
+        end
+
+        def inspect
+          "#<#{self.class} connected=#{connected?}>"
+        end
+
+        private def expiring?(grant)
+          grant.fetch("expires_at", 0).to_i <= @clock.call + EXPIRY_SKEW
+        end
+      end
+    end
+  end
+end

data/lib/clacky/message_format/anthropic.rb

@@ -19,6 +19,25 @@ module Clacky
     module Anthropic
       module_function
 
+      # Normalise a /v1/messages usage block to the codebase's canonical
+      # (OpenAI-style) prompt_tokens: total input including cache_read but
+      # excluding cache_creation.
+      #
+      # Anthropic reports input_tokens as the post-breakpoint tail only, with
+      # the cache buckets disjoint from it. Some /v1/messages-compatible
+      # gateways instead report input_tokens as the FULL input with both cache
+      # buckets already folded in; adding cache_read there would bill the whole
+      # cached prefix twice. Detect that by whether the cache buckets already
+      # fit inside input_tokens.
+      def normalise_prompt_tokens(input_tokens, cache_read, cache_creation)
+        cached_input = cache_read + cache_creation
+        if cached_input.positive? && input_tokens >= cached_input
+          input_tokens - cache_creation
+        else
+          input_tokens + cache_read
+        end
+      end
+
       # ── Message type identification ───────────────────────────────────────────
 
       # Returns true if the message is an Anthropic-native tool result stored in
@@ -169,22 +188,16 @@ module Clacky
                         else data["stop_reason"]
                         end
 
-        # Anthropic native `input_tokens` counts ONLY the non-cached, freshly-billed
-        # input — cache_read_input_tokens and cache_creation_input_tokens are
-        # reported separately and are disjoint from input_tokens.
-        #
         # Normalise to the codebase's canonical shape (OpenAI-style) so downstream
         # (ModelPricing.calculate_cost, CostTracker, show_token_usage) stays
         # provider-agnostic:
         #
-        #   prompt_tokens     = non_cached + cache_read     (OpenAI convention:
-        #                                                    includes cache_read
-        #                                                    but NOT cache_write;
-        #                                                    ModelPricing does
-        #                                                    `regular_input = prompt_tokens - cache_read`.)
+        #   prompt_tokens     = total input incl. cache_read, excl. cache_write
+        #                       (ModelPricing does
+        #                        `regular_input = prompt_tokens - cache_read`.)
         #   completion_tokens = output
         #   total_tokens      = THIS TURN'S new compute volume
-        #                     = raw_input + cache_creation + output
+        #                     = non_cached + cache_creation + output
         #                       (cache_read is excluded because hits are ~free /
         #                        already-paid-for; cache_creation IS new work this
         #                        turn even though it's billed at write_rate.)
@@ -199,14 +212,15 @@ module Clacky
         cache_creation    = usage["cache_creation_input_tokens"].to_i
         output_tokens     = usage["output_tokens"].to_i
 
-        prompt_tokens = raw_input_tokens + cache_read
+        prompt_tokens = normalise_prompt_tokens(raw_input_tokens, cache_read, cache_creation)
 
         usage_data = {
           prompt_tokens:      prompt_tokens,
           completion_tokens:  output_tokens,
           # Per-turn new compute: what the server freshly processed this request.
-          # Excludes cache_read (nearly free, already-paid-for).
-          total_tokens:       raw_input_tokens + cache_creation + output_tokens,
+          # Excludes cache_read (nearly free, already-paid-for). Derived from the
+          # normalised prompt_tokens so it stays correct under both conventions.
+          total_tokens:       (prompt_tokens - cache_read) + cache_creation + output_tokens,
           # Signal to CostTracker: total_tokens above is already the per-turn
           # delta (not a running cumulative like OpenAI's). CostTracker should
           # NOT subtract previous_total when this flag is truthy.

data/lib/clacky/message_history.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Clacky
   # MessageHistory wraps the conversation message list and exposes
   # business-meaningful operations instead of raw array manipulation.
@@ -12,9 +14,18 @@ module Clacky
       task_id created_at system_injected session_context memory_update
       subagent_instructions subagent_result subagent_transcript token_usage
       compressed_summary chunk_path truncated transient
-      chunk_index chunk_count
+      chunk_index chunk_count ext_events
     ].freeze
 
+    # Cap on persisted ext_events per message. These are milestone events
+    # (progress chatter is transient), so a handful per message is the norm —
+    # the cap only exists to stop a runaway extension. Oldest are dropped first.
+    MAX_EXT_EVENTS_PER_MESSAGE = 50
+
+    # Oversized payloads belong in a file, not in session.json (which is
+    # rewritten in full on every save).
+    MAX_EXT_EVENT_BYTES = 8 * 1024
+
     def initialize(messages = [])
       @messages = messages.dup
     end
@@ -85,6 +96,26 @@ module Clacky
       self
     end
 
+    # Append a custom extension event onto the most recent message so it is
+    # persisted with the session and can be replayed after a reload.
+    # Events are anchored to the last message: on replay they are re-emitted
+    # right after that message, preserving chronological order.
+    # No-op when the history is still empty (nothing to anchor to).
+    def append_ext_event(event)
+      msg = @messages.last
+      return self unless msg
+
+      if JSON.generate(event).bytesize > MAX_EXT_EVENT_BYTES
+        Clacky::Logger.warn("ext event #{event[:type].inspect} dropped: payload exceeds #{MAX_EXT_EVENT_BYTES} bytes")
+        return self
+      end
+
+      list = (msg[:ext_events] ||= [])
+      list.shift while list.size >= MAX_EXT_EVENTS_PER_MESSAGE
+      list << deep_sanitize_utf8(event)
+      self
+    end
+
     # Mutate the last message matching the predicate lambda in-place.
     # Used by execute_skill_with_subagent to update instruction messages.
     def mutate_last_matching(predicate, &block)

data/lib/clacky/providers.rb

@@ -43,6 +43,7 @@ module Clacky
           "dsk-deepseek-v4-pro",
           "dsk-deepseek-v4-flash",
           "or-gemini-3-1-pro",
+          "or-gemini-3-6-flash",
           "or-gemini-3-5-flash"
         ],
         # Image generation models served by the openclacky platform
@@ -94,30 +95,34 @@ module Clacky
         # routes them to Vertex AI Gemini (generateContent with inline
         # audio parts). The gateway returns transcription text.
         "stt_models" => [
+          "or-stt-gemini-3-6-flash",
           "or-stt-gemini-3-5-flash",
           "or-stt-gemini-1-5-pro"
         ],
         "stt_model_aliases" => {
+          "or-stt-gemini-3-6-flash" => "Gemini 3.6 Flash STT",
           "or-stt-gemini-3-5-flash" => "Gemini 3.5 Flash STT",
           "or-stt-gemini-1-5-pro"   => "Gemini 1.5 Pro STT"
         },
-        "default_stt_model" => "or-stt-gemini-3-5-flash",
+        "default_stt_model" => "or-stt-gemini-3-6-flash",
         # Video understanding models served by the openclacky gateway, which
         # routes video frames to Gemini (generateContent with inline image
         # parts). The gateway returns analysis text.
         "video_understanding_models" => [
+          "or-gemini-3-6-flash",
           "or-gemini-3-5-flash",
           "or-gemini-3-1-pro"
         ],
         "video_understanding_model_aliases" => {
+          "or-gemini-3-6-flash" => "Gemini 3.6 Flash",
           "or-gemini-3-5-flash" => "Gemini 3.5 Flash",
           "or-gemini-3-1-pro"   => "Gemini 3.1 Pro"
         },
-        "default_video_understanding_model" => "or-gemini-3-5-flash",
+        "default_video_understanding_model" => "or-gemini-3-6-flash",
         # Default OCR sidecar — used when the primary model is text-only.
         # Candidates are derived from the provider's vision-capable models;
         # this just picks the cheap+fast default to surface in "auto" mode.
-        "default_ocr_model" => "or-gemini-3-5-flash",
+        "default_ocr_model" => "or-gemini-3-6-flash",
         # Provider-level default: the Claude family served here is vision-capable.
         "capabilities" => { "vision" => true }.freeze,
         # Model-level overrides: DeepSeek models routed through this provider
@@ -144,7 +149,7 @@ module Clacky
           "abs-claude-sonnet-4-6" => "abs-claude-haiku-4-5",
           "abs-claude-sonnet-4-5" => "abs-claude-haiku-4-5",
           "dsk-deepseek-v4-pro"   => "dsk-deepseek-v4-flash",
-          "or-gemini-3-1-pro"     => "or-gemini-3-5-flash"
+          "or-gemini-3-1-pro"     => "or-gemini-3-6-flash"
         },
         # Fallback chain: if a model is unavailable, try the next one in order.
         # Keys are primary model names; values are the fallback model to use instead.
@@ -427,13 +432,11 @@ module Clacky
         "name_key" => "provider.name.volcengine_ark",
         "base_url" => "https://ark.cn-beijing.volces.com/api/v3",
         "api" => "openai-completions",
-        "default_model" => "doubao-seed-2.0-pro",
+        "default_model" => "doubao-seed-2.1-pro",
         "models" => [
           "doubao-seed-evolving",
           "doubao-seed-2.1-pro",
           "doubao-seed-2.1-turbo",
-          "doubao-seed-2.0-code",
-          "doubao-seed-2.0-pro",
           "doubao-seed-2.0-lite",
           "minimax-m3",
           "minimax-m2.7",
@@ -460,9 +463,7 @@ module Clacky
             "deepseek-v4-flash"  => "deepseek-v4-flash-260425",
             "doubao-seed-2.1-pro"   => "doubao-seed-2-1-pro-260628",
             "doubao-seed-2.1-turbo" => "doubao-seed-2-1-turbo-260628",
-            "doubao-seed-2.0-pro"   => "doubao-seed-2-0-pro-260215",
-            "doubao-seed-2.0-lite"  => "doubao-seed-2-0-lite-260428",
-            "doubao-seed-2.0-code"  => "doubao-seed-2-0-code-preview-260215"
+            "doubao-seed-2.0-lite"  => "doubao-seed-2-0-lite-260428"
           }.freeze
         }.freeze,
         # Most Doubao/multimodal models accept image input; GLM-5.2 and
@@ -619,7 +620,8 @@ module Clacky
       { pattern: /glm/i,           limit: 65_536 }, # GLM-5.2: 128K output ceiling; 64K ample for reasoning+answer
       { pattern: /kimi-k3/i,       limit: 65_536 }, # Kimi K3: max_completion_tokens=131072 (max 1M); 64K ample
       { pattern: /mimo-v2\.5-pro/i, limit: 65_536 }, # MiMo-V2.5-Pro: max_completion_tokens=131072; 64K ample
-      { pattern: /mimo/i,           limit: 32_768 }  # MiMo-V2.5: max_completion_tokens=32768; full default ceiling
+      { pattern: /mimo/i,           limit: 32_768 }, # MiMo-V2.5: max_completion_tokens=32768; full default ceiling
+      { pattern: /gemini/i,        limit: 65_536 }  # Gemini 3.x: 64K max output ceiling
     ].freeze
 
     class << self
@@ -991,8 +993,8 @@ module Clacky
       # Translate a display model name into the real model id the target
       # endpoint expects. Some providers expose the same model under different
       # ids per billing endpoint (e.g. Volcengine Ark's pay-as-you-go API needs
-      # versioned ids like "doubao-seed-2-0-pro-260215" while the Coding/Agent
-      # Plan endpoints accept the short "doubao-seed-2.0-pro"). Users always see
+      # versioned ids like "doubao-seed-2-1-pro-260628" while the Coding/Agent
+      # Plan endpoints accept the short "doubao-seed-2.1-pro"). Users always see
       # and pick the short name; this swaps it just before the request goes out.
       #
       # Returns the original model unchanged when no alias applies (unknown

data/lib/clacky/search_config.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Clacky
+  # Search provider selection, backed by ~/.clacky/search.yml.
+  #
+  # The built-in DuckDuckGo/Bing scrapers need no configuration and stay the
+  # default. Pointing `provider` at a script in ~/.clacky/searchers/ routes
+  # web_search through an API-backed engine instead, which is what users who
+  # want higher-quality results (or China-reachable ones) reach for.
+  #
+  # search.yml schema:
+  #   provider: tavily     — basename of a script in ~/.clacky/searchers/;
+  #                          blank or missing means built-in engines only
+  #   key: tvly-xxx        — credential handed to that script via env
+  #
+  # The directory is the registry: dropping my_engine.rb into
+  # ~/.clacky/searchers/ and setting `provider: my_engine` is all it takes,
+  # mirroring how ~/.clacky/skills/ and ~/.clacky/parsers/ work.
+  module SearchConfig
+    CONFIG_PATH = File.expand_path("~/.clacky/search.yml").freeze
+
+    class << self
+      # @return [Hash] { "provider" => String, "key" => String }
+      def load
+        raw = File.exist?(CONFIG_PATH) ? YAML.load_file(CONFIG_PATH) : nil
+        return { "provider" => "", "key" => "" } unless raw.is_a?(Hash)
+
+        { "provider" => raw["provider"].to_s.strip, "key" => raw["key"].to_s.strip }
+      rescue StandardError
+        { "provider" => "", "key" => "" }
+      end
+
+      def save(provider:, key:)
+        FileUtils.mkdir_p(File.dirname(CONFIG_PATH))
+        File.write(CONFIG_PATH, { "provider" => provider.to_s.strip, "key" => key.to_s.strip }.to_yaml)
+        File.chmod(0o600, CONFIG_PATH)
+      end
+
+      # Absolute path of the configured searcher, or nil when unset/missing.
+      # A provider naming a script that isn't installed is treated as unset so
+      # web_search silently falls back instead of erroring on every search.
+      def script_path
+        name = load["provider"]
+        return nil if name.empty?
+
+        Clacky::Utils::SearcherManager.path_for(name)
+      end
+
+      def key
+        load["key"]
+      end
+    end
+  end
+end