zuno 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6809336cae0fd3e0ff6510407f7a29ca852f833dc7f567e05f246b958982a968
-  data.tar.gz: 007fe0df2ef864d4dc8ce8afe903a733c85e0da41921fea7ecb53f5c1da56263
+  metadata.gz: e0b1a60f13b8d0f649d5a00df65846d3a35597f6298927c2e07b36f6f042528a
+  data.tar.gz: a6312c76748d3fe27bc50e70fac5c7922f240ac7b61eee6ed6ab1e7e90639e2a
 SHA512:
-  metadata.gz: 373a15dfb01d69283621579bc58a58561bceb30da4c309014632cb1e5404f659e7ba1f5d206f70f7650838a488b9483ecb02ecd36523d35f79e9d12fe43d9e89
-  data.tar.gz: ade9ff32f23eb1ccb60660c3372076e6c6f8b92d4ca64bebf0e617381d1b2ee4204de6bfc29eb54dd53765d0235bfc544e78107d09a086b8439bfed72f05f3f1
+  metadata.gz: d9d1ce4c9e83825b6a227f6442865d7983a43fc31ca7956d09c38214a428ce1ea8c83f8852f24e66302f6906824f288d6fb0a8fbbad4253fd0d1d920fe16e603
+  data.tar.gz: 54110db116e05eed86ac94eebd7416c2955a78fe691cafcff7ad39a733fd7e54245bfc659261aeb09dbeb20f26d5a836f433f1deefd6deda8242166947ac39d8

data/README.md

@@ -0,0 +1,38 @@
+# Zuno
+
+Standalone Ruby SDK for:
+
+- provider/model abstraction
+- tool calling with iterative loop execution
+- streaming via SSE
+
+## Install (local development)
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+## Basic usage
+
+```ruby
+require "zuno"
+
+result = Zuno.generate(
+  model: "openai/gpt-5-mini",
+  prompt: "Say hello"
+)
+
+puts result[:text]
+```
+
+## Callbacks
+
+`generate` supports:
+
+- `before_generation`
+- `after_generation`
+- `before_iteration`
+- `after_iteration`
+- `before_tool_execution`
+- `after_tool_execution`

data/lib/zuno/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zuno
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/zuno.rb

@@ -1,19 +1,687 @@
 # frozen_string_literal: true
 
+require "json"
+require "securerandom"
+require "typhoeus"
+
 require_relative "zuno/version"
-require_relative "zuno/configuration"
-require "zuno/chat"
-require "zuno/transcription"
-require "zuno/translation"
-require "faraday"
 
 module Zuno
