smart_prompt 0.5.1 → 0.5.3

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__)