openclacky 1.5.12 → 1.5.13

data/lib/clacky/client.rb

@@ -44,6 +44,7 @@ module Clacky
       effective_api_format ||= "anthropic-messages" if anthropic_format
       resolved_type = Providers.api_type_for_model(provider_id, @model, user_override: effective_api_format)
       @use_anthropic_format = resolved_type == "anthropic-messages"
+      @use_responses_format = resolved_type == "openai-responses"
 
       # Remember the provider id so we can tune connection headers below
       # (OpenRouter's /v1/messages accepts either Bearer or x-api-key, but
@@ -66,6 +67,12 @@ module Clacky
       @use_anthropic_format && !@use_bedrock
     end
 
+    # Returns true when the client talks to the OpenAI Responses API
+    # (/v1/responses) instead of Chat Completions.
+    def responses_format?(model = nil)
+      @use_responses_format && !@use_bedrock
+    end
+
     # ── Connection test ───────────────────────────────────────────────────────
 
     # Test API connection by sending a minimal request.
@@ -81,6 +88,11 @@ module Clacky
         minimal_body = { model: api_model, max_tokens: 16,
                          messages: [{ role: "user", content: "hi" }] }.to_json
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = minimal_body }
+      elsif responses_format?
+        minimal_body = MessageFormat::OpenAIResponses.build_request_body(
+          [{ role: "user", content: "hi" }], api_model, [], 16, false
+        ).to_json
+        response = openai_connection.post("responses") { |r| r.body = minimal_body }
       else
         minimal_body = { model: api_model, max_tokens: 16,
                          messages: [{ role: "user", content: "hi" }] }.to_json
@@ -113,6 +125,10 @@ module Clacky
         body     = MessageFormat::Anthropic.build_request_body(messages, api_model, [], max_tokens, false)
         response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = body.to_json }
         parse_simple_anthropic_response(response)
+      elsif responses_format?
+        body     = MessageFormat::OpenAIResponses.build_request_body(messages, api_model, [], max_tokens, false)
+        response = openai_connection.post("responses") { |r| r.body = body.to_json }
+        parse_simple_openai_responses_response(response)
       else
         body     = MessageFormat::OpenAI.build_request_body(messages, api_model, [], max_tokens, false, reasoning_effort: reasoning_effort)
         response = openai_connection.post("chat/completions") { |r| r.body = body.to_json }
@@ -164,6 +180,9 @@ module Clacky
         elsif anthropic_format?
           streaming_used = !on_chunk.nil?
           send_anthropic_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk)
+        elsif responses_format?
+          streaming_used = !on_chunk.nil?
+          send_openai_responses_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk, capability_model: model)
         else
           streaming_used = !on_chunk.nil?
           send_openai_request(cloned, api_model, tools, max_tokens, caching_enabled, reasoning_effort: reasoning_effort, on_chunk: wrapped_on_chunk, capability_model: model)
@@ -206,6 +225,8 @@ module Clacky
         MessageFormat::Bedrock.format_tool_results(response, tool_results)
       elsif anthropic_format?
         MessageFormat::Anthropic.format_tool_results(response, tool_results)
+      elsif responses_format?
+        MessageFormat::OpenAIResponses.format_tool_results(response, tool_results)
       else
         MessageFormat::OpenAI.format_tool_results(response, tool_results)
       end
@@ -460,6 +481,92 @@ module Clacky
       content
     end
 
