wave-dispatch 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fad95eeecc253e395c29e551144cc7ef306b40e24210e7310d068c4a15ed56c
-  data.tar.gz: d85a1e03d7ebb16310077c3c7086dcf4744a4e700b20b576f342c49c05460ef7
+  metadata.gz: 409e75177b57d71d5c816915aca6be428f36539c462c19610a945d34435d90ce
+  data.tar.gz: 364157ef490e38907643ba7b5a46a5d33a7c0bf41bc5392681fdf3ff4831f512
 SHA512:
-  metadata.gz: c9af2f42bfa9f0335d24b8062cb316ac5679b37753420418802caa073e86cb32eb291c1e32ad6c0ec03c5d3ed8f67030fe505f96c78f267831c1ced7456abd7a
-  data.tar.gz: 163bfff112548e72f2c18099b7fc0bb3d0d32e6ac450ffda0773b9237a92207247bf697ee9319a0f86bbfe67aed515ebaf77e943dc66cf0620693609020f7a58
+  metadata.gz: 5cef51963137cdccaf2df37be1d4337bbdc54904afda8a02541451fe2755645d139e6fc246f183aa923fc35d3fbcca432016f4c368419dd1d248ec8696355e4e
+  data.tar.gz: 76f60d66aebc013a709155442104dcd47e7dc50db030e326e8c8e75f58cf5a7b9061e8f3a2b4586998af0d121edf1c664eaeaa472d4cda1d98b0b6b582fdc10b

data/lib/wave_dispatch.rb

@@ -1,19 +1,25 @@
 # wave Dispatch — thin Ruby client. Route each request to the cheapest capable model (local-first;
 # escalate to your frontier only when needed). BYO keys + infra. Stdlib only (net/http).
+require "base64"
 require "net/http"
 require "json"
 require "uri"
 require "openssl"
 
 module WaveDispatch
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 
+  # 0.5.1 — payment hook: a Proc called once with the 402 challenge body (Hash) that returns the
+  # headers (Hash[String => String]) to retry the request with. Pair with `Client.wallet_hook(provider:,
+  # credentials:)` for the built-in CDP / Privy / Bridge factories, or build a Proc yourself.
   class Client
     def initialize(license = ENV["WAVE_LICENSE"], endpoint: "https://dispatch.wave.online",
-                   agents_endpoint: ENV["WAVE_AGENTS_ENDPOINT"] || "https://dispatch-agents.wave.online")
+                   agents_endpoint: ENV["WAVE_AGENTS_ENDPOINT"] || "https://dispatch-agents.wave.online",
+                   payment_hook: nil)
       @license = license
       @endpoint = endpoint
       @agents = agents_endpoint
+      @payment_hook = payment_hook       # 0.5.1 — handles 402 inside the client
     end
 
     # Classify a prompt (no execution) -> {"route", "probability", "margin", "forward"}
@@ -22,6 +28,9 @@ module WaveDispatch
     # Classify and run on the edge if your plan allows it.
     def execute(prompt) = send_req(:post, @endpoint + "/", { prompt: prompt, execute: true })
 
+    # Classify a pre-computed 768-d embedding (matmul-only: cheapest + fastest).
+    def route_vector(vector) = send_req(:post, @endpoint + "/", { vector: vector })
+
     # This license's savings ledger (decisions, saved_usd, saved_pct, ...). Requires a license.
     def savings = send_req(:get, "#{@agents}/ledger/summary?license=#{lic}")
 
@@ -31,6 +40,17 @@ module WaveDispatch
     # Start/replace a programmatic subscription (plan: agent_starter | agent_pro | agent_scale).
     def subscribe(plan) = send_req(:post, "#{@agents}/subscription/create", { license: @license, plan: plan })
 
+    # 0.5.1 — build a payment_hook for a built-in provider. provider: :cdp | :privy | :bridge.
+    # credentials per provider: cdp: {api_key:, api_secret:, address:}; privy: {app_id:, app_secret:,
+    # wallet_id:}; bridge: {api_key:, source_wallet:, destination:}. For custom wallets, build a Proc
+    # of your own that returns the header Hash you want set on the retry.
+    def self.wallet_hook(provider:, credentials: {})
+      provider = provider.to_sym
+      header = { cdp: "cdp-payment", privy: "privy-payment", bridge: "bridge-payment" }[provider]
+      raise "dispatch.wallet_hook: unknown provider #{provider.inspect}" unless header
+      ->(challenge) { { header => WaveDispatch.wallet_sign(provider, credentials, challenge) } }
+    end
+
     private
 
     def lic
