smart_prompt 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73eed476ea088ca5d249ae100e774c4bbe4235242773c49b478ac60304f2250e
-  data.tar.gz: 7e28652297f66ab0829ea9f24927bfa0d8f8618915dc4e2d969f7733c29ca8bc
+  metadata.gz: 1477a83b116691863533a9b1726e40be07b03b4faa67b60ebc72fe6a290d60f1
+  data.tar.gz: c9e71e998318d186f296495679573ccb2ad9b539420b3b9c3ee02314db8e2d8b
 SHA512:
-  metadata.gz: cfed4b173e3382fd59c8be7dd7712dd3e2da56948cf605e1e402e0c998bd20e6f0867915c9d8f749e6f794a63d796a013ea4c5aabad0177df17b2649e931c181
-  data.tar.gz: 21a684256011301008700ce3b66bf2220778ced62d1ecb4195fc610d492123a14717420f671af3499662f4df4fb9004948a7aeb5b9788756e715be2fdc9c344a
+  metadata.gz: a433f3724915b38af6e3a1e66d3f52568ec305f85d3b038643ffeb1ae5522547a8e5c6769e6c53cf1a081ca353587ddd0156987a4d2c705f25f267e388a7f5b9
+  data.tar.gz: 90b3ba6033912705cc096b17765f0ad221d6f8a6e6b3b2a4350345d4b0777ebdee359d30604320918891ee7965cb55528a0aab4c12b9d9eebd67237ff52d7876

data/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Added
+- **硅基流动 (SiliconFlow) support** — unified `SiliconFlowAdapter` covering all REST categories: chat, multimodal vision (image/video/audio), embeddings (BAAI/bge-m3), rerank (bge-reranker-v2-m3), text-to-image (Kolors), image-edit (Qwen-Image-Edit), text-to-video (Wan2.2 async submit/poll), TTS (CosyVoice2), ASR (SenseVoiceSmall), and custom-voice management — with SSE streaming, reasoning_content passthrough, and the provider-correct async video flow (`POST /video/submit` → `requestId`, `POST /video/status` → `results.videos[].url`)
+
+### Changed
+- **Refactored the Zhipu / SenseNova / SiliconFlow adapters** — extracted byte-identical cross-provider logic into four shared concerns under `lib/smart_prompt/concerns/` (`HTTPClient`, `MultimodalMessages`, `OpenAIChatShaping`, `ImagePersistence`), and split the Zhipu and SiliconFlow adapters into per-modality capability modules under `lib/smart_prompt/adapters/<provider>/` (`Text` / `Embed` / `Image` / `Video` / `Voice` / `Rerank`). Pure internal refactor — no public-API change (`send_request` stays 5-arg, all DSL-delegated method names preserved), behavior unchanged. ~286 lines removed and the previously triplicated HTTP / multimodal / chat-shaping / image-persistence code now has a single source.
+
 ## [0.5.1] - 2026-06-21
 ### Added
 - **SenseNova (商汤日日新) support** — unified `SenseNovaAdapter` covering chat (商量), multimodal vision, Cupido embeddings, and 秒画 text-to-image, with SSE streaming and reasoning-field handling

data/README.cn.md

@@ -14,6 +14,7 @@ SmartPrompt 是一个强大的 Ruby gem，提供了优雅的领域特定语言
 - **Anthropic Claude**: 原生支持 Claude 模型及多模态能力
 - **商汤 SenseNova（日日新）**: 单一适配器覆盖商量文本对话、图文多模态、Cupido 向量、秒画文生图四类 API，详见 `examples/sensenova_example.rb`
 - **智谱 AI（BigModel / GLM）**: 单一适配器覆盖全部模型类别——文本对话（GLM-4）、图文多模态（GLM-4V）、向量（embedding-3）、文生图（CogView）、文生视频（CogVideoX）、语音合成（GLM-TTS）、语音识别（GLM-ASR），详见 `examples/zhipu_example.rb`
+- **硅基流动（SiliconFlow）**: 单一适配器覆盖全部模型类别——文本对话、图文多模态、向量（bge-m3）、重排（rerank）、文生图（Kolors）、图像编辑（Qwen-Image-Edit）、文生视频（Wan2.2 异步）、语音合成（CosyVoice2）、语音识别（SenseVoiceSmall）及自定义音色管理，详见 `examples/siliconflow_example.rb`
 - **Llama.cpp 集成**: 直接集成本地 Llama.cpp 服务器
 - **可扩展适配器**: 易于扩展的适配器系统，支持新的 LLM 提供商
 - **统一接口**: 无论底层 LLM 提供商如何，都使用相同的 API

data/README.md

@@ -14,6 +14,7 @@ SmartPrompt is a powerful Ruby gem that provides an elegant domain-specific lang
 - **Anthropic Claude**: Native support for Claude models with multimodal capabilities
 - **SenseNova (商汤日日新)**: One adapter covers chat (商量), multimodal vision (图文多模态), Cupido embeddings (向量), and 秒画 text-to-image — see `examples/sensenova_example.rb`
 - **智谱 AI (BigModel / GLM)**: One adapter covers all categories — chat (GLM-4), vision (GLM-4V), embeddings (embedding-3), text-to-image (CogView), text-to-video (CogVideoX), TTS (GLM-TTS), ASR (GLM-ASR) — see `examples/zhipu_example.rb`
+- **硅基流动 (SiliconFlow)**: One adapter covers all categories — chat, multimodal vision, embeddings, rerank, text-to-image (Kolors), image-edit (Qwen-Image-Edit), text-to-video (Wan2.2 async), TTS (CosyVoice2), ASR (SenseVoiceSmall) — see `examples/siliconflow_example.rb`
 - **Llama.cpp Integration**: Direct integration with local Llama.cpp servers
 - **Extensible Adapters**: Easy-to-extend adapter system for new LLM providers
 - **Unified Interface**: Same API regardless of the underlying LLM provider

