tep 0.11.2 → 0.11.4

data/lib/spinel_kit/url.rb

@@ -0,0 +1,166 @@
+# VENDORED from OriPekelman/spinelkit @ 09e8558 -- DO NOT EDIT HERE.
+# Edit upstream and re-sync with `make vendor-spinelkit`.
+require_relative "hex"
+
+# SpinelKit::Url -- percent-encode/decode (the CGI / URI-component surface
+# Spinel can't get from stdlib) plus a form-query parser and a small URL
+# splitter. Ported from Tep::Url; the hex digits now come from SpinelKit::Hex.
+#
+# Self-contained: the empty str=>str hashes are seeded inline (the
+# `{"" => ""}`-then-delete idiom that pins Spinel's value type), and substring
+# search is a private `find_idx` (the `< 0` callsites can't narrow against
+# String#index's int|nil under Spinel's current model). All pure string ops.
+module SpinelKit
+  class Url
+    # "%41+b" -> "A b" (form-decode: `+` is space, `%XX` is a byte).
+    def self.unescape(s)
+      out = ""
+      i = 0
+      n = s.length
+      while i < n
+        c = s[i]
+        if c == "+"
+          out = out + " "
+          i += 1
+        elsif c == "%" && i + 2 < n
+          hi = Hex.nibble(s[i + 1])
+          lo = Hex.nibble(s[i + 2])
+          if hi >= 0 && lo >= 0
+            out = out + ((hi * 16 + lo).chr)
+            i += 3
+          else
+            out = out + c
+            i += 1
+          end
+        else
+          out = out + c
+          i += 1
+        end
+      end
+      out
+    end
+
+    # Percent-encode everything outside the RFC 3986 unreserved set
+    # (ALPHA / DIGIT / `-._~`); the rest becomes `%XX` with UPPERCASE hex.
+    # (Space -> `%20`, not `+` -- this is the URI-component, not form, encoder.)
+    #
+    # Byte-oriented: under Spinel `String#[]` indexes BYTES, so a multi-byte
+    # UTF-8 char is encoded byte-by-byte (correct %XX of each byte). Under CRuby,
+    # pass a binary string for the same behaviour (else `[]` splits on chars).
+    def self.escape(s)
+      out = ""
+      i = 0
+      while i < s.length
+        c = s[i]
+        if (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") ||
+           (c >= "0" && c <= "9") || c == "-" || c == "." ||
+           c == "_" || c == "~"
+          out = out + c
+        else
+          b = c.getbyte(0)
+          out = out + "%" + Hex.nibble_char(b / 16) + Hex.nibble_char(b % 16)
+        end
+        i += 1
+      end
+      out
+    end
+
+    # "a=1&b=2&c" -> {"a"=>"1","b"=>"2","c"=>""}. Keys + values are
+    # form-decoded (`unescape`).
+    def self.parse_query(s)
+      h = {"" => ""}
+      h.delete("")
+      if s.length == 0
+        return h
+      end
+      pairs = s.split("&")
+      pairs.each do |pair|
+        if pair.length > 0
+          eq = Url.find_idx(pair, "=", 0)
+          if eq < 0
+            h[Url.unescape(pair)] = ""
+          else
+            k = pair[0, eq]
+            v = pair[eq + 1, pair.length - eq - 1]
+            h[Url.unescape(k)] = Url.unescape(v)
+          end
+        end
+      end
+      h
+    end
+
+    # Split `http(s)://host[:port]/path?query` into a str=>str hash keyed
+    # scheme / host / port / path / query. Without a scheme the input is
+    # treated as a path (host stays empty). Default ports follow the scheme
+    # (80 / 443); `query` is the raw substring after `?` (not decoded).
+    #
+    # One body on purpose: Spinel widens a Hash-typed value when a helper
+    # mutates it and the caller keeps reading, so `out` stays StrStrHash only
+    # if nothing factors the mutation out (find_idx returns an int, no mutate).
+    def self.split_url(u)
+      out = {"" => ""}
+      out.delete("")
+      out["scheme"] = ""
+      out["host"]   = ""
+      out["port"]   = ""
+      out["path"]   = "/"
+      out["query"]  = ""
+
+      rest = u
+      if rest.length >= 7 && rest[0, 7] == "http://"
+        out["scheme"] = "http"
+        out["port"]   = "80"
+        rest = rest[7, rest.length - 7]
+      elsif rest.length >= 8 && rest[0, 8] == "https://"
+        out["scheme"] = "https"
+        out["port"]   = "443"
+        rest = rest[8, rest.length - 8]
+      end
+
+      if out["scheme"].length > 0
+        slash = Url.find_idx(rest, "/", 0)
+        hostport = rest
+        tail     = "/"
+        if slash >= 0
+          hostport = rest[0, slash]
+          tail     = rest[slash, rest.length - slash]
+        end
+        colon = Url.find_idx(hostport, ":", 0)
+        if colon >= 0
+          out["host"] = hostport[0, colon]
+          out["port"] = hostport[colon + 1, hostport.length - colon - 1]
+        else
+          out["host"] = hostport
+        end
+        rest = tail
+      end
+
+      qi = Url.find_idx(rest, "?", 0)
+      if qi >= 0
+        out["path"]  = rest[0, qi]
+        out["query"] = rest[qi + 1, rest.length - qi - 1]
+      else
+        out["path"] = rest
+      end
+      if out["path"].length == 0
+        out["path"] = "/"
+      end
+      out
+    end
+
+    # First index of `needle` in `s` at/after `start`, or -1. Internal
+    # (Spinel-safe substring search; see the module comment).
+    def self.find_idx(s, needle, start)
+      nlen = needle.length
+      slen = s.length
+      pos = start
+      while pos <= slen - nlen
+        if s[pos, nlen] == needle
+          return pos
+        end
+        pos += 1
+      end
+      -1
+    end
+  end
+end

data/lib/tep/auth_bearer_token.rb

@@ -9,7 +9,7 @@
 #   Tep::AuthBearerToken.set_secret(ENV["JWT_SECRET"])
 #
 # Token payload schema (flat JSON, single level -- matches
-# Tep::Json's flat-object extraction surface):
+# SpinelKit::Json's flat-object extraction surface):
 #
 #   {
 #     "sub":      "user:42",                    # principal_id (required)
@@ -22,7 +22,7 @@
 #                                               # agent_id|issued_at|expires_at|origin
 #   }
 #
-# Why flat (not nested `acting_via: { ... }`): Tep::Json today
+# Why flat (not nested `acting_via: { ... }`): SpinelKit::Json today
 # extracts flat keys only. A nested-object getter is a separate
 # tiny battery; for v1 of Auth the flat pipe-encoded delegate
 # string is the smallest thing that ships and round-trips
@@ -64,20 +64,20 @@ module Tep
 
       # Check expiry first -- a token whose exp passed gets rejected
       # even if the signature still verifies. exp is unix epoch sec.
-      exp = Tep::Json.get_int(payload, "exp")
+      exp = SpinelKit::Json.get_int(payload, "exp")
       if exp > 0 && Time.now.to_i >= exp
         return nil
       end
 
-      sub = Tep::Json.get_str(payload, "sub")
+      sub = SpinelKit::Json.get_str(payload, "sub")
       if sub.length == 0
         return nil
       end
 
-      caps_str = Tep::Json.get_str(payload, "caps")
+      caps_str = SpinelKit::Json.get_str(payload, "caps")
       caps = Tep::AuthBearerToken.parse_caps(caps_str)
 
-      delegate_str = Tep::Json.get_str(payload, "delegate")
+      delegate_str = SpinelKit::Json.get_str(payload, "delegate")
       delegation = Tep::AuthBearerToken.parse_delegate(delegate_str)
 
       Tep::Identity.new(sub, delegation, caps)

data/lib/tep/auth_oauth2.rb

@@ -161,10 +161,10 @@ module Tep
       delegate_str = rec.client_id + "|" + now_ts.to_s + "|" +
                      exp_ts.to_s + "|oauth_grant"
       payload = "{" +
-        Tep::Json.encode_pair_str("sub", rec.principal_id) + "," +
-        Tep::Json.encode_pair_int("exp", exp_ts) + "," +
-        Tep::Json.encode_pair_str("caps", rec.caps_str) + "," +
-        Tep::Json.encode_pair_str("delegate", delegate_str) +
+        SpinelKit::Json.encode_pair_str("sub", rec.principal_id) + "," +
+        SpinelKit::Json.encode_pair_int("exp", exp_ts) + "," +
+        SpinelKit::Json.encode_pair_str("caps", rec.caps_str) + "," +
+        SpinelKit::Json.encode_pair_str("delegate", delegate_str) +
       "}"
       Tep::Jwt.encode_hs256(payload, secret)
     end

data/lib/tep/events.rb

@@ -80,19 +80,19 @@ module Tep
       # was a bare string before #115. os + arch come from uname() via
       # Sock.sphttp_os_kind / sphttp_arch_kind.
       line = "{" +
-        Json.encode_pair_str("kind", "run_start") + "," +
-        Json.encode_pair_str("schema", "toy/v1") + "," +
-        Json.encode_pair_int("t", 0) + "," +
-        Json.encode_pair_str("started_at", started) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_start") + "," +
+        SpinelKit::Json.encode_pair_str("schema", "toy/v1") + "," +
+        SpinelKit::Json.encode_pair_int("t", 0) + "," +
+        SpinelKit::Json.encode_pair_str("started_at", started) + "," +
         "\"host\":{" +
-          Json.encode_pair_str("name", host) + "," +
-          Json.encode_pair_str("os",   Sock.sphttp_os_kind) + "," +
-          Json.encode_pair_str("arch", Sock.sphttp_arch_kind) +
+          SpinelKit::Json.encode_pair_str("name", host) + "," +
+          SpinelKit::Json.encode_pair_str("os",   Sock.sphttp_os_kind) + "," +
+          SpinelKit::Json.encode_pair_str("arch", Sock.sphttp_arch_kind) +
         "}," +
-        "\"backend\":{" + Json.encode_pair_str("kind", backend_kind) + "}," +
+        "\"backend\":{" + SpinelKit::Json.encode_pair_str("kind", backend_kind) + "}," +
         "\"model\":{" +
-          Json.encode_pair_str("name", model_name) + "," +
-          Json.encode_pair_str("path", model_path) +
+          SpinelKit::Json.encode_pair_str("name", model_name) + "," +
+          SpinelKit::Json.encode_pair_str("path", model_path) +
         "}," +
         "\"config\":" + config_json +
       "}"
@@ -120,10 +120,10 @@ module Tep
       # Build the merged extra: spec fields first, then caller's
       # fields appended (if non-empty).
       extra = "{" +
-        Json.encode_pair_str("model", model) + "," +
-        Json.encode_pair_int("prompt_tokens", prompt_tokens) + "," +
-        Json.encode_pair_int("completion_tokens", completion_tokens) + "," +
-        Json.encode_pair_int("latency_us", wall_us)
+        SpinelKit::Json.encode_pair_str("model", model) + "," +
+        SpinelKit::Json.encode_pair_int("prompt_tokens", prompt_tokens) + "," +
+        SpinelKit::Json.encode_pair_int("completion_tokens", completion_tokens) + "," +
+        SpinelKit::Json.encode_pair_int("latency_us", wall_us)
       caller_inner = ""
       if extra_json.length > 2
         # Strip the outer braces -- "{...}" -> "...".
@@ -134,10 +134,10 @@ module Tep
       end
       extra = extra + "}"
       line = "{" +
-        Json.encode_pair_str("kind", "eval") + "," +
-        Json.encode_pair_str("phase", "serve") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("name", "request") + "," +
+        SpinelKit::Json.encode_pair_str("kind", "eval") + "," +
+        SpinelKit::Json.encode_pair_str("phase", "serve") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("name", "request") + "," +
         "\"extra\":" + extra +
       "}"
       append_line(line)
@@ -163,14 +163,14 @@ module Tep
       end
       ended = Sock.sphttp_iso8601_utc(Time.now.to_i)
       line = "{" +
-        Json.encode_pair_str("kind", "run_end") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("ended_at", ended) + "," +
-        Json.encode_pair_str("reason", reason) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_end") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("ended_at", ended) + "," +
+        SpinelKit::Json.encode_pair_str("reason", reason) + "," +
         "\"stats\":{" +
-          Json.encode_pair_int("requests", @req_count) + "," +
-          Json.encode_pair_int("errors", @err_count) + "," +
-          Json.encode_pair_int("tokens_out", @tok_out) +
+          SpinelKit::Json.encode_pair_int("requests", @req_count) + "," +
+          SpinelKit::Json.encode_pair_int("errors", @err_count) + "," +
+          SpinelKit::Json.encode_pair_int("tokens_out", @tok_out) +
         "}" +
       "}"
       append_line(line)
@@ -205,28 +205,28 @@ module Tep
            Tep.str_find(line_s, "\"name\":\"request\"", 0) >= 0
           reqs += 1
           # completion_tokens now lives nested inside the `extra`
-          # object. Tep::Json.find_value_start walks only the
+          # object. SpinelKit::Json.find_value_start walks only the
           # top-level keys (it skips over nested objects), so we
           # have to extract extra first, then get_int within it.
-          extra_pos = Json.find_value_start(line_s, "extra")
+          extra_pos = SpinelKit::Json.find_value_start(line_s, "extra")
           if extra_pos >= 0
-            obj_end = Json.skip_container(line_s, extra_pos)
+            obj_end = SpinelKit::Json.skip_container(line_s, extra_pos)
             extra_obj = line_s[extra_pos, obj_end - extra_pos]
-            toks += Json.get_int(extra_obj, "completion_tokens")
+            toks += SpinelKit::Json.get_int(extra_obj, "completion_tokens")
           end
         end
         i += 1
       end
       ended = Sock.sphttp_iso8601_utc(Time.now.to_i)
       out = "{" +
-        Json.encode_pair_str("kind", "run_end") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("ended_at", ended) + "," +
-        Json.encode_pair_str("reason", reason) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_end") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("ended_at", ended) + "," +
+        SpinelKit::Json.encode_pair_str("reason", reason) + "," +
         "\"stats\":{" +
-          Json.encode_pair_int("requests", reqs) + "," +
-          Json.encode_pair_int("errors", errs) + "," +
-          Json.encode_pair_int("tokens_out", toks) +
+          SpinelKit::Json.encode_pair_int("requests", reqs) + "," +
+          SpinelKit::Json.encode_pair_int("errors", errs) + "," +
+          SpinelKit::Json.encode_pair_int("tokens_out", toks) +
         "}" +
       "}"
       append_line(out)
@@ -243,7 +243,7 @@ module Tep
     end
 
     # Append one JSON line. Best-effort, append mode -- mirrors
-    # Tep::Logger's file sink. Telemetry must never fail a request, so
+    # SpinelKit::Log's file sink. Telemetry must never fail a request, so
     # a malformed/unwritable path degrades to a dropped line rather
     # than a raised error reaching the handler. Callers gate on a
     # non-empty @path before reaching here.

data/lib/tep/http.rb

@@ -151,7 +151,7 @@ module Tep
 
     def self.send_req_blocking(verb, url, body, headers)
       out = Tep::Http::Response.new
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       scheme = parts["scheme"]
       if scheme != "http" && scheme != "https"
         # Unknown scheme.
@@ -168,7 +168,7 @@ module Tep
       # pooling TLS sockets is out of scope for 6.7b (#126). HTTP/1.0 +
       # Connection: close + recv-until-EOF over a fresh verified socket.
       if scheme == "https"
-        fd = Sock.sphttp_connect_tls(host, port)   # port 443 via Tep::Url
+        fd = Sock.sphttp_connect_tls(host, port)   # port 443 via SpinelKit::Url
         if fd < 0
           return out
         end
@@ -275,7 +275,7 @@ module Tep
     # docs/MACOS-CONCURRENCY.md for the why.
     def self.send_req_coop(verb, url, body, headers)
       out = Tep::Http::Response.new
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       scheme = parts["scheme"]
       if scheme != "http" && scheme != "https"
         return out

data/lib/tep/job.rb

@@ -24,7 +24,7 @@
 #   )
 #
 # The single-arg payload is intentional: structured data goes
-# through JSON (Tep::Json) which we already ship. Sidekiq's
+# through JSON (SpinelKit::Json) which we already ship. Sidekiq's
 # multi-arg `perform_async(a, b, c)` translates to encoding the
 # tuple as a JSON string and decoding it in `perform`.
 #
@@ -34,7 +34,7 @@
 #
 #     class HelloJob < Tep::Job
 #       def perform(arg)
-#         Tep::Logger.new.info("hello " + arg)
+#         SpinelKit::Log.new.info("hello " + arg)
 #         "done"
 #       end
 #     end

data/lib/tep/jwt.rb

@@ -13,14 +13,14 @@
 # Surface
 # -------
 #
-#   payload_json = "{" + Tep::Json.encode_pair_str("sub", user_id) + "," +
-#                        Tep::Json.encode_pair_int("exp", exp_unix) + "}"
+#   payload_json = "{" + SpinelKit::Json.encode_pair_str("sub", user_id) + "," +
+#                        SpinelKit::Json.encode_pair_int("exp", exp_unix) + "}"
 #   token = Tep::Jwt.encode_hs256(payload_json, secret)
 #
 #   # On the receiving side:
 #   if Tep::Jwt.verify_hs256(token, secret)
 #     payload = Tep::Jwt.decode_payload(token)   # the JSON string
-#     sub = Tep::Json.get_str(payload, "sub")
+#     sub = SpinelKit::Json.get_str(payload, "sub")
 #   end
 #
 # Scope
@@ -32,7 +32,7 @@
 #
 # **Claims validation:** the `verify_hs256` only checks the
 # signature. `exp` / `nbf` / `iss` / `aud` claim checks are left
-# to caller code -- pull them with `Tep::Json.get_int(payload, "exp")`
+# to caller code -- pull them with `SpinelKit::Json.get_int(payload, "exp")`
 # and compare against `Time.now.to_i`. This keeps the surface
 # small and lets the app's policy decide what's required (some
 # apps want skew tolerance, some want strict expiry).

data/lib/tep/live_view.rb

@@ -132,8 +132,8 @@ module Tep
     #     "note":      <free text>,
     #     "until_ts":  <unix ts or 0> }
     #
-    # Subclasses typically pull a few keys via Tep::Json.get_str /
-    # Tep::Json.get_int + update an @presence ivar; then either
+    # Subclasses typically pull a few keys via SpinelKit::Json.get_str /
+    # SpinelKit::Json.get_int + update an @presence ivar; then either
     # call broadcast_render (to fan out the new HTML to every
     # subscriber) or just mutate (if the LiveView is the only
     # observer).
@@ -176,8 +176,8 @@ module Tep
     # imeth on the base class dispatches through the typed slot
     # of the subclass instance and avoids the box.
     def dispatch_event_json(json_msg, req)
-      event   = Tep::Json.get_str(json_msg, "event")
-      payload = Tep::Json.get_str(json_msg, "payload")
+      event   = SpinelKit::Json.get_str(json_msg, "event")
+      payload = SpinelKit::Json.get_str(json_msg, "payload")
       handle_event(event, payload, req)
       0
     end

data/lib/tep/llm.rb

@@ -96,7 +96,7 @@ module Tep
       # argument's typed-callsite to a single shape -- splitting
       # tripped spinel's cross-method param inference.
       body = body[0, body.length - 1] + ",\"stream\":true}"
-      parts = Tep::Url.split_url(@base_url)
+      parts = SpinelKit::Url.split_url(@base_url)
       host = parts["host"]
       port = parts["port"].to_i
       fd = Sock.sphttp_connect(host, port)
@@ -123,15 +123,15 @@ module Tep
       out
     end
 
-    # Hand-rolled JSON build. Tep::Json doesn't ship nested
+    # Hand-rolled JSON build. SpinelKit::Json doesn't ship nested
     # array-of-hash support (its public encoders are flat); the
     # request body is a fixed shape so the inline assembly stays
     # bounded.
     def self.build_request_body(model, system_prompt, messages)
-      out = "{\"model\":" + Json.quote(model) + ",\"messages\":["
+      out = "{\"model\":" + SpinelKit::Json.quote(model) + ",\"messages\":["
       first = true
       if system_prompt.length > 0
-        out = out + "{\"role\":\"system\",\"content\":" + Json.quote(system_prompt) + "}"
+        out = out + "{\"role\":\"system\",\"content\":" + SpinelKit::Json.quote(system_prompt) + "}"
         first = false
       end
       i = 0
@@ -140,8 +140,8 @@ module Tep
           out = out + ","
         end
         msg = messages[i]
-        out = out + "{\"role\":" + Json.quote(msg.role) +
-                    ",\"content\":" + Json.quote(msg.content) + "}"
+        out = out + "{\"role\":" + SpinelKit::Json.quote(msg.role) +
+                    ",\"content\":" + SpinelKit::Json.quote(msg.content) + "}"
         first = false
         i += 1
       end
@@ -152,7 +152,7 @@ module Tep
     # OpenAI response shape:
     #   {"choices":[{"message":{"role":"assistant","content":"..."},
     #                "finish_reason":"stop"}], ...}
-    # We extract two fields, both inside choices[0]. Tep::Json's
+    # We extract two fields, both inside choices[0]. SpinelKit::Json's
     # flat-key decoder doesn't dive that deep, so we hand-walk the
     # JSON looking for `"message":{...}` and pull "content" + (the
     # surrounding) "finish_reason" out of it.
@@ -344,7 +344,7 @@ module Tep
           delta = Llm.extract_str_field(payload, "content", 0)
           if delta.length > 0
             state.acc = state.acc + delta
-            out_stream.write("data: {" + Json.encode_pair_str("content", delta) + "}\n\n")
+            out_stream.write("data: {" + SpinelKit::Json.encode_pair_str("content", delta) + "}\n\n")
           end
           # finish_reason on the last frame -- not load-bearing for
           # the accumulator but signals upstream end-of-stream.
@@ -375,11 +375,10 @@ module Tep
           return out
         end
         hex = s[i, eol - i]
-        n = Llm.hex_to_int(hex)
-        if n < 0
-          # Malformed length; bail.
-          return out
-        end
+        # to_int parses the leading hex (so a `size;ext` chunk-extension
+        # yields the size, not a parse error) and is >= 0, so 0 -- empty or
+        # no leading hex -- is the terminating chunk / give-up point.
+        n = SpinelKit::Hex.to_int(hex)
         if n == 0
           # Last chunk -- done.
           return out
@@ -407,10 +406,7 @@ module Tep
           return s[i, s.length - i]
         end
         hex = s[i, eol - i]
-        n = Llm.hex_to_int(hex)
-        if n < 0
-          return s[i, s.length - i]
-        end
+        n = SpinelKit::Hex.to_int(hex)   # leading-hex, >= 0 (see dechunk_consume)
         if n == 0
           return ""
         end
@@ -443,34 +439,6 @@ module Tep
       state.acc
     end
 
-    # Parse a (small) hex string to Integer; -1 on malformed.
-    # Chunked sizes are at most 8 hex chars in practice (4 GB);
-    # we cap at 16 for safety.
-    def self.hex_to_int(s)
-      if s.length == 0 || s.length > 16
-        return -1
-      end
-      n = 0
-      i = 0
-      while i < s.length
-        c = s[i]
-        d = -1
-        if c >= "0" && c <= "9"
-          d = (c.ord - 48)
-        elsif c >= "a" && c <= "f"
-          d = (c.ord - 87)
-        elsif c >= "A" && c <= "F"
-          d = (c.ord - 55)
-        end
-        if d < 0
-          return -1
-        end
-        n = n * 16 + d
-        i += 1
-      end
-      n
-    end
-
     # Per-stream state carried across consume_sse_events / read
     # loop iterations. See chat_stream + read_sse_response for use.
     class StreamState

data/lib/tep/mcp.rb

@@ -86,14 +86,14 @@ module Tep
     # handing the arguments sub-object to the per-tool cmeth.
     #
     # Returns "{}" when the key isn't present (so downstream
-    # Tep::Json.get_str / get_int calls see an empty object that
+    # SpinelKit::Json.get_str / get_int calls see an empty object that
     # returns their zero-default cleanly).
     def self.nested_extract(json, key)
-      pos = Tep::Json.find_value_start(json, key)
+      pos = SpinelKit::Json.find_value_start(json, key)
       if pos < 0
         return "{}"
       end
-      end_pos = Tep::Json.skip_value(json, pos)
+      end_pos = SpinelKit::Json.skip_value(json, pos)
       if end_pos <= pos
         return "{}"
       end
@@ -109,8 +109,8 @@ module Tep
           "\"protocolVersion\":\"" + Tep::MCP::PROTOCOL_VERSION + "\"," +
           "\"capabilities\":{\"tools\":{},\"resources\":{}}," +
           "\"serverInfo\":{" +
-            "\"name\":"    + Tep::Json.quote(server_name)    + "," +
-            "\"version\":" + Tep::Json.quote(server_version) +
+            "\"name\":"    + SpinelKit::Json.quote(server_name)    + "," +
+            "\"version\":" + SpinelKit::Json.quote(server_version) +
           "}" +
         "}" +
       "}"
@@ -138,7 +138,7 @@ module Tep
       "{\"jsonrpc\":\"2.0\",\"id\":" + req_id.to_s + "," +
         "\"result\":{" +
           "\"content\":[" +
-            "{\"type\":\"text\",\"text\":" + Tep::Json.quote(text) + "}" +
+            "{\"type\":\"text\",\"text\":" + SpinelKit::Json.quote(text) + "}" +
           "]," +
           "\"isError\":" + is_err_str +
         "}" +
@@ -163,9 +163,9 @@ module Tep
     def self.resources_read_envelope(req_id, uri, mime, text)
       "{\"jsonrpc\":\"2.0\",\"id\":" + req_id.to_s + "," +
         "\"result\":{\"contents\":[" +
-          "{\"uri\":" + Tep::Json.quote(uri) + "," +
-           "\"mimeType\":" + Tep::Json.quote(mime) + "," +
-           "\"text\":" + Tep::Json.quote(text) + "}" +
+          "{\"uri\":" + SpinelKit::Json.quote(uri) + "," +
+           "\"mimeType\":" + SpinelKit::Json.quote(mime) + "," +
+           "\"text\":" + SpinelKit::Json.quote(text) + "}" +
         "]}" +
       "}"
     end
@@ -175,7 +175,7 @@ module Tep
     def self.unknown_resource_envelope(req_id, uri)
       "{\"jsonrpc\":\"2.0\",\"id\":" + req_id.to_s + "," +
         "\"error\":{\"code\":-32602," +
-          "\"message\":" + Tep::Json.quote("unknown resource: " + uri) +
+          "\"message\":" + SpinelKit::Json.quote("unknown resource: " + uri) +
         "}" +
       "}"
     end
@@ -185,7 +185,7 @@ module Tep
     def self.unknown_tool_envelope(req_id, tool_name)
       "{\"jsonrpc\":\"2.0\",\"id\":" + req_id.to_s + "," +
         "\"error\":{\"code\":-32602," +
-          "\"message\":" + Tep::Json.quote("unknown tool: " + tool_name) +
+          "\"message\":" + SpinelKit::Json.quote("unknown tool: " + tool_name) +
         "}" +
       "}"
     end
@@ -195,7 +195,7 @@ module Tep
     def self.method_not_found_envelope(req_id, method_name)
       "{\"jsonrpc\":\"2.0\",\"id\":" + req_id.to_s + "," +
         "\"error\":{\"code\":-32601," +
-          "\"message\":" + Tep::Json.quote("method not found: " + method_name) +
+          "\"message\":" + SpinelKit::Json.quote("method not found: " + method_name) +
         "}" +
       "}"
     end

data/lib/tep/multipart.rb

@@ -9,7 +9,7 @@
 # different surface (likely `req.files`) plus an NUL-safe byte
 # array, both follow-ups.
 #
-# Public API mirrors Url.parse_query: pass the raw body + the
+# Public API mirrors SpinelKit::Url.parse_query: pass the raw body + the
 # request's Content-Type header value; get back a string-keyed
 # string-valued hash, ready to merge into `req.params`.
 module Tep