@@ -38,18 +58,73 @@ module WaveDispatch
       URI.encode_www_form_component(@license)
     end
 
-    def send_req(method, url, body = nil)
+    def build_req(method, url, body)
       uri = URI(url)
       req = (method == :post ? Net::HTTP::Post : Net::HTTP::Get).new(uri, "content-type" => "application/json")
       req["authorization"] = "Bearer #{@license}" if @license
       req.body = body.to_json if body
-      res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
-                            verify_mode: OpenSSL::SSL::VERIFY_PEER) { |h| h.request(req) }
-      raise "dispatch: 402 payment required (x402)" if res.code == "402"
+      [uri, req]
+    end
+
+    def http_call(uri, req)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                      verify_mode: OpenSSL::SSL::VERIFY_PEER) { |h| h.request(req) }
+    end
+
+    def send_req(method, url, body = nil)
+      uri, req = build_req(method, url, body)
+      res = http_call(uri, req)
+      if res.code == "402" && @payment_hook
+        challenge = (JSON.parse(res.body) rescue {})
+        extra = @payment_hook.call(challenge) || {}
+        uri2, req2 = build_req(method, url, body)
+        extra.each { |k, v| req2[k.to_s] = v }
+        res = http_call(uri2, req2)
+      end
+      raise "dispatch: 402 payment required (x402) — pay and retry, or set a license / payment_hook" if res.code == "402"
       raise "dispatch: 401 unauthorized — set a valid license" if res.code == "401"
-      # any other non-2xx must raise — never JSON.parse an error body and return it as a success result
       raise "dispatch: #{res.code} #{res.body.to_s[0, 160]}" unless res.code.start_with?("2")
       JSON.parse(res.body)
     end
   end
+
+  # Built-in provider sign — HTTP orchestration only; actual signing happens at the provider.
+  def self.wallet_sign(provider, creds, challenge)
+    accepts = challenge.is_a?(Hash) ? (challenge["accepts"] || []) : []
+    accept = accepts.find { |a| a.is_a?(Hash) && a["protocol"] == provider.to_s } || accepts.first || {}
+    case provider
+    when :cdp
+      # CDP-JWT signing is non-trivial in stdlib-only Ruby; the built-in returns a marker payload that
+      # the worker accepts via the wave-payments adapter when WAVE_VERIFY_URL is set. For full on-chain
+      # CDP signing, build your own Proc with the official Coinbase CDP gem.
+      { provider: "cdp", address: creds[:address], accept: accept,
+        hint: "use the coinbase-cdp gem for CDP-JWT signing in production" }.to_json
+    when :privy
+      %i[app_id app_secret wallet_id].each { |k| raise "dispatch.wallet_hook(privy): #{k} required" unless creds[k] }
+      basic = Base64.strict_encode64("#{creds[:app_id]}:#{creds[:app_secret]}")
+      uri = URI("https://auth.privy.io/api/v1/wallets/#{URI.encode_www_form_component(creds[:wallet_id])}/rpc")
+      req = Net::HTTP::Post.new(uri, "content-type" => "application/json",
+                                "authorization" => "Basic #{basic}", "privy-app-id" => creds[:app_id])
+      req.body = { method: "personal_sign", params: { message: accept.to_json }, chain_type: "ethereum" }.to_json
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: true,
+                            verify_mode: OpenSSL::SSL::VERIFY_PEER) { |h| h.request(req) }
+      raise "dispatch.wallet_hook(privy): provider #{res.code}" unless res.code.start_with?("2")
+      j = (JSON.parse(res.body) rescue {})
+      sig = (j.dig("data", "signature") || j["signature"])
+      { provider: "privy", signature: sig, accept: accept }.to_json
+    when :bridge
+      raise "dispatch.wallet_hook(bridge): :api_key required" unless creds[:api_key]
+      uri = URI("https://api.bridge.xyz/v0/transfers")
+      req = Net::HTTP::Post.new(uri, "content-type" => "application/json", "api-key" => creds[:api_key])
+      req.body = { source: creds[:source_wallet], destination: creds[:destination] || accept["payTo"],
+                   amount: accept["maxAmountRequired"] }.to_json
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: true,
+                            verify_mode: OpenSSL::SSL::VERIFY_PEER) { |h| h.request(req) }
+      raise "dispatch.wallet_hook(bridge): provider #{res.code}" unless res.code.start_with?("2")
+      j = (JSON.parse(res.body) rescue {})
+      { provider: "bridge", id: j["id"], accept: accept }.to_json
+    else
+      raise "dispatch.wallet_sign: unsupported provider #{provider.inspect}"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wave-dispatch
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - WAVE Online, LLC