apipurse-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a0fdd0668219be947c676430083275ccfd4e9007ed855e2f03e6cb9677fefcd2
+  data.tar.gz: 9993092dd2bb386e08dfba2a98fd8014fe194b28609081dcd1ecc891daa8bddb
+SHA512:
+  metadata.gz: 2a2ab7d9d4152dea0402cd355f3a67cf59985d8f7053dca26be0eb8451e11b502a793f554ab0a868061cb757f1a0d8794ebe16b89ca865745ee21f9027346a75
+  data.tar.gz: c7812964ac4cbb85719e19afc8b40faa68576882d823b80688eea41ec7c9b07ced8587b2443bdca2768ba426124ba9f8fa243bc3c406be4137a78139c4c64a2f

data/lib/apipurse/wrap_anthropic.rb

@@ -0,0 +1,97 @@
+# Apipurse::WrapAnthropic.call(client, apipurse) — automatic, zero-call-site
+# cost tracking for the official `anthropic` Ruby gem. Same design as
+# Apipurse::WrapOpenAI — see wrap_openai.rb for the full "this is not a
+# proxy" explanation, which applies identically here.
+#
+# Usage:
+#
+#   client = Anthropic::Client.new
+#   apipurse = Apipurse::Client.new(
+#     ingest_token: ENV["APIPURSE_INGEST_TOKEN"],
+#     provider_id: ENV["APIPURSE_PROVIDER_ID"],
+#     base_url: "https://your-apipurse-domain.com"
+#   )
+#   Apipurse::WrapAnthropic.call(client, apipurse)
+#
+#   message = client.messages.create(
+#     model: "claude-sonnet-4-20250514",
+#     max_tokens: 1024,
+#     messages: [{ role: "user", content: "Hello" }]
+#   )
+#
+# Streaming: unlike OpenAI, Anthropic's stream always carries token counts in
+# its `message_start` and `message_delta` events — no extra request flag
+# needed.
+module Apipurse
+  module WrapAnthropic
+    def self.call(client, apipurse, on_track: nil)
+      messages = client.messages
+      original = messages.method(:create)
+
+      messages.define_singleton_method(:create) do |*args, **kwargs, &block|
+        result = original.call(*args, **kwargs, &block)
+
+        if result.respond_to?(:usage)
+          Apipurse::WrapAnthropic.report(result, apipurse, on_track)
+          result
+        elsif result.respond_to?(:each)
+          Apipurse::WrapAnthropic.wrap_stream(result, apipurse, on_track)
+        else
+          result
+        end
+      end
+
+      client
+    end
+
+    def self.report(message, apipurse, on_track)
+      usage = message.respond_to?(:usage) ? message.usage : nil
+      return unless usage
+
+      result = apipurse.track_completion(
+        model: message.model,
+        input_tokens: (usage.respond_to?(:input_tokens) ? usage.input_tokens : nil) || 0,
+        output_tokens: (usage.respond_to?(:output_tokens) ? usage.output_tokens : nil) || 0
+      )
+      on_track&.call(result)
+    rescue StandardError
+      nil
+    end
+
+    def self.wrap_stream(stream, apipurse, on_track)
+      Enumerator.new do |yielder|
+        model = nil
+        input_tokens = 0
+        output_tokens = 0
+
+        stream.each do |event|
+          event_type = event.respond_to?(:type) ? event.type : nil
+
+          if event_type == "message_start" && event.respond_to?(:message) && event.message
+            model = event.message.model
+            usage = event.message.respond_to?(:usage) ? event.message.usage : nil
+            if usage
+              input_tokens = usage.respond_to?(:input_tokens) ? (usage.input_tokens || input_tokens) : input_tokens
+              output_tokens = usage.respond_to?(:output_tokens) ? (usage.output_tokens || output_tokens) : output_tokens
+            end
+          end
+
+          if event_type == "message_delta" && event.respond_to?(:usage) && event.usage
+            output_tokens = event.usage.respond_to?(:output_tokens) ? (event.usage.output_tokens || output_tokens) : output_tokens
+          end
+
+          yielder << event
+        end
+
+        next unless model
+
+        begin
+          result = apipurse.track_completion(model: model, input_tokens: input_tokens, output_tokens: output_tokens)
+          on_track&.call(result)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/apipurse/wrap_openai.rb