data/lib/smart_prompt/sensenova_adapter.rb

@@ -3,6 +3,10 @@ require "json"
 require "net/http"
 require "uri"
 require "fileutils"
+require_relative "concerns/image_persistence"
+require_relative "concerns/openai_chat_shaping"
+require_relative "concerns/multimodal_messages"
+require_relative "concerns/http_client"
 
 module SmartPrompt
   # Adapter for SenseNova (商汤 日日新) — the SenseCore large-model platform.
@@ -38,7 +42,6 @@ module SmartPrompt
       2048x2048 2752x1536 1536x2752 3072x1376 1344x3136 2560x720 3072x864
     ].freeze
     DEFAULT_IMAGE_SIZE = "2048x2048".freeze
-    SUPPORTED_IMAGE_FORMATS = %w[jpg jpeg png gif bmp webp].freeze
 
     # SenseNova sampling parameters forwarded from config to the chat request when present.
     CHAT_OPTIONAL_KEYS = %w[
@@ -46,6 +49,31 @@ module SmartPrompt
       reasoning_effort max_completion_tokens max_tokens
     ].freeze
 
+    include ImagePersistence
+    include OpenAIChatShaping
+    include MultimodalMessages
+    include HTTPClient
+
+    # ---- hooks for shared concerns -------------------------------------------
+    def provider_label
+      "SenseNova"
+    end
+
+    def default_image_prefix
+      "sensenova_image"
+    end
+
+    # SenseNova exposes the reasoning trace under `reasoning` (not reasoning_content)
+    # and also returns system_fingerprint — override the OpenAIChatShaping hooks so the
+    # shared shaper still produces the uniform reasoning_content / fingerprint output.
+    def reasoning_field_name
+      "reasoning"
+    end
+
+    def extra_top_level_fields(raw)
+      { "system_fingerprint" => raw["system_fingerprint"] }
+    end
+
     def initialize(config)
       super
       SmartPrompt.logger.info "Start create the SmartPrompt SenseNovaAdapter."
@@ -166,16 +194,7 @@ module SmartPrompt
       images
     end
 
-    # Save one or many generated images to disk (Array from #generate_image or a single hash).
-    def save_image(image_data, output_dir = "./output", filename_prefix = "sensenova_image")
-      FileUtils.mkdir_p(output_dir)
-      images = image_data.is_a?(Array) ? image_data : [image_data]
-      saved = images.each_with_index.map do |img, index|
-        save_single_image(img, output_dir, "#{filename_prefix}_#{index + 1}")
-      end
-      SmartPrompt.logger.info "Saved #{saved.size} SenseNova image(s) to #{output_dir}"
-      saved
-    end
+    # (save_image / save_single_image provided by ImagePersistence concern.)
 
     private
 
@@ -192,171 +211,10 @@ module SmartPrompt
       body
     end
 
-    # Pass messages through, normalizing any multimodal content. Local image paths inside
-    # image_url.url are converted to data: URLs; http(s)/data URLs and plain text pass through.
-    def process_multimodal_messages(messages)
-      messages.map do |msg|
-        role = msg[:role] || msg["role"]
-        content = msg[:content] || msg["content"]
-        content = content.map { |item| normalize_content_item(item) } if content.is_a?(Array)
-        { "role" => role, "content" => content }
-      end
-    end
-
-    def normalize_content_item(item)
-      return { "type" => "text", "text" => item.to_s } unless item.is_a?(Hash)
-
-      type = item[:type] || item["type"]
-      if type == "image_url"
-        iu = item[:image_url] || item["image_url"]
-        url = iu.is_a?(Hash) ? (iu[:url] || iu["url"]) : iu
-        { "type" => "image_url", "image_url" => { "url" => normalize_image_url(url) } }
-      else
-        stringify_hash(item)
-      end
-    end
-
-    def normalize_image_url(url)
-      return url if url.nil?
-      return url if url.start_with?("http://", "https://", "data:")
+    # (process_multimodal_messages / normalize_* / stringify_hash provided by MultimodalMessages concern.)
+    # (build_completion_response / build_stream_chunk provided by OpenAIChatShaping concern.)
 