+    # ── OpenAI Responses API request / response ───────────────────────────────
+
+    def send_openai_responses_request(messages, model, tools, max_tokens, caching_enabled,
+                                      reasoning_effort: nil, on_chunk: nil, capability_model: nil)
+      # Override max_tokens when the model declares a higher output ceiling
+      model_for_limit = capability_model || model
+      model_limit = Providers.max_output_for(model_for_limit)
+      max_tokens = model_limit if model_limit
+
+      # Deliberately no apply_message_caching here: the Responses API does
+      # not recognize Anthropic-style cache_control markers, and OpenAI's
+      # Responses prompt caching is automatic server-side. Injecting
+      # cache_control would be silently ignored (or rejected by stricter
+      # endpoints).
+
+      cap_model = capability_model || model
+      body = MessageFormat::OpenAIResponses.build_request_body(
+        messages, model, tools, max_tokens, caching_enabled,
+        vision_supported: Providers.supports?(@provider_id, :vision, model_name: cap_model),
+        reasoning_effort: reasoning_effort
+      )
+      return send_openai_responses_stream_request(body, on_chunk) if on_chunk
+
+      response = openai_connection.post("responses") { |r| r.body = body.to_json }
+
+      raise_error(response) unless response.status == 200
+      check_html_response(response)
+
+      parsed_body = safe_json_parse(response.body, context: "LLM response")
+      MessageFormat::OpenAIResponses.parse_response(parsed_body)
+    end
+
+    # Streaming variant for the OpenAI Responses API.
+    # Posts to the "responses" endpoint with stream:true; the upstream returns
+    # typed SSE events (response.output_text.delta,
+    # response.function_call_arguments.delta, response.completed, etc.) that
+    # the aggregator reassembles into the non-streaming response shape.
+    private def send_openai_responses_stream_request(body, on_chunk)
+      stream_body = body.merge(stream: true)
+      aggregator = OpenAIResponsesStreamAggregator.new(on_chunk: on_chunk)
+      sse_buf = +""
+
+      response = openai_connection.post("responses") do |req|
+        req.headers["Accept"] = "text/event-stream"
+        req.body = stream_body.to_json
+        req.options.on_data = proc do |chunk, _bytes_received, _env|
+          sse_buf << chunk
+          drain_sse_frames(sse_buf) { |_event, data| aggregator.handle(data) }
+        end
+      end
+
+      unless response.status == 200
+        response.env.body = sse_buf if response.body.to_s.empty?
+        raise_error(response)
+      end
+
+      result = aggregator.to_h
+      log_stream_summary("openai-responses", aggregator, aggregator.saw_done? ? "completed" : nil)
+      # A complete Responses API stream always terminates with a
+      # response.completed / response.done (or response.incomplete) event.
+      # Its absence means the upstream cut the stream mid-response; retry
+      # rather than accept a silently truncated answer.
+      unless aggregator.saw_done?
+        raise Clacky::UpstreamTruncatedError,
+          "[LLM] Streaming response ended without response.completed (upstream cut the stream). Retrying..."
+      end
+      MessageFormat::OpenAIResponses.parse_response(result)
+    end
+
+    def parse_simple_openai_responses_response(response)
+      raise_error(response) unless response.status == 200
+      parsed_body = safe_json_parse(response.body, context: "LLM response")
+      result = MessageFormat::OpenAIResponses.parse_response(parsed_body)
+      content = result[:content]
+      if content.nil?
+        snippet = response.body.to_s[0, 1200]
+        if defined?(Clacky::Logger)
+          Clacky::Logger.warn("[parse_simple_openai_responses_response] no content. status=#{response.status} body=#{snippet}")
+        end
+        raise RetryableError,
+          "Upstream Responses API response missing text content. " \
+          "Body snippet: #{snippet}"
+      end
+      content
+    end
+
     # ── Prompt caching helpers ────────────────────────────────────────────────
 
     # Add cache_control markers to the last 2 messages in the array.

data/lib/clacky/default_extensions/ext-studio/api/handler.rb

@@ -344,6 +344,9 @@ class ExtStudioExt < Clacky::ApiExtension
     ext_id  = require_ext_id!
     version = presence(json_body["version"])
     error!("version required", status: 422) unless version
+    unless Clacky::ExtensionVerifier.valid_version?(version)
+      error!("version must use three numeric segments (for example, 1.0.0)", status: 422)
+    end
 
     result  = Clacky::ExtensionLoader.load_all(force: false)
     container = Array(result.containers).find { |id, _| id == ext_id }&.last

data/lib/clacky/default_extensions/ext-studio/panels/studio/view.js

@@ -627,8 +627,12 @@
     }
   }
 
+  function normalizeVersion(v) {
+    return String(v || "").replace(/[^0-9.]/g, "").split(".").slice(0, 3).join(".");
+  }
+
   function isSemver(v) {
-    return /^\d+\.\d+\.\d+$/.test(v);
+    return /^[0-9]+\.[0-9]+\.[0-9]+$/.test(v);
   }
 
   // Unified publish flow: one modal that walks the creator from a release form
@@ -642,23 +646,14 @@
       const titleNew = isBrand ? t("pub.brand.title.new") : t("pub.title.new");
       const titleUpdate = isBrand ? t("pub.brand.title.update") : t("pub.title.update");
       const introText = isBrand ? t("pub.brand.intro", { name: ext.name }) : t("pub.intro", { name: ext.name });