@@ -0,0 +1,90 @@
+# Apipurse::WrapOpenAI.call(client, apipurse) — automatic, zero-call-site
+# cost tracking for the official `openai` Ruby gem.
+#
+# This is NOT a network proxy. The wrapper runs entirely inside your own
+# process: it calls the real OpenAI client exactly as before, inspects the
+# response your own code already received, and reports only the model ID +
+# token counts to APIPurse's /api/track/completion endpoint.
+#
+# Usage:
+#
+#   client = OpenAI::Client.new
+#   apipurse = Apipurse::Client.new(
+#     ingest_token: ENV["APIPURSE_INGEST_TOKEN"],
+#     provider_id: ENV["APIPURSE_PROVIDER_ID"],
+#     base_url: "https://your-apipurse-domain.com"
+#   )
+#   Apipurse::WrapOpenAI.call(client, apipurse)
+#
+#   # Tracked automatically, no extra code here:
+#   completion = client.chat.completions.create(
+#     model: "gpt-4o",
+#     messages: [{ role: "user", content: "Hello" }]
+#   )
+#
+# Reporting failures (e.g. a gem version whose response shape doesn't match
+# what this wrapper expects) are swallowed here rather than raised, so a
+# tracking hiccup can never break your real completion call.
+module Apipurse
+  module WrapOpenAI
+    def self.call(client, apipurse, on_track: nil)
+      completions = client.chat.completions
+      original = completions.method(:create)
+
+      completions.define_singleton_method(:create) do |*args, **kwargs, &block|
+        result = original.call(*args, **kwargs, &block)
+
+        if result.respond_to?(:usage)
+          Apipurse::WrapOpenAI.report(result, apipurse, on_track)
+          result
+        elsif result.respond_to?(:each)
+          Apipurse::WrapOpenAI.wrap_stream(result, apipurse, on_track)
+        else
+          result
+        end
+      end
+
+      client
+    end
+
+    def self.report(completion, apipurse, on_track)
+      usage = completion.respond_to?(:usage) ? completion.usage : nil
+      return unless usage
+
+      result = apipurse.track_completion(
+        model: completion.model,
+        input_tokens: (usage.respond_to?(:prompt_tokens) ? usage.prompt_tokens : nil) || 0,
+        output_tokens: (usage.respond_to?(:completion_tokens) ? usage.completion_tokens : nil) || 0
+      )
+      on_track&.call(result)
+    rescue StandardError
+      nil
+    end
+
+    def self.wrap_stream(stream, apipurse, on_track)
+      Enumerator.new do |yielder|
+        last_model = nil
+        last_usage = nil
+
+        stream.each do |chunk|
+          last_model = chunk.model if chunk.respond_to?(:model) && chunk.model
+          last_usage = chunk.usage if chunk.respond_to?(:usage) && chunk.usage
+          yielder << chunk
+        end
+
+        next unless last_model && last_usage
+
+        begin
+          result = apipurse.track_completion(
+            model: last_model,
+            input_tokens: (last_usage.respond_to?(:prompt_tokens) ? last_usage.prompt_tokens : nil) || 0,
+            output_tokens: (last_usage.respond_to?(:completion_tokens) ? last_usage.completion_tokens : nil) || 0
+          )
+          on_track&.call(result)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/apipurse.rb

@@ -0,0 +1,84 @@
+# APIPurse SDK (Ruby reference implementation) — real-time cost tracking.
+#
+# Unlike the OpenAI/Anthropic/Stripe connectors (which poll the provider's
+# own cost report every few hours), this reports usage the instant your own
+# code finishes a call, so it shows up on the dashboard immediately and can
+# trigger a budget alert right away instead of hours later.
+#
+# Not a network proxy — nothing routes through APIPurse's servers. Only the
+# model ID and token counts are ever sent to /api/track/completion.
+#
+# Dependency-free: uses only Net::HTTP and JSON from the standard library.
+#
+# Two integration styles, both call the same endpoint under the hood:
+#
+# 1. Automatic (recommended) — wrap your existing OpenAI/Anthropic client
+#    once at setup with Apipurse::WrapOpenAI/Apipurse::WrapAnthropic (see
+#    wrap_openai.rb / wrap_anthropic.rb) and every call is tracked with zero
+#    changes at each call site.
+# 2. Manual — call track_completion() yourself right after a completion.
+
+require "json"
+require "net/http"
+require "uri"
+
+module Apipurse
+  TrackCompletionResult = Struct.new(:ok, :cost_usd, :alert_triggered, :error, keyword_init: true)
+
+  class Client
+    def initialize(ingest_token:, provider_id:, base_url: "http://localhost:3000", silent: true)
+      @ingest_token = ingest_token
+      @provider_id = provider_id
+      @base_url = base_url.chomp("/")
+      @silent = silent
+    end
+
+    # Reports one completion's token usage. Computes and stores the exact
+    # dollar cost immediately (via APIPurse's model price table) and checks
+    # your budget right away — no waiting for a scheduled sync.
+    def track_completion(model:, input_tokens:, output_tokens:, request_count: 1)
+      uri = URI("#{@base_url}/api/track/completion")
+      body = {
+        provider_id: @provider_id,
+        model: model,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
+        request_count: request_count,
+      }.to_json
+
+      response = Net::HTTP.start(
+        uri.host, uri.port,
+        use_ssl: uri.scheme == "https",
+        open_timeout: 10, read_timeout: 10
+      ) do |http|
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@ingest_token}"
+        request.body = body
+        http.request(request)
+      end
+
+      payload = JSON.parse(response.body)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        message = payload["error"] || "HTTP #{response.code}"
+        return TrackCompletionResult.new(ok: false, error: message) if @silent
+
+        raise "APIPurse tracking failed: #{message}"
+      end
+
+      TrackCompletionResult.new(
+        ok: payload["ok"] || false,
+        cost_usd: payload["cost_usd"],
+        alert_triggered: payload["alert_triggered"]
+      )
+    rescue StandardError => e
+      raise if !@silent
+
+      TrackCompletionResult.new(ok: false, error: e.message)
+    end
+  end
+end
+
+require_relative "apipurse/wrap_openai"
+require_relative "apipurse/wrap_anthropic"

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: apipurse-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- APIPurse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-07-26 00:00:00.000000000 Z
+dependencies: []
+description: 'Automatic OpenAI/Anthropic client wrappers plus a manual track_completion()
+  client. Not a network proxy: nothing routes through APIPurse''s servers.'
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/apipurse.rb
+- lib/apipurse/wrap_anthropic.rb
+- lib/apipurse/wrap_openai.rb
+homepage: https://github.com/yelmorab/Apipurse
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/yelmorab/Apipurse
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: APIPurse real-time cost tracking SDK for Ruby
+test_files: []