-  class << self
-    attr_accessor :configuration
+  class Error < StandardError; end
+  class ProviderError < Error; end
+  class ToolError < Error; end
+  class MaxStepsExceeded < Error; end
+  class StreamingError < Error; end
+
+  ModelDescriptor = Struct.new(:id, :provider, keyword_init: true) do
+    def initialize(id:, provider:)
+      super(id: id.to_s, provider: provider.to_sym)
+    end
+  end
+
+  ToolDefinition = Struct.new(:name, :description, :input_schema, :execute_proc, keyword_init: true) do
+    def initialize(name:, description:, input_schema:, execute_proc:)
+      super(
+        name: name.to_s,
+        description: description.to_s,
+        input_schema: input_schema.is_a?(Hash) ? input_schema : {},
+        execute_proc: execute_proc
+      )
+    end
+
+    def as_provider_tool
+      {
+        type: "function",
+        function: {
+          name: name,
+          description: description,
+          parameters: input_schema
+        }
+      }
+    end
+
+    def execute(arguments)
+      raise ToolError, "Tool '#{name}' is missing an execute block" unless execute_proc.respond_to?(:call)
+
+      symbolized_args = arguments.each_with_object({}) { |(key, value), acc| acc[key.to_sym] = value }
+
+      begin
+        execute_proc.call(arguments)
+      rescue ArgumentError, TypeError
+        execute_proc.call(**symbolized_args)
+      end
+    end
+  end
+
+  ADAPTER_CONFIG_KEYS = %i[api_key app_url title timeout].freeze
+  DEFAULT_MAX_STEPS = 8
+
+  module_function
+
+  def model(id, provider: :openrouter)
+    ModelDescriptor.new(id: id, provider: provider)
+  end
+
+  def tool(name:, description:, input_schema:, &execute)
+    raise ToolError, "A block is required for tool '#{name}'" unless block_given?
+
+    ToolDefinition.new(
+      name: name,
+      description: description,
+      input_schema: input_schema,
+      execute_proc: execute
+    )
+  end
+
+  def generate(
+    model:,
+    messages: nil,
+    system: nil,
+    prompt: nil,
+    tools: {},
+    max_steps: DEFAULT_MAX_STEPS,
+    temperature: nil,
+    max_tokens: nil,
+    provider_options: {},
+    before_tool_execution: nil,
+    after_tool_execution: nil,
+    before_iteration: nil,
+    after_iteration: nil,
+    before_generation: nil,
+    after_generation: nil
+  )
+    model_descriptor = normalize_model(model)
+    adapter = provider_adapter(model_descriptor.provider, provider_options)
+    tool_map = normalize_tools(tools)
+    llm_messages = normalize_messages(messages: messages, system: system, prompt: prompt)
+    after_generation_called = false
+
+    call_callback!(
+      before_generation,
+      {
+        model: model_descriptor,
+        messages: llm_messages,
+        tool_names: tool_map.keys
+      }
+    )
+
+    iterations = []
+    iteration_count = 0
+
+    while iteration_count < max_steps
+      current_iteration = iteration_count + 1
+      call_callback!(
+        before_iteration,
+        {
+          iteration_index: current_iteration,
+          messages: llm_messages
+        }
+      )
+
+      payload = build_payload(
+        model_id: model_descriptor.id,
+        messages: llm_messages,
+        tools: tool_map,
+        temperature: temperature,
+        max_tokens: max_tokens,
+        provider_options: provider_options
+      )
+
+      response = adapter.chat(payload)
+      message = response.dig("choices", 0, "message") || {}
+      tool_calls = Array(message["tool_calls"])
+
+      iteration_record = {
+        index: current_iteration,
+        message: message,
+        tool_calls: tool_calls,
+        usage: response["usage"],
+        finish_reason: response.dig("choices", 0, "finish_reason"),
+        tool_results: []
+      }
+
+      if tool_calls.empty?
+        iterations << iteration_record
+        call_callback!(
+          after_iteration,
+          {
+            iteration_index: current_iteration,
+            iteration: iteration_record
+          }
+        )
+
+        result = {
+          text: extract_message_text(message),
+          message: message,
+          usage: response["usage"],
+          finish_reason: response.dig("choices", 0, "finish_reason"),
+          iterations: iterations,
+          raw_response: response
+        }
+
+        after_generation_called = true
+        call_callback!(after_generation, { ok: true, result: result })
+        return result
+      end
+
+      llm_messages << build_assistant_tool_call_message(message: message, tool_calls: tool_calls)
+
+      tool_calls.each do |tool_call|
+        tool_call_id = normalize_tool_call_id(tool_call["id"])
+        arguments = parse_arguments(tool_call.dig("function", "arguments"))
+        tool_name = tool_call.dig("function", "name").to_s
+
+        call_callback!(
+          before_tool_execution,
+          {
+            iteration_index: current_iteration,
+            tool_call_id: tool_call_id,
+            tool_name: tool_name,
+            input: arguments,
+            raw_tool_call: tool_call
+          }
+        )
+
+        tool_result = execute_tool_call(
+          tool_call: tool_call,
+          tools: tool_map,
+          tool_call_id: tool_call_id,
+          arguments: arguments
+        )
+
+        iteration_record[:tool_results] << tool_result
+        call_callback!(after_tool_execution, tool_result.merge(iteration_index: current_iteration))
+
+        llm_messages << {
+          "role" => "tool",
+          "tool_call_id" => tool_result[:tool_call_id],
+          "content" => serialize_tool_content(tool_result[:output])
+        }
+      end
+
+      iterations << iteration_record
+      call_callback!(
+        after_iteration,
+        {
+          iteration_index: current_iteration,
+          iteration: iteration_record
+        }
+      )
+
+      iteration_count += 1
+    end
+
+    raise MaxStepsExceeded, "Reached max_steps=#{max_steps} without a final assistant response"
+  rescue ProviderError, MaxStepsExceeded => e
+    unless after_generation_called
+      after_generation_called = true
+      call_callback!(after_generation, { ok: false, error: e })
+    end
+    raise
+  rescue StandardError => e
+    unless after_generation_called
+      after_generation_called = true
+      call_callback!(after_generation, { ok: false, error: e })
+    end
+    raise Error, e.message
+  end
+
+  def stream(
+    model:,
+    messages: nil,
+    system: nil,
+    prompt: nil,
+    temperature: nil,
+    max_tokens: nil,
+    provider_options: {},
+    &block
+  )
+    raise ArgumentError, "stream requires a block callback" unless block_given?
+
+    model_descriptor = normalize_model(model)
+    adapter = provider_adapter(model_descriptor.provider, provider_options)
+    llm_messages = normalize_messages(messages: messages, system: system, prompt: prompt)
+
+    payload = build_payload(
+      model_id: model_descriptor.id,
+      messages: llm_messages,
+      tools: {},
+      temperature: temperature,
+      max_tokens: max_tokens,
+      provider_options: provider_options
+    ).merge("stream" => true)
+
+    block.call(type: :start, model: model_descriptor.id, provider: model_descriptor.provider)
+
+    emitted_finish = false
+
+    adapter.stream(payload) do |raw_data|
+      next if raw_data == "[DONE]"
+
+      parsed = parse_json(raw_data)
+      raise StreamingError, "Malformed SSE payload: #{raw_data}" if parsed.nil?
+
+      usage = parsed["usage"]
+      block.call(type: :usage, usage: usage, raw: parsed) if usage.is_a?(Hash)
+
+      choice = Array(parsed["choices"]).first || {}
+      delta = choice["delta"] || {}
+
+      text_delta = extract_text_delta(delta)
+      block.call(type: :text_delta, text: text_delta, raw: parsed) if text_delta && !text_delta.empty?
+
+      Array(delta["tool_calls"]).each do |tool_call_delta|
+        tool_delta = {
+          index: tool_call_delta["index"],
+          id: tool_call_delta["id"],
+          type: tool_call_delta["type"],
+          name: tool_call_delta.dig("function", "name"),
+          arguments_delta: tool_call_delta.dig("function", "arguments")
+        }
+        block.call(type: :tool_call_delta, tool_call: tool_delta, raw: parsed)
+      end
+
+      finish_reason = choice["finish_reason"]
+      next if finish_reason.nil? || finish_reason.to_s.empty?
+
+      emitted_finish = true
+      block.call(type: :finish, finish_reason: finish_reason, raw: parsed)
+    end
+
+    block.call(type: :finish, finish_reason: "stop") unless emitted_finish
+    true
+  rescue ProviderError => e
+    wrapped_error = StreamingError.new(e.message)
+    block.call(type: :error, error: wrapped_error.message) if block_given?
+    raise wrapped_error
+  rescue StreamingError => e
+    block.call(type: :error, error: e.message) if block_given?
+    raise
+  rescue StandardError => e
+    wrapped_error = StreamingError.new(e.message)
+    block.call(type: :error, error: wrapped_error.message) if block_given?
+    raise wrapped_error
+  end
+
+  def normalize_model(input)
+    return input if input.is_a?(ModelDescriptor)
+    return model(input, provider: :openrouter) if input.is_a?(String)
+
+    if input.is_a?(Hash)
+      return model(
+        input[:id] || input["id"],
+        provider: input[:provider] || input["provider"] || :openrouter
+      )
+    end
+
+    raise Error, "Unsupported model value: #{input.inspect}"
+  end
+  private_class_method :normalize_model
+
+  def normalize_tools(tools)
+    return {} if tools.nil?
+
+    if tools.is_a?(Array)
+      return tools.each_with_object({}) do |entry, acc|
+        next unless entry.is_a?(ToolDefinition)
+
+        acc[entry.name] = entry
+      end
+    end
+
+    raise ToolError, "tools must be a Hash or Array" unless tools.is_a?(Hash)
+
+    tools.each_with_object({}) do |(name, value), acc|
+      tool_name = name.to_s
+      acc[tool_name] = normalize_tool_entry(tool_name, value)
+    end
+  end
+  private_class_method :normalize_tools
+
+  def normalize_tool_entry(name, value)
+    return value if value.is_a?(ToolDefinition)
+
+    if value.is_a?(Hash)
+      execute_proc = value[:execute] || value["execute"]
+      return ToolDefinition.new(
+        name: name,
+        description: value[:description] || value["description"] || "",
+        input_schema: value[:input_schema] || value["input_schema"] || value[:parameters] || value["parameters"] || {},
+        execute_proc: execute_proc
+      )
+    end
+
+    raise ToolError, "Tool '#{name}' has invalid definition"
+  end
+  private_class_method :normalize_tool_entry
+
+  def normalize_messages(messages:, system:, prompt:)
+    if messages.nil? || messages.empty?
+      normalized = []
+      normalized << { "role" => "system", "content" => system.to_s } if system
+      normalized << { "role" => "user", "content" => prompt.to_s } if prompt
+      return normalized
+    end
+
+    normalized = deep_stringify(messages)
+    normalized.unshift({ "role" => "system", "content" => system.to_s }) if system
+    normalized << { "role" => "user", "content" => prompt.to_s } if prompt
+    normalized
+  end
+  private_class_method :normalize_messages
+
+  def build_payload(model_id:, messages:, tools:, temperature:, max_tokens:, provider_options:)
+    payload = {
+      "model" => model_id,
+      "messages" => messages
+    }
+
+    payload["temperature"] = temperature unless temperature.nil?
+    payload["max_tokens"] = max_tokens unless max_tokens.nil?
+    payload["tools"] = tools.values.map(&:as_provider_tool) unless tools.empty?
+
+    request_options = reject_keys(provider_options, ADAPTER_CONFIG_KEYS)
+    payload.merge!(deep_stringify(request_options)) if request_options.is_a?(Hash)
+    payload
   end
