openclacky 1.2.17 → 1.3.0

data/lib/clacky/media/dashscope.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "uri"
+require_relative "base"
+
+module Clacky
+  module Media
+    # Alibaba DashScope (Qwen-Image) image generation provider.
+    #
+    # DashScope is NOT an OpenAI-compatible image API. It has its own
+    # endpoint, request envelope and response schema:
+    #
+    #   POST <host>/api/v1/services/aigc/multimodal-generation/generation
+    #   Authorization: Bearer <key>
+    #   { "model": "qwen-image-2.0-pro",
+    #     "input":      { "messages": [ { "role": "user",
+    #                                     "content": [ { "text": "<prompt>" } ] } ] },
+    #     "parameters": { "size": "2048*2048", "n": 1,
+    #                     "prompt_extend": true, "watermark": false } }
+    #
+    #   => { "output": { "choices": [ { "message": { "content": [
+    #          { "image": "https://...png?Expires=..." } ] } } ] },
+    #        "usage": { "width": 2048, "height": 2048, "image_count": 1 } }
+    #
+    # The image link expires after 24h, so we download and persist it under
+    # <output_dir>/assets/generated/ (via Base#save_image_from_url), matching
+    # the on-disk shape of the base64 providers.
+    #
+    # Routing: Generator sends any base_url under *.aliyuncs.com here. We
+    # derive the real generation endpoint from the host so users can paste
+    # the compatible-mode base_url (…/compatible-mode/v1) they already use
+    # for Qwen text models and still get working image generation.
+    class DashScope < Base
+      GENERATION_PATH = "/api/v1/services/aigc/multimodal-generation/generation"
+
+      # aspect_ratio -> "<width>*<height>" (DashScope uses '*' not 'x').
+      # qwen-image-2.0 / -plus / -max share these recommended resolutions;
+      # the 2.0 series accepts arbitrary sizes within 512*512..2048*2048,
+      # the max/plus series only accept a fixed set, so we stick to values
+      # that are valid for every family.
+      ASPECT_TO_SIZE_V2 = {
+        "landscape" => "2688*1536", # 16:9
+        "square"    => "2048*2048", # 1:1
+        "portrait"  => "1536*2688"  # 9:16
+      }.freeze
+
+      ASPECT_TO_SIZE_MAX_PLUS = {
+        "landscape" => "1664*928",  # 16:9
+        "square"    => "1328*1328", # 1:1
+        "portrait"  => "928*1664"   # 9:16
+      }.freeze
+
+      DEFAULT_ASPECT = "landscape"
+      PROVIDER_ID    = "qwen"
+
+      def generate_image(prompt:, aspect_ratio: DEFAULT_ASPECT, output_dir: nil, n: 1, **_kwargs)
+        aspect = size_table.key?(aspect_ratio) ? aspect_ratio : DEFAULT_ASPECT
+        size   = size_table[aspect]
+
+        if prompt.to_s.strip.empty?
+          return error_response(
+            error: "Prompt is required and must be a non-empty string",
+            error_type: "invalid_argument",
+            provider: PROVIDER_ID,
+            aspect_ratio: aspect
+          )
+        end
+
+        if @api_key.to_s.empty?
+          return error_response(
+            error: "api_key not configured for image model '#{@model}'",
+            error_type: "auth_required",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        payload = {
+          model: @model,
+          input: {
+            messages: [
+              { role: "user", content: [{ text: prompt }] }
+            ]
+          },
+          parameters: {
+            size: size,
+            n: n,
+            prompt_extend: true,
+            watermark: false
+          }
+        }
+
+        begin
+          response = connection.post(GENERATION_PATH) do |req|
+            req.headers["Content-Type"]  = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+            req.body = JSON.generate(payload)
+          end
+        rescue Faraday::Error => e
+          return error_response(
+            error: "HTTP request failed: #{e.message}",
+            error_type: "network_error",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        body = parse_json(response.body)
+        unless body.is_a?(Hash)
+          return error_response(
+            error: "Invalid JSON response from upstream",
+            error_type: "invalid_response",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        # DashScope reports business failures via top-level code/message,
+        # sometimes alongside a non-2xx status, sometimes 200.
+        if body["code"] && !body["code"].to_s.empty?
+          return error_response(
+            error: "Upstream error #{body["code"]}: #{body["message"]}",
+            error_type: "api_error",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        unless response.success?
+          return error_response(
+            error: "Upstream #{response.status}: #{truncate(response.body, 500)}",
+            error_type: "api_error",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        image_url = extract_image_url(body)
+        if image_url.nil?
+          return error_response(
+            error: "Upstream returned no image data",
+            error_type: "empty_response",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        local_path = save_image_from_url(image_url, output_dir: output_dir || Dir.pwd, prefix: "img")
+        if local_path.nil?
+          return error_response(
+            error: "Failed to download generated image from #{image_url}",
+            error_type: "download_failed",
+            provider: PROVIDER_ID,
+            prompt: prompt,
+            aspect_ratio: aspect
+          )
+        end
+
+        usage = body["usage"]
+        success_response(
+          image: local_path,
+          prompt: prompt,
+          aspect_ratio: aspect,
+          provider: PROVIDER_ID,
+          extra: {
+            "size"      => size,
+            "usage"     => usage,
+            "request_id" => body["request_id"]
+          }.compact
+        )
+      end
+
+      # qwen-image-max / qwen-image-plus accept only the fixed resolution set;
+      # everything else (qwen-image-2.0 family, plain qwen-image) uses the 2.0
+      # recommended sizes.
+      private def size_table
+        if @model.to_s.match?(/qwen-image-(max|plus)/i)
+          ASPECT_TO_SIZE_MAX_PLUS
+        else
+          ASPECT_TO_SIZE_V2
+        end
+      end
+
+      # output.choices[].message.content[].image -> first image URL
+      private def extract_image_url(body)
+        choices = body.dig("output", "choices")
+        return nil unless choices.is_a?(Array)
+
+        choices.each do |choice|
+          content = choice.dig("message", "content")
+          next unless content.is_a?(Array)
+
+          content.each do |block|
+            img = block.is_a?(Hash) ? block["image"] : nil
+            return img if img.is_a?(String) && !img.empty?
+          end
+        end
+        nil
+      end
+
+      private def connection
+        Faraday.new(url: endpoint_base) do |f|
+          f.options.timeout      = 240
+          f.options.open_timeout = 10
+        end
+      end
+
+      # Derive the API root (scheme + host) from the configured base_url,
+      # discarding any path the user pasted (e.g. /compatible-mode/v1). The
+      # generation path is then appended by #connection.post. Falls back to
+      # the mainland host if the configured URL can't be parsed.
+      private def endpoint_base
+        uri = URI.parse(@base_url.to_s)
+        if uri.scheme && uri.host
+          "#{uri.scheme}://#{uri.host}"
+        else
+          "https://dashscope.aliyuncs.com"
+        end
+      rescue URI::InvalidURIError
+        "https://dashscope.aliyuncs.com"
+      end
+
+      private def parse_json(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        nil
+      end
+
+      private def truncate(str, max)
+        s = str.to_s
+        s.length > max ? "#{s[0, max]}..." : s
+      end
+    end
+  end
+end

data/lib/clacky/media/gemini.rb

@@ -31,6 +31,16 @@ module Clacky
           aspect_ratio: aspect_ratio
         )
       end
+
+      def generate_video(prompt:, aspect_ratio: "landscape", duration_seconds: nil, output_dir: nil, **_kwargs)
+        video_error_response(
+          error: "Direct Google AI Studio video generation is not supported. Use the openclacky gateway (base_url https://api.openclacky.com) with a video model such as or-veo-3-1.",
+          error_type: "not_implemented",
+          provider: "gemini-direct",
+          prompt: prompt,
+          aspect_ratio: aspect_ratio
+        )
+      end
     end
   end
 end

data/lib/clacky/media/generator.rb

@@ -2,6 +2,7 @@
 
 require_relative "openai_compat"
 require_relative "gemini"
+require_relative "dashscope"
 
 module Clacky
   module Media
@@ -22,6 +23,17 @@ module Clacky
         "aiplatform.googleapis.com"
       ].freeze
 
+      # Hosts that speak Alibaba's native DashScope (Qwen-Image) API instead
+      # of an OpenAI-compatible facade. Matched as a substring so every
+      # regional variant (dashscope / dashscope-intl / dashscope-us, and the
+      # Singapore *.maas.aliyuncs.com workspace hosts) is caught. Third-party
+      # aggregators (SiliconFlow, OpenRouter, …) that re-expose qwen-image
+      # behind an OpenAI-compatible endpoint are NOT under aliyuncs.com, so
+      # they correctly keep going through OpenAICompat.
+      DASHSCOPE_NATIVE_HOSTS = [
+        "aliyuncs.com"
+      ].freeze
+
       # @param agent_config [Clacky::AgentConfig]
       def initialize(agent_config)
         @agent_config = agent_config
@@ -32,6 +44,16 @@ module Clacky
         @agent_config.find_model_by_type("image")
       end
 
+      # @return [Hash, nil] the type=video model entry, or nil if not configured
+      def video_model_entry
+        @agent_config.find_model_by_type("video")
+      end
+
+      # @return [Hash, nil] the type=audio model entry, or nil if not configured
+      def audio_model_entry
+        @agent_config.find_model_by_type("audio")
+      end
+
       def generate_image(prompt:, aspect_ratio: "landscape", output_dir: nil, **kwargs)
         entry = image_model_entry
         if entry.nil?
@@ -55,11 +77,62 @@ module Clacky
         )
       end
 
+      def generate_video(prompt:, aspect_ratio: "landscape", duration_seconds: nil, output_dir: nil, **kwargs)
+        entry = video_model_entry
+        if entry.nil?
+          return {
+            "success"    => false,
+            "video"      => nil,
+            "error"      => "No video model configured. Add a model with type=video in settings.",
+            "error_type" => "not_configured",
+            "provider"   => "",
+            "model"      => "",
+            "prompt"     => prompt
+          }
+        end
+
+        provider = build_provider_for(entry)
+        provider.generate_video(
+          prompt: prompt,
+          aspect_ratio: aspect_ratio,
+          duration_seconds: duration_seconds,
+          output_dir: output_dir,
+          **kwargs
+        )
+      end
+
+      def generate_speech(input:, voice: nil, output_dir: nil, **kwargs)
+        entry = audio_model_entry
+        if entry.nil?
+          return {
+            "success"    => false,
+            "audio"      => nil,
+            "error"      => "No audio model configured. Add a model with type=audio in settings.",
+            "error_type" => "not_configured",
+            "provider"   => "",
+            "model"      => "",
+            "input"      => input
+          }
+        end
+
+        provider = build_provider_for(entry)
+        provider.generate_speech(
+          input: input,
+          voice: voice,
+          output_dir: output_dir,
+          **kwargs
+        )
+      end
+
       # Pick the adapter class for a media model entry.
       #
       # Routing rules:
       #   • base_url points directly at a Google AI Studio host → Gemini
       #     (native /v1beta/models/<m>:generateContent schema).
+      #   • base_url points at an Alibaba DashScope host (*.aliyuncs.com) →
+      #     DashScope (native /api/v1/.../multimodal-generation schema for
+      #     Qwen-Image). Third-party aggregators re-exposing qwen-image behind
+      #     an OpenAI-compatible facade are NOT on aliyuncs.com and fall through.
       #   • everything else → OpenAICompat. This covers OpenAI itself, the
       #     openclacky gateway, OpenRouter, and any third-party proxy that
       #     re-exposes Gemini / Imagen / DALL-E behind /v1/images/generations.
@@ -69,6 +142,8 @@ module Clacky
         url = entry["base_url"].to_s
         if GOOGLE_NATIVE_HOSTS.any? { |host| url.include?(host) }
           Gemini.new(entry)
+        elsif DASHSCOPE_NATIVE_HOSTS.any? { |host| url.include?(host) }
+          DashScope.new(entry)
         else
           OpenAICompat.new(entry)
         end

data/lib/clacky/media/openai_compat.rb

@@ -22,6 +22,12 @@ module Clacky
 
       DEFAULT_ASPECT = "landscape"
 
+      # Video aspect ratios accepted by the gateway's /videos/generations
+      # endpoint. The human-friendly labels map straight through; the gateway
+      # normalises to Veo's "16:9" / "9:16" internally.
+      VIDEO_ASPECTS = %w[landscape portrait].freeze
+      DEFAULT_VIDEO_DURATION = 8
+
       def generate_image(prompt:, aspect_ratio: DEFAULT_ASPECT, output_dir: nil, n: 1, **_kwargs)
         provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
         aspect      = ASPECT_TO_SIZE.key?(aspect_ratio) ? aspect_ratio : DEFAULT_ASPECT
@@ -135,6 +141,143 @@ module Clacky
         )
       end
 
+      def generate_video(prompt:, aspect_ratio: DEFAULT_ASPECT, duration_seconds: nil, output_dir: nil, image: nil, **_kwargs)
+        provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
+        aspect      = VIDEO_ASPECTS.include?(aspect_ratio) ? aspect_ratio : DEFAULT_ASPECT
+        duration    = duration_seconds.to_i
+        duration    = DEFAULT_VIDEO_DURATION if duration <= 0
+
+        if prompt.to_s.strip.empty?
+          return video_error_response(
+            error: "Prompt is required and must be a non-empty string",
+            error_type: "invalid_argument", provider: provider_id, aspect_ratio: aspect
+          )
+        end
+        if @api_key.to_s.empty?
+          return video_error_response(
+            error: "api_key not configured for video model '#{@model}'",
+            error_type: "auth_required", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        payload = { model: @model, prompt: prompt, aspect_ratio: aspect, duration_seconds: duration }
+        payload[:image] = image if image.is_a?(Hash) && image["b64_json"]
+
+        begin
+          response = video_connection.post("videos/generations") do |req|
+            req.headers["Content-Type"]  = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+            req.body = JSON.generate(payload)
+          end
+        rescue Faraday::Error => e
+          return video_error_response(
+            error: "HTTP request failed: #{e.message}",
+            error_type: "network_error", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        unless response.success?
+          return video_error_response(
+            error: "Upstream #{response.status}: #{truncate(response.body, 500)}",
+            error_type: "api_error", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        body = parse_json(response.body)
+        return video_error_response(
+          error: "Invalid JSON response from upstream",
+          error_type: "invalid_response", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+        ) unless body.is_a?(Hash)
+
+        first = (body["data"] || []).first
+        if first.nil? || first["b64_json"].to_s.empty?
+          return video_error_response(
+            error: "Upstream returned no video data",
+            error_type: "empty_response", provider: provider_id, prompt: prompt, aspect_ratio: aspect
+          )
+        end
+
+        path = save_b64_video(first["b64_json"], output_dir: output_dir || Dir.pwd, prefix: "vid")
+        video_success_response(
+          video: path, prompt: prompt, aspect_ratio: aspect, provider: provider_id,
+          extra: {
+            "duration_seconds" => duration,
+            "usage"            => body["usage"],
+            "cost_usd"         => body["cost_usd"]
+          }.compact
+        )
+      end
+
+      def generate_speech(input:, voice: nil, output_dir: nil, **_kwargs)
+        provider_id = Clacky::Providers.find_by_base_url(@base_url) || "custom"
+
+        if input.to_s.strip.empty?
+          return audio_error_response(
+            error: "input is required and must be a non-empty string",
+            error_type: "invalid_argument", provider: provider_id, voice: voice.to_s
+          )
+        end
+        if @api_key.to_s.empty?
+          return audio_error_response(
+            error: "api_key not configured for audio model '#{@model}'",
+            error_type: "auth_required", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        payload = { model: @model, input: input }
+        payload[:voice] = voice if voice && !voice.to_s.strip.empty?
+
+        begin
+          response = audio_connection.post("audio/speech") do |req|
+            req.headers["Content-Type"]  = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+            req.body = JSON.generate(payload)
+          end
+        rescue Faraday::Error => e
+          return audio_error_response(
+            error: "HTTP request failed: #{e.message}",
+            error_type: "network_error", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        unless response.success?
+          return audio_error_response(
+            error: "Upstream #{response.status}: #{truncate(response.body, 500)}",
+            error_type: "api_error", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        body = parse_json(response.body)
+        return audio_error_response(
+          error: "Invalid JSON response from upstream",
+          error_type: "invalid_response", provider: provider_id, input: input, voice: voice.to_s
+        ) unless body.is_a?(Hash)
+
+        first = (body["data"] || []).first
+        if first.nil? || first["b64_json"].to_s.empty?
+          return audio_error_response(
+            error: "Upstream returned no audio data",
+            error_type: "empty_response", provider: provider_id, input: input, voice: voice.to_s
+          )
+        end
+
+        ext = case first["mime_type"].to_s
+              when "audio/mpeg", "audio/mp3" then "mp3"
+              when "audio/ogg" then "ogg"
+              else "wav"
+              end
+
+        path = save_b64_audio(first["b64_json"], output_dir: output_dir || Dir.pwd, prefix: "tts", extension: ext)
+        audio_success_response(
+          audio: path, input: input, voice: body["voice"] || voice.to_s, provider: provider_id,
+          extra: {
+            "mime_type" => first["mime_type"],
+            "usage"     => body["usage"],
+            "cost_usd"  => body["cost_usd"]
+          }.compact
+        )
+      end
+
       private def connection
         Faraday.new(url: normalized_base_url) do |f|
           f.options.timeout      = 240
@@ -142,6 +285,23 @@ module Clacky
         end
       end
 
+      # Video generation runs the gateway's submit+poll cycle inside one
+      # request, which can take several minutes; give it a much longer read
+      # timeout than the image path.
+      private def video_connection
+        Faraday.new(url: normalized_base_url) do |f|
+          f.options.timeout      = 600
+          f.options.open_timeout = 10
+        end
+      end
+
+      private def audio_connection
+        Faraday.new(url: normalized_base_url) do |f|
+          f.options.timeout      = 120
+          f.options.open_timeout = 10
+        end
+      end
+
       private def gemini_family?(model_name)
         model_name.to_s.match?(/gemini|imagen/i)
       end

data/lib/clacky/message_history.rb

@@ -150,11 +150,6 @@ module Clacky
       @messages.find { |m| m[:subagent_instructions] }
     end
 
-    # Return all messages where task_id <= given id (Time Machine support).
-    def for_task(task_id)
-      @messages.select { |m| !m[:task_id] || m[:task_id] <= task_id }
-    end
-
     # ─────────────────────────────────────────────
     # Size helpers
     # ─────────────────────────────────────────────
@@ -191,8 +186,18 @@ module Clacky
     #   can't fire when the previous turns came from a provider that keeps
     #   thinking inline (e.g. MiniMax: <think>...</think> in content), so
     #   this bypass lets us recover on the retry without a server restart.
-    def to_api(force_reasoning_content_pad: false)
-      msgs = @messages.map { |m| strip_for_api(m) }
+    # Convert to API-ready messages. When `task_chain` is given (a Set of
+    # task IDs forming the active task's ancestor chain), messages tagged with
+    # a task_id outside that chain are dropped first — this is the Time Machine
+    # path, ensuring undone/sibling-branch turns never reach the LLM. Messages
+    # without a task_id (system / injected context) are always kept.
+    def to_api(force_reasoning_content_pad: false, task_chain: nil)
+      source = if task_chain
+        @messages.select { |m| !m[:task_id] || task_chain.include?(m[:task_id]) }
+      else
+        @messages
+      end
+      msgs = source.map { |m| strip_for_api(m) }
       msgs = repair_tool_call_pairing(msgs)
       ensure_reasoning_content_consistency(msgs, force: force_reasoning_content_pad)
     end

data/lib/clacky/providers.rb

@@ -60,6 +60,34 @@ module Clacky
           "or-gpt-image-2"             => "GPT Image 2"
         },
         "default_image_model" => "or-gpt-image-2",
+        # Video generation models served by the openclacky gateway, which
+        # routes them to Vertex AI Veo (async predictLongRunning under the
+        # hood; the gateway hides the polling and returns the MP4 inline).
+        "video_models" => [
+          "or-veo-3-1",
+          "or-veo-3-1-fast",
+          "or-veo-3",
+          "or-veo-3-fast"
+        ],
+        "video_model_aliases" => {
+          "or-veo-3-1"      => "Veo 3.1",
+          "or-veo-3-1-fast" => "Veo 3.1 Fast",
+          "or-veo-3"        => "Veo 3",
+          "or-veo-3-fast"   => "Veo 3 Fast"
+        },
+        "default_video_model" => "or-veo-3-1",
+        # Text-to-speech models served by the openclacky gateway, which
+        # routes them to Vertex AI Gemini 2.5 (responseModalities=["AUDIO"]).
+        # The gateway returns WAV inline as base64.
+        "audio_models" => [
+          "or-tts-gemini-2-5-flash",
+          "or-tts-gemini-2-5-pro"
+        ],
+        "audio_model_aliases" => {
+          "or-tts-gemini-2-5-flash" => "Gemini 2.5 Flash TTS",
+          "or-tts-gemini-2-5-pro"   => "Gemini 2.5 Pro TTS"
+        },
+        "default_audio_model" => "or-tts-gemini-2-5-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.

data/lib/clacky/rich_ui_controller.rb

@@ -559,7 +559,9 @@ module Clacky
       @running = false
     end
 
-    def stop(clear_screen: false)
+    # Clears the screen on exit by default — the Rich UI repaints fullscreen
+    # and leaves no useful scrollback to preserve.
+    def stop(clear_screen: true)
       @running = false
       @shell.stop
       RubyRich::Terminal.clear if clear_screen