-      raise Error, "Image file not found: #{url}" unless File.exist?(url)
-      ext = File.extname(url).downcase.delete(".")
-      raise Error, "Unsupported image format: #{ext}" unless SUPPORTED_IMAGE_FORMATS.include?(ext)
-      mime = ext == "jpg" ? "jpeg" : ext
-      "data:image/#{mime};base64,#{Base64.strict_encode64(File.binread(url))}"
-    end
-
-    # ---- response shaping -----------------------------------------------------
-
-    # Convert a non-streaming SenseNova response into the OpenAI completion shape the
-    # rest of SmartPrompt expects, surfacing the reasoning model's `reasoning` field.
-    def build_completion_response(raw)
-      msg = raw.dig("choices", 0, "message") || {}
-      message = { "role" => msg["role"] || "assistant" }
-      message["content"] = msg["content"]
-      message["reasoning_content"] = msg["reasoning"] if msg["reasoning"]
-      message["tool_calls"] = msg["tool_calls"] if msg["tool_calls"]
-
-      response = {
-        "id"      => raw["id"],
-        "object"  => raw["object"] || "chat.completion",
-        "created" => raw["created"],
-        "model"   => raw["model"],
-        "choices" => [{
-          "index"         => 0,
-          "message"       => message,
-          "finish_reason" => raw.dig("choices", 0, "finish_reason"),
-        }],
-      }
-      response["usage"] = raw["usage"] if raw["usage"]
-      response["system_fingerprint"] = raw["system_fingerprint"] if raw["system_fingerprint"]
-      response
-    end
-
-    # Convert one SSE event from SenseNova's stream into an OpenAI-style streaming chunk.
-    # The key remap is delta.reasoning -> delta.reasoning_content, which is what
-    # Engine#@stream_proc reads for reasoning models.
-    def build_stream_chunk(data)
-      chunk = {
-        "id"      => data["id"],
-        "object"  => data["object"],
-        "created" => data["created"],
-        "model"   => data["model"],
-      }
-      chunk["usage"]             = data["usage"]             if data["usage"]
-      chunk["system_fingerprint"] = data["system_fingerprint"] if data["system_fingerprint"]
-
-      choices = data["choices"] || []
-      if choices.any?
-        delta = choices[0]["delta"] || {}
-        new_delta = {}
-        new_delta["role"]              = delta["role"]      if delta["role"]
-        new_delta["content"]           = delta["content"]   if delta["content"]
-        new_delta["reasoning_content"] = delta["reasoning"] if delta["reasoning"]
-        new_delta["tool_calls"]        = delta["tool_calls"] if delta["tool_calls"]
-        chunk["choices"] = [{
-          "index"         => choices[0]["index"] || 0,
-          "delta"         => new_delta,
-          "finish_reason" => choices[0]["finish_reason"],
-        }]
-      else
-        # Usage-only final event (choices is an empty array).
-        chunk["choices"] = []
-      end
-      chunk
-    end
-
-    # ---- HTTP -----------------------------------------------------------------
-
-    def http_post_json(url, body)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl     = (uri.scheme == "https")
-      http.open_timeout = 30
-      http.read_timeout = 240
-
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request["Content-Type"]  = "application/json"
-      request["Authorization"] = "Bearer #{@api_key}"
-      request.body = body.to_json
-
-      SmartPrompt.logger.debug "SenseNova POST #{uri} body=#{body.to_json}"
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
-      else
-        SmartPrompt.logger.error "SenseNova API error: #{response.code} - #{response.body}"
-        raise LLMAPIError, "SenseNova API error: #{response.code} - #{response.body}"
-      end
-    end
-
-    # POST with stream:true and yield each parsed SSE `data:` payload to the block.
-    def stream_chat(url, body)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl      = (uri.scheme == "https")
-      http.open_timeout  = 30
-      http.read_timeout  = 300
-
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request["Content-Type"]  = "application/json"
-      request["Authorization"] = "Bearer #{@api_key}"
-      request["Accept"]        = "text/event-stream"
-      request.body = body.to_json
-
-      buffer = ""
-      done = false
-
-      http.request(request) do |response|
-        unless response.is_a?(Net::HTTPSuccess)
-          raise LLMAPIError, "SenseNova stream error: #{response.code} - #{response.body}"
-        end
-
-        response.read_body do |segment|
-          break if done
-          buffer << segment
-          while (idx = buffer.index("\n"))
-            line = buffer.slice!(0, idx + 1).strip
-            next if line.empty? || !line.start_with?("data:")
-
-            payload = line.sub(/\Adata:\s*/, "")
-            if payload == "[DONE]"
-              done = true
-              break
-            end
-
-            begin
-              data = JSON.parse(payload)
-            rescue JSON::ParserError
-              next
-            end
-            yield data
-          end
-        end
-      end
-    end
+    # (http_post_json / stream_chat provided by HTTPClient concern.)
 
     # Resolve the image size: default to 2048x2048 when none given, and warn (but still
     # send) when the caller asks for a size sensenova-u1-fast does not accept.
@@ -370,41 +228,6 @@ module SmartPrompt
       size
     end
 
-    def save_single_image(image_data, output_dir, filename)
-      if image_data[:b64_json]
-        file_path = File.join(output_dir, "#{filename}.png")
-        File.binwrite(file_path, Base64.decode64(image_data[:b64_json]))
-      elsif image_data[:url]
-        uri = URI.parse(image_data[:url])
-        response = Net::HTTP.get_response(uri)
-        raise Error, "Failed to download image from URL: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-        ext = case response["content-type"]
-              when "image/jpeg", "image/jpg" then "jpg"
-              when "image/png"               then "png"
-              when "image/gif"               then "gif"
-              when "image/webp"              then "webp"
-              else "png"
-              end
-        file_path = File.join(output_dir, "#{filename}.#{ext}")
-        File.binwrite(file_path, response.body)
-      else
-        raise Error, "No image data available to save"
-      end
-      file_path
-    end
-
-    def stringify_hash(hash)
-      case hash
-      when Hash
-        hash.each_with_object({}) do |(k, v), memo|
-          memo[k.to_s] = stringify_hash(v)
-        end
-      when Array
-        hash.map { |v| stringify_hash(v) }
-      else
-        hash
-      end
-    end
+    # (stringify_hash provided by MultimodalMessages concern.)
   end
 end

data/lib/smart_prompt/version.rb

@@ -1,3 +1,3 @@
 module SmartPrompt
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/lib/smart_prompt/zhipu_adapter.rb

@@ -3,38 +3,60 @@ require "json"
 require "net/http"
 require "uri"
 require "fileutils"
+require_relative "concerns/image_persistence"
+require_relative "concerns/openai_chat_shaping"
+require_relative "concerns/multimodal_messages"
+require_relative "concerns/http_client"
+require_relative "adapters/zhipu/text"
+require_relative "adapters/zhipu/embed"
+require_relative "adapters/zhipu/image"
+require_relative "adapters/zhipu/video"
+require_relative "adapters/zhipu/voice"
+require_relative "adapters/zhipu/rerank"
 
 module SmartPrompt