+  private_class_method :build_payload
+
+  def provider_adapter(provider, provider_options)
+    config = pick_keys(provider_options, ADAPTER_CONFIG_KEYS)
+
+    case provider.to_sym
+    when :openrouter
+      Providers::OpenRouter.new(**config)
+    else
+      raise ProviderError, "Unsupported provider: #{provider}"
+    end
+  end
+  private_class_method :provider_adapter
+
+  def build_assistant_tool_call_message(message:, tool_calls:)
+    {
+      "role" => "assistant",
+      "content" => extract_message_text(message),
+      "tool_calls" => tool_calls
+    }
+  end
+  private_class_method :build_assistant_tool_call_message
+
+  def execute_tool_call(tool_call:, tools:, tool_call_id: nil, arguments: nil)
+    tool_name = tool_call.dig("function", "name").to_s
+    tool_call_id = normalize_tool_call_id(tool_call_id || tool_call["id"])
+    arguments = parse_arguments(tool_call.dig("function", "arguments")) if arguments.nil?
+    tool = tools[tool_name]
+
+    unless tool
+      return {
+        tool_call_id: tool_call_id,
+        tool_name: tool_name,
+        input: arguments,
+        ok: false,
+        output: { "ok" => false, "error" => "Unknown tool: #{tool_name}" }
+      }
+    end
+
+    output = normalize_output_payload(tool.execute(arguments))
+    {
+      tool_call_id: tool_call_id,
+      tool_name: tool_name,
+      input: arguments,
+      ok: true,
+      output: output
+    }
+  rescue StandardError => e
+    {
+      tool_call_id: tool_call_id,
+      tool_name: tool_name,
+      input: arguments,
+      ok: false,
+      output: { "ok" => false, "error" => "Tool execution failed: #{e.message}" }
+    }
+  end
+  private_class_method :execute_tool_call
+
+  def normalize_tool_call_id(value)
+    normalized = value.to_s.strip
+    return normalized unless normalized.empty?
+
+    "call_#{SecureRandom.uuid}"
+  end
+  private_class_method :normalize_tool_call_id
+
+  def call_callback!(callback, payload)
+    return if callback.nil?
+    raise Error, "Callback must respond to #call" unless callback.respond_to?(:call)
+
+    callback.call(payload)
+  end
+  private_class_method :call_callback!
+
+  def normalize_output_payload(payload)
+    case payload
+    when Hash, Array
+      deep_stringify(payload)
+    else
+      payload
+    end
+  end
+  private_class_method :normalize_output_payload
+
+  def extract_message_text(message)
+    content = message["content"]
+    return content if content.is_a?(String)
+
+    if content.is_a?(Array)
+      return content.filter_map { |part| part["text"] if part.is_a?(Hash) && part["text"] }.join
+    end
+
+    return content["text"].to_s if content.is_a?(Hash) && content["text"]
+
+    content.to_s
+  end
+  private_class_method :extract_message_text
+
+  def extract_text_delta(delta)
+    content = delta["content"]
+    return content if content.is_a?(String)
+
+    if content.is_a?(Array)
+      return content.filter_map { |part| part["text"] if part.is_a?(Hash) && part["text"] }.join
+    end
+
+    nil
+  end
+  private_class_method :extract_text_delta
+
+  def parse_arguments(arguments)
+    return arguments if arguments.is_a?(Hash)
+    return {} if arguments.nil? || arguments.to_s.strip.empty?
+
+    parse_json(arguments) || {}
+  end
+  private_class_method :parse_arguments
+
+  def parse_json(value)
+    JSON.parse(value)
+  rescue JSON::ParserError, TypeError
+    nil
+  end
+  private_class_method :parse_json
+
+  def serialize_tool_content(output)
+    return output if output.is_a?(String)
+
+    JSON.generate(output)
+  rescue StandardError
+    output.to_s
+  end
+  private_class_method :serialize_tool_content
+
+  def pick_keys(hash, keys)
+    return {} unless hash.is_a?(Hash)
+
+    hash.each_with_object({}) do |(key, value), acc|
+      symbol_key = key.to_sym
+      acc[symbol_key] = value if keys.include?(symbol_key)
+    end
+  end
+  private_class_method :pick_keys
+
+  def reject_keys(hash, keys)
+    return {} unless hash.is_a?(Hash)
+
+    hash.each_with_object({}) do |(key, value), acc|
+      symbol_key = key.to_sym
+      acc[key] = value unless keys.include?(symbol_key)
+    end
+  end
+  private_class_method :reject_keys
+
+  def deep_stringify(value)
+    case value
+    when Hash
+      value.each_with_object({}) do |(key, item), acc|
+        acc[key.to_s] = deep_stringify(item)
+      end
+    when Array
+      value.map { |item| deep_stringify(item) }
+    else
+      value
+    end
+  end
+  private_class_method :deep_stringify
+
+  module Providers
+    class OpenRouter
+      CHAT_COMPLETIONS_URL = "https://openrouter.ai/api/v1/chat/completions".freeze
+      DEFAULT_TIMEOUT = 120_000
+
+      def initialize(api_key: nil, app_url: nil, title: nil, timeout: DEFAULT_TIMEOUT)
+        @api_key = api_key || resolve_api_key
+        raise ProviderError, "OpenRouter API key not configured" if @api_key.nil? || @api_key.to_s.empty?
+
+        @app_url = app_url || ENV["OPENROUTER_HTTP_REFERER"] || "http://localhost"
+        @title = title || ENV["OPENROUTER_APP_TITLE"] || "zuno-ruby"
+        @timeout = timeout
+      end
+
+      def chat(payload)
+        response = Typhoeus.post(
+          CHAT_COMPLETIONS_URL,
+          headers: headers,
+          body: JSON.generate(payload),
+          timeout: @timeout
+        )
+
+        validate_response!(response)
+        parsed = JSON.parse(response.body)
+        raise ProviderError, "OpenRouter returned invalid JSON" unless parsed.is_a?(Hash)
+
+        parsed
+      rescue JSON::ParserError => e
+        raise ProviderError, "Failed to parse OpenRouter response: #{e.message}"
+      end
+
+      def stream(payload)
+        raise ArgumentError, "stream requires a block callback" unless block_given?
+
+        request = Typhoeus::Request.new(
+          CHAT_COMPLETIONS_URL,
+          method: :post,
+          headers: headers,
+          body: JSON.generate(payload),
+          timeout: @timeout
+        )
+
+        parser = SseParser.new { |data| yield(data) }
+        request.on_body do |chunk|
+          parser.push(chunk)
+          nil
+        end
+
+        request.run
+        validate_response!(request.response)
+        parser.flush
+      end
+
+      private
+
+      def headers
+        {
+          "Authorization" => "Bearer #{@api_key}",
+          "Content-Type" => "application/json",
+          "HTTP-Referer" => @app_url,
+          "X-Title" => @title
+        }
+      end
+
+      def validate_response!(response)
+        raise ProviderError, "No response returned from OpenRouter" if response.nil?
+        raise ProviderError, "OpenRouter request timed out" if response.timed_out?
+        raise ProviderError, "OpenRouter request failed: #{response.return_code}" unless response.success?
+
+        status = response.code.to_i
+        return if status >= 200 && status < 300
+
+        body = response.body.to_s
+        message = body.length > 300 ? "#{body[0, 300]}..." : body
+        raise ProviderError, "OpenRouter responded with HTTP #{status}: #{message}"
+      end
+
+      def resolve_api_key
+        ENV["OPENROUTER_API_KEY"]
+      end
+    end
+  end
+
+  class SseParser
+    def initialize(&on_data)
+      @on_data = on_data
+      @buffer = +""
+    end
+
+    def push(chunk)
+      return if chunk.nil? || chunk.empty?
+
+      @buffer << chunk
+      parse_buffer
+    end
+
+    def flush
+      parse_buffer(final: true)
+    end
+
+    private
+
+    def parse_buffer(final: false)
+      delimiter = "\n\n"
+
+      loop do
+        index = @buffer.index(delimiter)
+        break if index.nil?
+
+        raw_event = @buffer.slice!(0, index + delimiter.length)
+        emit_event(raw_event)
+      end
+
+      emit_event(@buffer.dup) if final && !@buffer.empty?
+      @buffer.clear if final
+    end
+
+    def emit_event(raw_event)
+      lines = raw_event.split("\n")
+      payload_lines = lines.filter_map do |line|
+        stripped = line.strip
+        next if stripped.empty?
+        next unless stripped.start_with?("data:")
+
+        stripped.sub(/^data:\s?/, "")
+      end
+
+      return if payload_lines.empty?
 
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield(configuration)
+      @on_data.call(payload_lines.join("\n"))
+    end
   end
 end