-      let currentVersion = ext.version || "";
+      let currentVersion = normalizeVersion(ext.version);
       let isUpdate = false;
 
       const verField = el("div", { class: "studio-field" });
       verField.appendChild(el("label", { class: "studio-label", text: t("pub.version.label") }));
-      const verInput = el("input", { class: "studio-input", type: "text", value: currentVersion, placeholder: "1.0.0" });
-      verInput.addEventListener("input", () => {
-        currentVersion = verInput.value.trim();
-        const valid = isSemver(currentVersion);
-        verInput.classList.toggle("studio-input-error", !!currentVersion && !valid);
-        publishBtn.disabled = !valid;
-        publishBtn.textContent = valid ? t("pub.btn.publish", { ver: currentVersion }) : t("pub.btn.publish", { ver: currentVersion || "?" });
-        if (currentVersion && !valid) {
-          setProgress(t("err.invalid_version"), true);
-        } else {
-          status.style.display = "none";
-        }
+      const verInput = el("input", {
+        class: "studio-input", type: "text", value: currentVersion,
+        placeholder: "1.0.0", inputmode: "decimal", autocomplete: "off", spellcheck: "false",
       });
       verField.appendChild(verInput);
 
@@ -694,7 +689,8 @@
 
       const publishBtn = modal.footer.querySelector(".btn-primary");
       const cancelBtn = modal.footer.querySelector(".btn-secondary");
-      if (!currentVersion) publishBtn.disabled = true;
+      verInput.addEventListener("input", () => syncVersionState({ normalize: true }));
+      syncVersionState();
 
       Promise.resolve(prevVersionOrPromise).then((prevVersion) => {
         if (done || !prevVersion) return;
@@ -702,10 +698,8 @@
         const titleEl = modal.overlay.querySelector(".modal-title");
         if (titleEl) titleEl.textContent = titleUpdate;
         if (prevVersion !== currentVersion) {
-          currentVersion = prevVersion;
-          verInput.value = currentVersion;
-          publishBtn.disabled = false;
-          publishBtn.textContent = t("pub.btn.publish", { ver: currentVersion });
+          verInput.value = normalizeVersion(prevVersion);
+          syncVersionState();
         }
       });
 
@@ -715,9 +709,34 @@
         status.className = "studio-modal-status" + (isError ? " studio-modal-status-error" : "");
       }
 
+      function syncVersionState({ normalize = false, updateFeedback = true } = {}) {
+        if (normalize) {
+          const raw = verInput.value;
+          const cursor = verInput.selectionStart;
+          const normalized = normalizeVersion(raw);
+          if (normalized !== raw) {
+            verInput.value = normalized;
+            if (cursor != null) {
+              const normalizedCursor = normalizeVersion(raw.slice(0, cursor)).length;
+              verInput.setSelectionRange(normalizedCursor, normalizedCursor);
+            }
+          }
+        }
+
+        currentVersion = verInput.value.trim();
+        const valid = isSemver(currentVersion);
+        publishBtn.disabled = !valid;
+        publishBtn.textContent = t("pub.btn.publish", { ver: valid ? currentVersion : (currentVersion || "?") });
+
+        if (updateFeedback) {
+          verInput.classList.toggle("studio-input-error", !!currentVersion && !valid);
+          if (currentVersion && !valid) setProgress(t("err.invalid_version"), true);
+          else status.style.display = "none";
+        }
+      }
+
       function resetButtons() {
-        publishBtn.disabled = !currentVersion;
-        publishBtn.textContent = currentVersion ? t("pub.btn.publish", { ver: currentVersion }) : t("pub.btn.publish", { ver: "?" });
+        syncVersionState({ updateFeedback: false });
         cancelBtn.disabled = false;
         notes.disabled = false;
         verInput.disabled = false;

data/lib/clacky/default_extensions/git/ext.yml

@@ -1,7 +1,7 @@
 id: git
 name: Git
 display_name: Git
-display_name_zh: Git
+display_name_zh: Git 管理
 description: Changes panel — a friendly view of what the AI changed in the working tree
 description_zh: 变更面板 — 直观查看 AI 在工作区的每一处修改
 version: "0.1.0"