-  # Adapter for 智谱 AI (BigModel / GLM) — covering all REST model categories behind one
-  # provider domain. One adapter owns the whole provider: every category shares the same
-  # base URL `https://open.bigmodel.cn/api/paas/v4` and Bearer-token auth, so a single config
-  # block serves them just by changing `model`.
+  # Adapter for 智谱 AI (BigModel / GLM) — one adapter owns the whole provider: every
+  # category shares the base URL https://open.bigmodel.cn/api/paas/v4 and Bearer auth.
   #
-  #   1. 文本对话 (chat)   — POST {base}/chat/completions      (OpenAI-compatible; reasoning
-  #                          models return message.reasoning_content, the exact field the engine
-  #                          already reads — no remap needed)
-  #   2. 图文多模态 (vision) — same endpoint, OpenAI Vision content array
-  #   3. 向量 (embeddings) — POST {base}/embeddings            (embedding-3, custom dimensions)
-  #   4. 文生图 (image)    — POST {base}/images/generations    (response is NESTED: data.images[].url)
-  #   5. 文生视频 (video)  — POST {base}/videos/generations -> task_id; GET {base}/async-result?task_id=
-  #                          poll until SUCCESS -> video_result.url  (async)
-  #   6. 语音合成 (TTS)    — POST {base}/audio/speech          (glm-tts)
-  #   7. 语音识别 (ASR)    — POST {base}/audio/transcriptions  (glm-asr-2512, multipart)
-  #   8. 重排 (rerank)     — POST {base}/rerank
+  # Per-modality behavior lives in capability modules under adapters/zhipu/
+  # (Text / Embed / Image / Video / Voice / Rerank); cross-provider plumbing (HTTP,
+  # multimodal normalization, chat shaping, image saving) comes from the shared
+  # concerns. This class wires them together + holds config/credentials.
   #
-  # We talk to the endpoints with Net::HTTP directly (like the SenseNova / image / tts / stt /
-  # video adapters) so we can control SSE streaming, the nested image shape, and the async
-  # video flow. No new gem deps.
+  #   chat/vision — POST {base}/chat/completions (OpenAI-compatible; reasoning_content)
+  #   embeddings  — POST {base}/embeddings        (embedding-3, custom dimensions)
+  #   image       — POST {base}/images/generations (nested data.images[].url)
+  #   video       — POST {base}/videos/generations -> GET {base}/async-result (async)
+  #   tts         — POST {base}/audio/speech       (glm-tts)
+  #   asr         — POST {base}/audio/transcriptions (multipart)
+  #   rerank      — POST {base}/rerank
   class ZhipuAIAdapter < LLMAdapter
     DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4".freeze
     # CodeGeeX-4 / coding models use a separate base.
     DEFAULT_CODING_BASE_URL = "https://open.bigmodel.cn/api/coding/paas/v4".freeze
-    SUPPORTED_IMAGE_FORMATS = %w[jpg jpeg png gif bmp webp].freeze
 
-    # Zhipu chat sampling parameters forwarded from config when present.
-    CHAT_OPTIONAL_KEYS = %w[
-      top_p max_tokens do_sample stop presence_penalty frequency_penalty thinking
-    ].freeze
+    # Cross-provider shared concerns
+    include ImagePersistence
+    include OpenAIChatShaping
+    include MultimodalMessages
+    include HTTPClient
+
+    # Per-capability modules
+    include ZhipuAI::Text
+    include ZhipuAI::Embed
+    include ZhipuAI::Image
+    include ZhipuAI::Video
+    include ZhipuAI::Voice
+    include ZhipuAI::Rerank
+
+    # ---- hooks for shared concerns -------------------------------------------
+    def provider_label
+      "Zhipu"
+    end
+
+    def default_image_prefix
+      "zhipu_image"
+    end
 
     def initialize(config)
       super
@@ -44,8 +66,8 @@ module SmartPrompt
       if api_key.is_a?(String) && api_key.start_with?("ENV[") && api_key.end_with?("]")
         api_key = eval(api_key)
       end
-      # Match the other adapters: tolerate a missing key at construction so examples/config
-      # can load without a live key; the first request fails with a clear auth error.
+      # Tolerate a missing key at construction so examples/config can load without a
+      # live key; the first request fails with a clear auth error.
       SmartPrompt.logger.warn "Zhipu api_key is empty — API calls will fail until it is set." if api_key.nil? || api_key.to_s.strip.empty?
 
       @api_key     = api_key
@@ -58,559 +80,13 @@ module SmartPrompt
       SmartPrompt.logger.info "Zhipu base_url=#{@base_url}"
     end
 
