elelem-anthropic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56afa7f5f223aa55908e14a3f1338e5855e60cc14b545afea442359c91f52093
+  data.tar.gz: c0ff12d63238c13cb2087b402a95ca493998b4eae059e0eab84578e9f76e7a5d
+SHA512:
+  metadata.gz: 493df59bd32c8efe6e84231b184abda1e8d58d8ad27e2f0c3433e0bf2eb969d7f8b20c7550c1c26988f11a561de44944394556c373fb9d307f381179f26375c8
+  data.tar.gz: 5c440bb7aead702d60d013d6fc105b217d63502b89c99d74b35093d66f4b461f47fa9b35a9c12d6df25b1bc471e42bebc2c4a990a86ded078ef1711b4fb82029

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 mo khan
+
+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/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/exe/elelem-anthropic

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "elelem/cli"
+
+Signal.trap("INT") { exit 1 }
+
+Elelem::CLI.new(ARGV, provider: "anthropic").run

data/lib/elelem/anthropic/client.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Anthropic
+    class Client
+      def initialize(endpoint:, headers:, model:, version: nil, read_timeout: 3600, open_timeout: 10)
+        @uri = URI.parse(endpoint)
+        @headers_source = headers
+        @model = model
+        @version = version
+        @read_timeout = read_timeout
+        @open_timeout = open_timeout
+      end
+
+      def fetch(messages, tools = [], &block)
+        system_prompt, normalized_messages = extract_system(messages)
+        tool_calls = []
+
+        stream(normalized_messages, system_prompt, tools) do |event|
+          handle_event(event, tool_calls, &block)
+        end
+
+        finalize_tool_calls(tool_calls, &block)
+      end
+
+      private
+
+      def headers
+        @headers_source.respond_to?(:call) ? @headers_source.call : @headers_source
+      end
+
+      def handle_event(event, tool_calls, &block)
+        case event["type"]
+        when "content_block_start"
+          handle_content_block_start(event, tool_calls)
+        when "content_block_delta"
+          handle_content_block_delta(event, tool_calls, &block)
+        end
+      end
+
+      def handle_content_block_start(event, tool_calls)
+        content_block = event["content_block"]
+        return unless content_block["type"] == "tool_use"
+
+        tool_calls << {
+          id: content_block["id"],
+          name: content_block["name"],
+          args: String.new
+        }
+      end
+
+      def handle_content_block_delta(event, tool_calls, &block)
+        delta = event["delta"]
+
+        case delta["type"]
+        when "text_delta"
+          block.call(type: "saying", text: delta["text"])
+        when "thinking_delta"
+          block.call(type: "thinking", text: delta["thinking"])
+        when "input_json_delta"
+          tool_calls.last[:args] << delta["partial_json"].to_s if tool_calls.any?
+        end
+      end
+
+      def finalize_tool_calls(tool_calls, &block)
+        tool_calls.each do |tool_call|
+          args = tool_call.delete(:args)
+          tool_call[:arguments] = args.empty? ? {} : JSON.parse(args)
+          block.call(type: "doing", id: tool_call[:id], name: tool_call[:name], arguments: tool_call[:arguments])
+        end
+        tool_calls
+      end
+
+      def stream(messages, system_prompt, tools)
+        body = build_request_body(messages, system_prompt, tools)
+
+        request = Net::HTTP::Post.new(@uri)
+        request["content-type"] = "application/json"
+        headers.each { |k, v| request[k] = v }
+        request.body = JSON.generate(body)
+
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = @uri.scheme == "https"
+        http.read_timeout = @read_timeout
+        http.open_timeout = @open_timeout
+
+        http.start do |conn|
+          conn.request(request) do |response|
+            raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+            read_sse_stream(response) { |event| yield event }
+          end
+        end
+      end
+
+      def build_request_body(messages, system_prompt, tools)
+        body = { max_tokens: 64000, messages:, stream: true }
+        body[:model] = @model unless @version
+        body[:anthropic_version] = @version if @version
+        body[:system] = system_prompt if system_prompt
+        body[:tools] = unwrap_tools(tools) unless tools.empty?
+        body
+      end
+
+      def read_sse_stream(response)
+        buffer = String.new
+
+        response.read_body do |chunk|
+          buffer << chunk
+
+          while (index = buffer.index("\n\n"))
+            raw_event = buffer.slice!(0, index + 2)
+            event = parse_sse(raw_event)
+            yield event if event
+          end
+        end
+      end
+
+      def parse_sse(raw)
+        line = raw.lines.find { |l| l.start_with?("data: ") }
+        return nil unless line
+
+        data = line.delete_prefix("data: ").strip
+        return nil if data == "[DONE]"
+
+        JSON.parse(data)
+      end
+
+      def extract_system(messages)
+        system_messages, other_messages = messages.partition { |message| message[:role] == "system" }
+        system_content = system_messages.first&.dig(:content)
+        [system_content, normalize(other_messages)]
+      end
+
+      def normalize(messages)
+        messages.map { |message| normalize_message(message) }
+      end
+
+      def normalize_message(message)
+        case message[:role]
+        when "tool"
+          tool_result_message(message)
+        when "assistant"
+          message[:tool_calls]&.any? ? assistant_with_tools_message(message) : message
+        else
+          message
+        end
+      end
+
+      def tool_result_message(message)
+        {
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: message[:tool_call_id],
+            content: message[:content]
+          }]
+        }
+      end
+
+      def assistant_with_tools_message(message)
+        text_content = build_text_content(message[:content])
+        tool_content = build_tool_content(message[:tool_calls])
+
+        { role: "assistant", content: text_content + tool_content }
+      end
+
+      def build_text_content(content)
+        return [] if content.to_s.empty?
+
+        [{ type: "text", text: content }]
+      end
+
+      def build_tool_content(tool_calls)
+        tool_calls.map do |tool_call|
+          {
+            type: "tool_use",
+            id: tool_call[:id],
+            name: tool_call[:name],
+            input: tool_call[:arguments]
+          }
+        end
+      end
+
+      def unwrap_tools(tools)
+        tools.map do |tool|
+          {
+            name: tool.dig(:function, :name),
+            description: tool.dig(:function, :description),
+            input_schema: tool.dig(:function, :parameters)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elelem/anthropic/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Elelem
+  module Anthropic
+    VERSION = "0.1.0"
+  end
+end

data/lib/elelem/anthropic.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "elelem"
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "anthropic/version"
+require_relative "anthropic/client"
+
+Elelem::Providers.register(:anthropic) do
+  api_key = ENV.fetch("ANTHROPIC_API_KEY")
+  Elelem::Anthropic::Client.new(
+    endpoint: "https://api.anthropic.com/v1/messages",
+    headers: { "x-api-key" => api_key, "anthropic-version" => "2023-06-01" },
+    model: ENV.fetch("ANTHROPIC_MODEL", "claude-opus-4-5-20250514")
+  )
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: elelem-anthropic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mo khan
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elelem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: An Anthropic provider plugin for elelem.
+email:
+- mo@mokhan.ca
+executables:
+- elelem-anthropic
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- Rakefile
+- exe/elelem-anthropic
+- lib/elelem/anthropic.rb
+- lib/elelem/anthropic/client.rb
+- lib/elelem/anthropic/version.rb
+homepage: https://src.mokhan.ca/elelem/anthropic
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://src.mokhan.ca/elelem/anthropic
+  source_code_uri: https://src.mokhan.ca/elelem/anthropic
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: An Anthropic provider plugin for elelem.
+test_files: []