hinow-ai 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32e08f0d016478c52bbe52d51e564988a29148b4f08592718e7cf567a2c12d32
+  data.tar.gz: 8b55afc8c05105fb2b22441c3ca694fcc01e959d19e4bd7f1fe0cfe4ab11e87c
+SHA512:
+  metadata.gz: 1a2d25c9d1494378145321d314a6777e6f6d9921b1b824b5c8c161702e6fef0a702dee313a1764d5c9dac62fd7652ca51912ce4b44fa3d94ddb9351be1efc0e7
+  data.tar.gz: 625638213fa9486a6a46ebfab675fe900ed5a46aa1ee20680581af1f1414b5951436aeec25ff13a136d1fae48d3e3e7e264d7fddb41a08f39c89710e561879b9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HINOW AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,201 @@
+# HINOW Ruby SDK
+
+Official Ruby SDK for the [HINOW AI Inference API](https://hinow.ai).
+
+## Installation
+
+```bash
+gem install hinow-ai
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'hinow-ai'
+```
+
+## Quick Start
+
+```ruby
+require 'hinow'
+
+client = Hinow::Client.new(api_key: 'hi_your_api_key')
+
+# Chat completion
+response = client.chat.completions.create(
+  model: 'deepseek-ai/deepseek-v3.2',
+  messages: [{ role: 'user', content: 'Hello!' }],
+  temperature: 0.7
+)
+
+puts response['choices'][0]['message']['content']
+```
+
+## Configuration
+
+### Global Configuration
+
+```ruby
+Hinow.configure do |config|
+  config.api_key = 'hi_your_api_key'
+  config.base_url = 'https://api.hinow.ai'
+  config.timeout = 120
+end
+
+# Then use the global client
+response = Hinow.client.chat.completions.create(...)
+```
+
+### Environment Variable
+
+```bash
+export HINOW_API_KEY=hi_your_api_key
+```
+
+```ruby
+client = Hinow::Client.new  # Uses HINOW_API_KEY
+```
+
+## Features
+
+### Chat Completions
+
+```ruby
+response = client.chat.completions.create(
+  model: 'deepseek-ai/deepseek-v3.2',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'What is the capital of France?' }
+  ],
+  temperature: 0.7,
+  max_tokens: 1000
+)
+```
+
+### Function Calling
+
+```ruby
+response = client.chat.completions.create(
+  model: 'deepseek-ai/deepseek-v3.2',
+  messages: [{ role: 'user', content: "What's the weather in Paris?" }],
+  tools: [{
+    type: 'function',
+    function: {
+      name: 'get_weather',
+      description: 'Get the current weather in a city',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: { type: 'string', description: 'City name' }
+        },
+        required: ['location']
+      }
+    }
+  }]
+)
+
+if response['choices'][0]['message']['tool_calls']
+  response['choices'][0]['message']['tool_calls'].each do |tool_call|
+    puts "Function: #{tool_call['function']['name']}"
+    puts "Arguments: #{tool_call['function']['arguments']}"
+  end
+end
+```
+
+### Image Generation
+
+```ruby
+response = client.images.generate(
+  model: 'dall-e-3',
+  prompt: 'A beautiful sunset over mountains',
+  size: '1024x1024',
+  quality: 'hd'
+)
+
+response['data']['urls'].each { |url| puts "Image URL: #{url}" }
+```
+
+### Text to Speech
+
+```ruby
+response = client.audio.speech(
+  model: 'tts-1',
+  input: 'Hello, how are you today?',
+  voice: 'alloy',
+  speed: 1.0
+)
+
+response['data']['urls'].each { |url| puts "Audio URL: #{url}" }
+```
+
+### Speech to Text
+
+```ruby
+response = client.audio.transcribe(
+  model: 'whisper-1',
+  file: '/path/to/audio.mp3',
+  language: 'en'
+)
+
+puts "Transcription: #{response['data']['text']}"
+```
+
+### Video Generation
+
+```ruby
+response = client.video.generate(
+  model: 'video-model',
+  prompt: 'A cat playing piano',
+  duration: 5,
+  resolution: '1080p'
+)
+
+response['data']['urls'].each { |url| puts "Video URL: #{url}" }
+```
+
+### Embeddings
+
+```ruby
+response = client.embeddings.create(
+  model: 'text-embedding-ada-002',
+  input: 'Hello world'
+)
+
+embedding = response['data'][0]['embedding']
+puts "Embedding dimensions: #{embedding.length}"
+```
+
+### List Models
+
+```ruby
+response = client.models.list
+response['data'].each { |model| puts "Model: #{model['id']}" }
+```
+
+### Check Balance
+
+```ruby
+balance = client.get_balance
+puts "Balance: #{balance['data']['balance']} #{balance['data']['currency']}"
+```
+
+## Error Handling
+
+```ruby
+begin
+  response = client.chat.completions.create(...)
+rescue Hinow::Error => e
+  puts "Error: #{e.message}"
+  puts "Status code: #{e.status_code}"
+end
+```
+
+## Links
+
+- [HINOW Website](https://hinow.ai)
+- [API Platform](https://platform.hinow.ai)
+- [GitHub](https://github.com/hinow-ai/sdk-ruby)
+
+## License
+
+MIT License

data/lib/hinow/audio.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Audio
+    def initialize(client)
+      @client = client
+    end
+
+    def speech(model:, input:, voice: nil, speed: nil)
+      body = { model: model, prompt: input } # API uses "prompt" not "input"
+
+      parameters = {}
+      parameters[:voice] = voice if voice
+      parameters[:speed] = speed.to_s if speed
+
+      body[:parameters] = parameters unless parameters.empty?
+
+      @client.post("/v1/audio/speech", body)
+    end
+
+    def transcribe(model:, file:, language: nil)
+      payload = {
+        model: model,
+        file: Faraday::Multipart::FilePart.new(file, "audio/*")
+      }
+      payload[:language] = language if language
+
+      @client.post_multipart("/v1/audio/transcriptions", payload)
+    end
+  end
+end

data/lib/hinow/chat.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Chat
+    def initialize(client)
+      @client = client
+    end
+
+    def completions
+      @completions ||= ChatCompletions.new(@client)
+    end
+  end
+
+  class ChatCompletions
+    def initialize(client)
+      @client = client
+    end
+
+    def create(model:, messages:, temperature: nil, max_tokens: nil, top_p: nil,
+               repetition_penalty: nil, response_format: nil, tools: nil, tool_choice: nil)
+      body = {
+        model: model,
+        messages: messages
+      }
+
+      parameters = {}
+      parameters[:temperature] = temperature.to_s if temperature
+      parameters[:max_tokens] = max_tokens.to_s if max_tokens
+      parameters[:top_p] = top_p.to_s if top_p
+      parameters[:repetition_penalty] = repetition_penalty.to_s if repetition_penalty
+
+      body[:parameters] = parameters unless parameters.empty?
+      body[:response_format] = response_format if response_format
+      body[:tools] = tools if tools
+      body[:tool_choice] = tool_choice if tool_choice
+
+      @client.post("/v1/chat/completions", body)
+    end
+  end
+end

data/lib/hinow/client.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Client
+    DEFAULT_BASE_URL = "https://api.hinow.ai"
+    DEFAULT_TIMEOUT = 120
+
+    attr_reader :chat, :images, :audio, :video, :embeddings, :models
+
+    def initialize(api_key: nil, base_url: nil, timeout: nil)
+      @api_key = api_key || ENV["HINOW_API_KEY"]
+      raise Error, "API key is required. Set HINOW_API_KEY environment variable or pass api_key parameter." if @api_key.nil? || @api_key.empty?
+
+      @base_url = (base_url || DEFAULT_BASE_URL).chomp("/")
+      @timeout = timeout || DEFAULT_TIMEOUT
+
+      @connection = Faraday.new(url: @base_url) do |f|
+        f.request :multipart
+        f.request :url_encoded
+        f.headers["Authorization"] = "Bearer #{@api_key}"
+        f.headers["Content-Type"] = "application/json"
+        f.headers["User-Agent"] = "hinow-ruby/#{VERSION}"
+        f.options.timeout = @timeout
+        f.adapter Faraday.default_adapter
+      end
+
+      @chat = Chat.new(self)
+      @images = Images.new(self)
+      @audio = Audio.new(self)
+      @video = Video.new(self)
+      @embeddings = Embeddings.new(self)
+      @models = Models.new(self)
+    end
+
+    def get_balance
+      get("/v1/balance")
+    end
+
+    def get(path)
+      response = @connection.get(path)
+      handle_response(response)
+    end
+
+    def post(path, body)
+      response = @connection.post(path) do |req|
+        req.body = body.to_json
+      end
+      handle_response(response)
+    end
+
+    def post_multipart(path, payload)
+      response = @connection.post(path) do |req|
+        req.headers.delete("Content-Type")
+        req.body = payload
+      end
+      handle_response(response)
+    end
+
+    private
+
+    def handle_response(response)
+      body = JSON.parse(response.body) rescue response.body
+
+      unless response.success?
+        raise Error.new(
+          "Request failed with status #{response.status}: #{body}",
+          status_code: response.status,
+          response_body: body
+        )
+      end
+
+      body
+    end
+  end
+end

data/lib/hinow/embeddings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Embeddings
+    def initialize(client)
+      @client = client
+    end
+
+    def create(model:, input:)
+      @client.post("/v1/embeddings", { model: model, input: input })
+    end
+  end
+end

data/lib/hinow/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Error < StandardError
+    attr_reader :status_code, :response_body
+
+    def initialize(message = nil, status_code: nil, response_body: nil)
+      @status_code = status_code
+      @response_body = response_body
+      super(message)
+    end
+  end
+end

data/lib/hinow/images.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Images
+    def initialize(client)
+      @client = client
+    end
+
+    def generate(model:, prompt:, n: nil, size: nil, quality: nil, style: nil)
+      body = { model: model, prompt: prompt }
+
+      parameters = {}
+      parameters[:n] = n.to_s if n
+      parameters[:size] = size if size
+      parameters[:quality] = quality if quality
+      parameters[:style] = style if style
+
+      body[:parameters] = parameters unless parameters.empty?
+
+      @client.post("/v1/images", body)
+    end
+  end
+end

data/lib/hinow/models.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Models
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.get("/v1/models")
+    end
+  end
+end

data/lib/hinow/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hinow
+  VERSION = "1.0.0"
+end

data/lib/hinow/video.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hinow
+  class Video
+    def initialize(client)
+      @client = client
+    end
+
+    def generate(model:, prompt:, duration: nil, resolution: nil, fps: nil)
+      body = { model: model, prompt: prompt }
+
+      parameters = {}
+      parameters[:duration] = duration.to_s if duration
+      parameters[:resolution] = resolution if resolution
+      parameters[:fps] = fps.to_s if fps
+
+      body[:parameters] = parameters unless parameters.empty?
+
+      @client.post("/v1/videos", body)
+    end
+  end
+end

data/lib/hinow.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+
+require_relative "hinow/version"
+require_relative "hinow/error"
+require_relative "hinow/client"
+require_relative "hinow/chat"
+require_relative "hinow/images"
+require_relative "hinow/audio"
+require_relative "hinow/video"
+require_relative "hinow/embeddings"
+require_relative "hinow/models"
+
+module Hinow
+  class << self
+    attr_accessor :api_key, :base_url, :timeout
+
+    def configure
+      yield self
+    end
+
+    def client
+      @client ||= Client.new(
+        api_key: api_key,
+        base_url: base_url,
+        timeout: timeout
+      )
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: hinow-ai
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- HINOW AI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Ruby client library for HINOW AI - Access LLMs, image generation, TTS,
+  STT, video generation, and embeddings.
+email:
+- support@hinow.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/hinow.rb
+- lib/hinow/audio.rb
+- lib/hinow/chat.rb
+- lib/hinow/client.rb
+- lib/hinow/embeddings.rb
+- lib/hinow/error.rb
+- lib/hinow/images.rb
+- lib/hinow/models.rb
+- lib/hinow/version.rb
+- lib/hinow/video.rb
+homepage: https://hinow.ai
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://hinow.ai
+  source_code_uri: https://github.com/hinow-ai/sdk-ruby
+  changelog_uri: https://github.com/hinow-ai/sdk-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for the HINOW AI Inference API
+test_files: []