-    public
-
-    # ---- chat + vision -------------------------------------------------------
-
-    # Chat / multimodal. Non-streaming returns a full OpenAI-format hash (so last_response
-    # carries usage + reasoning_content); streaming calls +proc+ with each OpenAI-shaped chunk.
-    def send_request(messages, model = nil, temperature = nil, tools = nil, proc = nil)
-      model_name = model || @config["model"]
-      body = build_chat_body(messages, model_name, temperature, tools)
-      SmartPrompt.logger.info "ZhipuAIAdapter: chat request model=#{model_name} stream=#{!proc.nil?}"
-
-      url = chat_url_for(model_name)
-      if proc
-        body["stream"] = true
-        stream_chat(url, body) { |data| proc.call(build_stream_chunk(data), 0) }
-        SmartPrompt.logger.info "ZhipuAIAdapter: streaming request finished"
-        nil
-      else
-        raw = http_post_json(url, body)
-        response = build_completion_response(raw)
-        @last_response = response
-        SmartPrompt.logger.info "ZhipuAIAdapter: received chat response"
-        response
-      end
-    rescue LLMAPIError, Error
-      raise
-    rescue => e
-      SmartPrompt.logger.error "Zhipu chat error: #{e.message}"
-      raise LLMAPIError, "Failed to call Zhipu chat: #{e.message}"
-    end
-
-    # ---- embeddings ----------------------------------------------------------
-
-    # embedding-3 (default 2048 dims); supports a custom `dimensions` (256/512/1024/2048)
-    # via config. Returns the first embedding vector.
-    def embeddings(text, model)
-      model_name = model || @config["embedding_model"] || @config["model"]
-      SmartPrompt.logger.info "ZhipuAIAdapter: embeddings model=#{model_name}"
-
-      body = { "model" => model_name, "input" => text.is_a?(Array) ? text : [text.to_s] }
-      body["dimensions"] = @config["dimensions"] if @config["dimensions"]
-      body["encoding_format"] = @config["encoding_format"] if @config["encoding_format"]
-
-      response =
-        begin
-          http_post_json("#{@base_url}/embeddings", body)
-        rescue LLMAPIError, Error
-          raise
-        rescue => e
-          raise LLMAPIError, "Failed to call Zhipu embeddings: #{e.message}"
-        end
-
-      items = response["data"]
-      unless items.is_a?(Array) && items.any? && items[0]["embedding"]
-        raise LLMAPIError, "No embedding vector in Zhipu response: #{response.inspect}"
-      end
-      items[0]["embedding"]
-    end
-
-    # ---- image (CogView / GLM-Image) -----------------------------------------
-
-    # Text-to-image. The Zhipu response is NESTED: data.images[].url (not OpenAI's data[]),
-    # so we parse defensively. Returns an Array of {url:, b64_json:}.
-    def generate_image(prompt, params = {})
-      SmartPrompt.logger.info "ZhipuAIAdapter: generating image"
-      raise Error, "Prompt cannot be empty" if prompt.nil? || prompt.to_s.strip.empty?
-
-      model_name = params[:model] || @config["image_model"] || @config["model"]
-      raise Error, "No model configured for image generation" if model_name.nil? || model_name.to_s.strip.empty?
-
-      body = { "model" => model_name, "prompt" => prompt.to_s }
-      body["size"]            = params[:size]            if params[:size]
-      body["user"]            = params[:user]            if params[:user]
-      body["response_format"] = params[:response_format] if params[:response_format]
-
-      SmartPrompt.logger.info "Zhipu image params: #{body.except('prompt').inspect}"
-      response =
-        begin
-          http_post_json(@image_url, body)
-        rescue LLMAPIError, Error
-          raise
-        rescue => e
-          raise Error, "Failed to call Zhipu image generation: #{e.message}"
-        end
-
-      images = parse_image_response(response)
-      SmartPrompt.logger.info "ZhipuAIAdapter: generated #{images.size} image(s)"
-      images
-    end
-
-    # Save one or many generated images to disk (Array from #generate_image or a single hash).
-    def save_image(image_data, output_dir = "./output", filename_prefix = "zhipu_image")
-      FileUtils.mkdir_p(output_dir)
-      images = image_data.is_a?(Array) ? image_data : [image_data]
-      saved = images.each_with_index.map do |img, index|
-        save_single_image(img, output_dir, "#{filename_prefix}_#{index + 1}")
-      end
-      SmartPrompt.logger.info "Saved #{saved.size} Zhipu image(s) to #{output_dir}"
-      saved
-    end
-
-    # ---- video (CogVideoX, async) --------------------------------------------
-
-    # Submit a text-to-video (or image-to-video) job. Returns the task id.
-    def generate_video(prompt, params = {})
-      SmartPrompt.logger.info "ZhipuAIAdapter: submitting video job"
-      model_name = params[:model] || @config["video_model"] || @config["model"]
-      raise Error, "No model configured for video generation" if model_name.nil? || model_name.to_s.strip.empty?
-
-      body = { "model" => model_name, "prompt" => prompt.to_s }
-      %i[quality fps duration with_audio resolution request_id seed].each do |k|
-        body[k.to_s] = params[k] unless params[k].nil?
-      end
-      body["image_url"] = normalize_image_url(params[:image_url]) if params[:image_url]
-
-      SmartPrompt.logger.info "Zhipu video params: #{body.except('prompt').inspect}"
-      response =
-        begin
-          http_post_json(@video_url, body)
-        rescue LLMAPIError, Error
-          raise
-        rescue => e
-          raise Error, "Failed to submit Zhipu video job: #{e.message}"
-        end
-
-      task_id = response["id"] || response["task_id"]
-      raise LLMAPIError, "No task id in Zhipu video response: #{response.inspect}" unless task_id
-      SmartPrompt.logger.info "ZhipuAIAdapter: video task #{task_id} submitted"
-      { task_id: task_id, model: model_name, raw: response }
-    end
-
-    # Poll an async task. Returns the raw status hash (task_status etc.).
-    def check_video_status(task_id)
-      SmartPrompt.logger.info "ZhipuAIAdapter: polling video task #{task_id}"
-      http_get_json("#{@query_url}/#{URI.encode_www_form_component(task_id)}")
-    rescue LLMAPIError, Error
-      raise
-    rescue => e
-      raise LLMAPIError, "Failed to query Zhipu video task: #{e.message}"
-    end
-
-    # Block until the task finishes (or times out), then return the video URL.
-    def wait_for_video_completion(task_id, check_interval: 10, timeout: 600)
-      start = Time.now
-      loop do
-        status = check_video_status(task_id)
-        case task_status_of(status)
-        when "SUCCESS"
-          url = video_url_of(status)
-          raise LLMAPIError, "Video succeeded but no url in: #{status.inspect}" unless url
-          SmartPrompt.logger.info "ZhipuAIAdapter: video ready #{url}"
-          return { task_id: task_id, status: "SUCCESS", video_url: url, cover_image_url: cover_url_of(status), raw: status }
-        when "FAIL", "FAILED"
-          raise LLMAPIError, "Zhipu video generation failed: #{status.inspect}"
-        else
-          if Time.now - start > timeout
-            raise LLMAPIError, "Zhipu video generation timeout after #{timeout}s"
-          end
-          SmartPrompt.logger.info "Zhipu video task #{task_id} still processing..."
-          sleep(check_interval)
-        end
-      end
-    end
-
-    def download_video(video_url, output_path)
-      uri = URI.parse(video_url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      response = http.request(Net::HTTP::Get.new(uri.request_uri))
-      raise Error, "Failed to download video: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-      FileUtils.mkdir_p(File.dirname(output_path))
-      File.binwrite(output_path, response.body)
-      SmartPrompt.logger.info "Zhipu video saved to #{output_path}"
-      output_path
-    rescue => e
-      raise e.is_a?(SmartPrompt::Error) ? e : Error, "Error downloading Zhipu video: #{e.message}"
-    end
-
-    # ---- TTS (GLM-TTS) -------------------------------------------------------
-
-    # Returns a base64 data URL for the synthesized audio. GLM-TTS accepts wav/pcm only
-    # (mp3/flac are rejected), so default to wav.
-    def synthesize_speech(text, voice: nil, model: nil, response_format: "wav", **opts)
-      SmartPrompt.logger.info "ZhipuAIAdapter: TTS"
-      raise Error, "Text cannot be empty" if text.nil? || text.to_s.strip.empty?
-
-      model_name = model || @config["tts_model"] || "glm-tts"
-      body = { "model" => model_name, "input" => text.to_s }
-      body["voice"] = voice if voice
-      body["response_format"] = response_format
-      body["speed"] = opts[:speed] if opts[:speed]
-      body["emotion"] = opts[:emotion] if opts[:emotion]
-
-      audio = http_post_binary("#{@base_url}/audio/speech", body)
-      "data:audio/#{response_format};base64,#{Base64.strict_encode64(audio)}"
-    rescue LLMAPIError, Error
-      raise
-    rescue => e
-      raise Error, "Failed to call Zhipu TTS: #{e.message}"
-    end
-
-    def synthesize_to_file(text, output_path, voice: nil, model: nil, response_format: "wav", **opts)
-      data_url = synthesize_speech(text, voice: voice, model: model, response_format: response_format, **opts)
-      FileUtils.mkdir_p(File.dirname(output_path))
-      audio_bytes = Base64.decode64(data_url.sub(/\Adata:audio\/\w+;base64,/, ""))
-      File.binwrite(output_path, audio_bytes)
-      SmartPrompt.logger.info "Zhipu audio saved to #{output_path}"
-      { file_path: output_path, format: response_format }
-    end
-
-    # ---- ASR (GLM-ASR-2512) --------------------------------------------------
-
-    # Transcribe an audio file (local path). Returns {text:}.
-    def transcribe_audio(audio_file, model: nil, language: nil, **opts)
-      SmartPrompt.logger.info "ZhipuAIAdapter: ASR #{File.basename(audio_file)}"
-      raise Error, "Audio file not found: #{audio_file}" unless File.exist?(audio_file)
-
-      model_name = model || @config["asr_model"] || "glm-asr-2512"
-      form = { "model" => model_name }
-      form["language"] = language if language
-      form["prompt"] = opts[:prompt] if opts[:prompt]
-      form["response_format"] = opts[:response_format] if opts[:response_format]
-
-      response = http_post_multipart("#{@base_url}/audio/transcriptions", form, audio_file)
-      { text: response["text"] }
-    rescue LLMAPIError, Error
-      raise
-    rescue => e
-      raise e.is_a?(SmartPrompt::Error) ? e : Error, "Failed to call Zhipu ASR: #{e.message}"
-    end
-
-    # ---- rerank (bonus) ------------------------------------------------------
-
-    def rerank(query, documents, model: nil)
-      model_name = model || @config["rerank_model"] || @config["model"]
-      body = { "model" => model_name, "query" => query, "documents" => documents }
-      response = http_post_json("#{@base_url}/rerank", body)
-      (response["results"] || []).map { |r| { index: r["index"], relevance_score: r["relevance_score"] || r["score"] } }
-    rescue LLMAPIError, Error
-      raise
-    rescue => e
-      raise LLMAPIError, "Failed to call Zhipu rerank: #{e.message}"
-    end
-
     private
 
-    # ---- chat building -------------------------------------------------------
-
-    def chat_url_for(model_name)
-      # CodeGeeX-4 and coding models are served from the coding base.
-      (model_name.to_s.include?("codegeex") || @config["coding"]) ? "#{@coding_base}/chat/completions" : "#{@base_url}/chat/completions"
-    end
-
-    def build_chat_body(messages, model_name, temperature, tools)
-      body = {
-        "model"       => model_name,
-        "messages"    => process_multimodal_messages(messages),
-        "temperature" => @config["temperature"] || temperature || 0.7,
-      }
-      CHAT_OPTIONAL_KEYS.each { |k| body[k] = @config[k] if @config.key?(k) }
-      body["tools"] = tools if tools && !tools.empty?
-      body
-    end
-
-    # Pass messages through, normalizing multimodal content (local image paths -> data URLs).
-    def process_multimodal_messages(messages)
-      messages.map do |msg|
-        role = msg[:role] || msg["role"]
-        content = msg[:content] || msg["content"]
-        content = content.map { |item| normalize_content_item(item) } if content.is_a?(Array)
-        { "role" => role, "content" => content }
-      end
-    end
-
-    def normalize_content_item(item)
-      return { "type" => "text", "text" => item.to_s } unless item.is_a?(Hash)
-
-      type = item[:type] || item["type"]
-      if type == "image_url"
-        iu = item[:image_url] || item["image_url"]
-        url = iu.is_a?(Hash) ? (iu[:url] || iu["url"]) : iu
-        { "type" => "image_url", "image_url" => { "url" => normalize_image_url(url) } }
-      else
-        stringify_hash(item)
-      end
-    end
-
-    def normalize_image_url(url)
-      return url if url.nil?
-      return url if url.start_with?("http://", "https://", "data:")
-
-      raise Error, "Image file not found: #{url}" unless File.exist?(url)
-      ext = File.extname(url).downcase.delete(".")
-      raise Error, "Unsupported image format: #{ext}" unless SUPPORTED_IMAGE_FORMATS.include?(ext)
-      mime = ext == "jpg" ? "jpeg" : ext
-      "data:image/#{mime};base64,#{Base64.strict_encode64(File.binread(url))}"
-    end
-
-    # ---- response shaping ----------------------------------------------------
-
-    # Zhipu's non-streaming chat response is already OpenAI-shaped; normalize to a consistent
-    # hash and preserve reasoning_content where present.
-    def build_completion_response(raw)
-      msg = raw.dig("choices", 0, "message") || {}
-      message = { "role" => msg["role"] || "assistant" }
-      message["content"] = msg["content"]
-      message["reasoning_content"] = msg["reasoning_content"] if msg["reasoning_content"]
-      message["tool_calls"] = msg["tool_calls"] if msg["tool_calls"]
-
-      response = {
-        "id"      => raw["id"],
-        "object"  => raw["object"] || "chat.completion",
-        "created" => raw["created"],
-        "model"   => raw["model"],
-        "choices" => [{
-          "index"         => 0,
-          "message"       => message,
-          "finish_reason" => raw.dig("choices", 0, "finish_reason"),
-        }],
-      }
-      response["usage"] = raw["usage"] if raw["usage"]
-      response
-    end
-
-    # Build an OpenAI-style streaming chunk from a Zhipu SSE event. reasoning_content and
-    # content pass through unchanged (Zhipu already uses these names).
-    def build_stream_chunk(data)
-      chunk = {
-        "id"      => data["id"],
-        "object"  => data["object"],
-        "created" => data["created"],
-        "model"   => data["model"],
-      }
-      chunk["usage"] = data["usage"] if data["usage"]
-
-      choices = data["choices"] || []
-      if choices.any?
-        delta = choices[0]["delta"] || {}
-        new_delta = {}
-        new_delta["role"]              = delta["role"]              if delta["role"]
-        new_delta["content"]           = delta["content"]           if delta["content"]
-        new_delta["reasoning_content"] = delta["reasoning_content"] if delta["reasoning_content"]
-        new_delta["tool_calls"]        = delta["tool_calls"]        if delta["tool_calls"]
-        chunk["choices"] = [{
-          "index"         => choices[0]["index"] || 0,
-          "delta"         => new_delta,
-          "finish_reason" => choices[0]["finish_reason"],
-        }]
-      else
-        chunk["choices"] = []
-      end
-      chunk
-    end
-
-    # Zhipu image response: cogview-3-flash returns the FLAT OpenAI shape data[].url;
-    # older docs mention a NESTED data.images[].url. Handle both plus a bare-url array.
-    def parse_image_response(response)
-      container = response["data"]
-      items =
-        if container.is_a?(Hash)
-          container["images"] || container["data"] || container["url"]
-        elsif container.is_a?(Array)
-          container
-        end
-      items ||= response["images"] || response["urls"]
-
-      # Some responses return images as a bare array of URLs (strings).
-      items = items.map { |x| x.is_a?(String) ? { "url" => x } : x } if items.is_a?(Array)
-
-      unless items.is_a?(Array) && items.any?
-        SmartPrompt.logger.error "Zhipu image response had no images: #{response.inspect}"
-        raise LLMAPIError, "No image data in Zhipu response"
-      end
-      items.map { |d| { url: d["url"], b64_json: d["b64_json"] } }
-    end
-
-    # Zhipu async task status is under task_status; accept a few aliases.
-    def task_status_of(status)
-      status["task_status"] || status["status"] || "PROCESSING"
-    end
-
-    # video_result is an Array: [{cover_image_url:, url:}]. Pull the first video url.
-    def video_url_of(status)
-      vr = status["video_result"]
-      item = vr.is_a?(Array) ? vr[0] : vr
-      return item["url"] || item["video_url"] if item.is_a?(Hash)
-      status["video_url"] || status.dig("data", "video_url")
-    end
-
-    def cover_url_of(status)
-      vr = status["video_result"]
-      item = vr.is_a?(Array) ? vr[0] : vr
-      item.is_a?(Hash) ? (item["cover_image_url"] || item["cover_url"]) : nil
-    end
-
-    # ---- HTTP ----------------------------------------------------------------
-
-    def http_post_json(url, body)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = 30; http.read_timeout = 240
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Content-Type"]  = "application/json"
-      req["Authorization"] = "Bearer #{@api_key}"
-      req.body = body.to_json
-      SmartPrompt.logger.debug "Zhipu POST #{uri} body=#{body.to_json}"
-      resp = http.request(req)
-      if resp.is_a?(Net::HTTPSuccess)
-        resp.body.to_s.empty? ? {} : JSON.parse(resp.body)
-      else
-        SmartPrompt.logger.error "Zhipu API error: #{resp.code} - #{resp.body}"
-        raise LLMAPIError, "Zhipu API error: #{resp.code} - #{resp.body}"
-      end
-    end
-
-    def http_get_json(url)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = 30; http.read_timeout = 60
-      req = Net::HTTP::Get.new(uri.request_uri)
-      req["Authorization"] = "Bearer #{@api_key}"
-      SmartPrompt.logger.debug "Zhipu GET #{uri}"
-      resp = http.request(req)
-      if resp.is_a?(Net::HTTPSuccess)
-        resp.body.to_s.empty? ? {} : JSON.parse(resp.body)
-      else
-        raise LLMAPIError, "Zhipu API error: #{resp.code} - #{resp.body}"
-      end
-    end
-
-    # Returns the raw response body bytes (for TTS audio).
-    def http_post_binary(url, body)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = 30; http.read_timeout = 120
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Content-Type"]  = "application/json"
-      req["Authorization"] = "Bearer #{@api_key}"
-      req.body = body.to_json
-      resp = http.request(req)
-      if resp.is_a?(Net::HTTPSuccess)
-        resp.body
-      else
-        raise LLMAPIError, "Zhipu TTS API error: #{resp.code} - #{resp.body}"
-      end
-    end
-
-    # multipart/form-data POST with a file upload (for ASR). Returns parsed JSON.
+    # Zhipu's ASR call site uses the legacy 3-arg multipart shape (url, form, file_path).
+    # Adapt it to HTTPClient's 5-arg shape with a sensible audio mime.
     def http_post_multipart(url, form, file_path)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = 30; http.read_timeout = 180
-
-      boundary = "----SmartPrompt#{object_id}"
-      mime = "audio/#{(File.extname(file_path).downcase.delete(".") || "wav")}"
-
-      body = ""
-      form.each do |k, v|
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n"
-        body << "#{v}\r\n"
-      end
-      File.open(file_path, "rb") do |f|
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(file_path)}\"\r\n"
-        body << "Content-Type: #{mime}\r\n\r\n"
-        body << f.read
-        body << "\r\n"
-      end
-      body << "--#{boundary}--\r\n"
-
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Content-Type"]  = "multipart/form-data; boundary=#{boundary}"
-      req["Authorization"] = "Bearer #{@api_key}"
-      req.body = body
-      resp = http.request(req)
-      if resp.is_a?(Net::HTTPSuccess)
-        resp.body.to_s.empty? ? {} : JSON.parse(resp.body)
-      else
-        raise LLMAPIError, "Zhipu ASR API error: #{resp.code} - #{resp.body}"
-      end
-    end
-
-    # POST with stream:true and yield each parsed SSE `data:` payload to the block.
-    def stream_chat(url, body)
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = 30; http.read_timeout = 300
-
-      req = Net::HTTP::Post.new(uri.request_uri)
-      req["Content-Type"]  = "application/json"
-      req["Authorization"] = "Bearer #{@api_key}"
-      req["Accept"]        = "text/event-stream"
-      req.body = body.to_json
-
-      buffer = ""
-      done = false
-      http.request(req) do |response|
-        unless response.is_a?(Net::HTTPSuccess)
-          raise LLMAPIError, "Zhipu stream error: #{response.code} - #{response.body}"
-        end
-        response.read_body do |segment|
-          break if done
-          buffer << segment
-          while (idx = buffer.index("\n"))
-            line = buffer.slice!(0, idx + 1).strip
-            next if line.empty? || !line.start_with?("data:")
-            payload = line.sub(/\Adata:\s*/, "")
-            if payload == "[DONE]"
-              done = true
-              break
-            end
-            begin
-              yield JSON.parse(payload)
-            rescue JSON::ParserError
-              next
-            end
-          end
-        end
-      end
-    end
-
-    def save_single_image(image_data, output_dir, filename)
-      if image_data[:b64_json]
-        file_path = File.join(output_dir, "#{filename}.png")
-        File.binwrite(file_path, Base64.decode64(image_data[:b64_json]))
-      elsif image_data[:url]
-        uri = URI.parse(image_data[:url])
-        response = Net::HTTP.get_response(uri)
-        raise Error, "Failed to download image from URL: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-        ext = case response["content-type"]
-              when "image/jpeg", "image/jpg" then "jpg"
-              when "image/png"               then "png"
-              when "image/gif"               then "gif"
-              when "image/webp"              then "webp"
-              else "png"
-              end
-        file_path = File.join(output_dir, "#{filename}.#{ext}")
-        File.binwrite(file_path, response.body)
-      else
-        raise Error, "No image data available to save"
-      end
-      file_path
-    end
-
-    def stringify_hash(hash)
-      case hash
-      when Hash
-        hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = stringify_hash(v) }
-      when Array
-        hash.map { |v| stringify_hash(v) }
-      else
-        hash
-      end
+      ext = File.extname(file_path).downcase.delete(".")
+      super(url, form, "file", file_path, "audio/#{ext.empty? ? 'wav' : ext}")
     end
   end
 end

data/lib/smart_prompt.rb

@@ -21,6 +21,7 @@ require File.expand_path('../smart_prompt/llamacpp_adapter', __FILE__)
 require File.expand_path('../smart_prompt/anthropic_adapter', __FILE__)
 require File.expand_path('../smart_prompt/sensenova_adapter', __FILE__)
 require File.expand_path('../smart_prompt/zhipu_adapter', __FILE__)
+require File.expand_path('../smart_prompt/siliconflow_adapter', __FILE__)
 require File.expand_path('../smart_prompt/multimodal_adapter', __FILE__)
 require File.expand_path('../smart_prompt/image_generation_adapter', __FILE__)
 require File.expand_path('../smart_prompt/video_generation_adapter', __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_prompt
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - zhuang biaowei