metadata

@@ -1,74 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: zuno
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
-- John Paul
+- Hyperaide
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2024-09-06 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: typhoeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '13.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: event_stream_parser
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '3.13'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: AI toolkit for Ruby
+        version: '3.13'
+description: Standalone Ruby SDK for AI generation with tool loops and SSE streaming.
 email:
-- johnarpaul@gmail.com
+- team@hyperaide.dev
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/providers/openai.rb
+- README.md
 - lib/zuno.rb
-- lib/zuno/chat.rb
-- lib/zuno/configuration.rb
 - lib/zuno/version.rb
-homepage: https://github.com/dqnamo
+homepage: https://github.com/hyperaide/hyperaide
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/dqnamo
+  homepage_uri: https://github.com/hyperaide/hyperaide
+  source_code_uri: https://github.com/hyperaide/hyperaide
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -77,15 +76,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: AI toolkit for Ruby
+summary: Ruby Agent SDK with provider/model abstraction, tools, and streaming
 test_files: []

data/lib/providers/openai.rb

@@ -1,58 +0,0 @@
-require 'ostruct'
-require 'faraday'
-require 'byebug'
-require 'event_stream_parser'
-
-module Providers
-  class OpenAI
-    def initialize
-      @connection = Faraday.new(url: "https://api.openai.com") do |faraday|
-        faraday.request :json
-        faraday.response :json
-        faraday.adapter Faraday.default_adapter
-      end
-
-      @api_key = Zuno.configuration.openai_api_key
-    end
-
-    def chat_completion(messages, model, options = {}, raw_response)
-      response = @connection.post("/v1/chat/completions") do |req|
-        req.headers["Content-Type"] = "application/json"
-        req.headers["Authorization"] = "Bearer #{@api_key}"
-        req.body = {
-          model: model,
-          messages: messages,
-        }.merge(options).to_json
-
-        if options[:stream]
-          parser = EventStreamParser::Parser.new
-          req.options.on_data = Proc.new do |chunk, size|
-            if raw_response
-              yield chunk
-            else
-              parser.feed(chunk) do |type, data, id, reconnection_time|
-                return if data == "[DONE]"
-                content = JSON.parse(data)["choices"][0]["delta"]["content"]
-                yield OpenStruct.new(content: content) if content
-              end
-            end
-          end
-        end
-      end
-
-      unless options[:stream]
-        if raw_response
-          return response.body
-        else
-          if response.body["error"]
-            raise response.body["error"]["message"]
-          elsif response.body["choices"][0]["message"]["content"]
-            OpenStruct.new(content: response.body["choices"][0]["message"]["content"])
-          elsif response.body["choices"][0]["message"]["tool_calls"]
-            OpenStruct.new(tool_calls: response.body["choices"][0]["message"]["tool_calls"])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/zuno/chat.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "providers/openai"
-
-module Zuno
-  OPENAI_MODELS = %w[gpt-3.5-turbo gpt-4-turbo gpt-4-turbo-preview gpt-4o gpt-4o-mini].freeze
-
-  class << self
-    def chat(messages:, model: nil, **options)
-      model ||= Zuno.configuration.chat_completion_model
-      provider = provider_for_model(model)
-      raw_response = options.delete(:raw_response) || false
-
-      if options[:stream]
-        provider.chat_completion(messages, model, options, raw_response) do |chunk|
-          yield chunk if block_given?
-        end
-      else
-        provider.chat_completion(messages, model, options, raw_response)
-      end
-    end
-
-    private
-
-    def provider_for_model(model)
-      case model
-      when *OPENAI_MODELS then Providers::OpenAI.new
-      else
-        raise ArgumentError, "Unsupported model: #{model}"
-      end
-    end
-
-    def model_providers_mapping
-      @model_providers_mapping ||= {
-        **OPENAI_MODELS.to_h { |model| [model, Providers::OpenAI.new] },
-      }
-    end
-  end
-end

data/lib/zuno/configuration.rb

@@ -1,11 +0,0 @@
-module Zuno
-  class Configuration
-    attr_accessor :chat_completion_model, :openai_api_key, :anthropic_api_key, :groq_cloud_api_key
-
-    def initialize
-      @chat_completion_model = nil
-      @openai_api_key = nil
-      @anthropic_api_key = nil
-    end
-  end
-end