tep 0.11.3 → 0.11.5

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

data/lib/tep/net.rb

@@ -12,9 +12,14 @@ module Sock
   # libssl/libcrypto. Linked for every app (like sqlite3 elsewhere);
   # the plaintext path never calls into it, so apps that make no HTTPS
   # requests pay only the link cost, not runtime. See tep#148.
-  # (When OpenSSL is off the default path -- macOS/Homebrew -- the build
-  # finds it via CPATH/LIBRARY_PATH in the environment, not a cflag
-  # here; spinel's ffi_cflags rejects an empty-string placeholder.)
+  #
+  # OpenSSL include/lib paths come via @TEP_SPHTTP_CFLAGS@ (the
+  # pkg_config sibling in spinel-ext.json -- `pkg-config openssl`,
+  # fallback `-lssl -lcrypto`), mirroring @TEP_PG_CFLAGS@. On Linux it's
+  # often just the libs (headers on the default path); on macOS/Homebrew
+  # it supplies the keg-only -I/-L too, so sphttp.c compiles + the
+  # ffi_lib "ssl"/"crypto" below resolve. See tep#208.
+  ffi_cflags "@TEP_SPHTTP_CFLAGS@"
   ffi_lib "ssl"
   ffi_lib "crypto"
 

data/lib/tep/openai_server.rb

@@ -69,7 +69,7 @@ module Tep
         # but receives the raw req so the backend can parse the
         # messages array itself + apply its own chat template. Tep
         # doesn't pre-build a Message[] because templating + role
-        # ordering is per-model; the JSON tools live in Tep::Json. The
+        # ordering is per-model; the JSON tools live in SpinelKit::Json. The
         # return is reused from the token path (text becomes the
         # assistant message's content). Base no-op; subclasses override.
         # Only reached when supports_chat? returns true -- the handler
@@ -150,8 +150,8 @@ module Tep
           # override answers (e.g. ToyBackend returning "cuda").
           backend_kind = Tep::APP.openai_backend.device_kind
           config_json = "{" +
-            Tep::Json.encode_pair_str("server", "tep-llm-openai") + "," +
-            Tep::Json.encode_pair_str("events_jsonl", events_jsonl) +
+            SpinelKit::Json.encode_pair_str("server", "tep-llm-openai") + "," +
+            SpinelKit::Json.encode_pair_str("events_jsonl", events_jsonl) +
           "}"
           events.run_start(host, backend_kind, "", "", config_json)
           Tep.get("/v1/models",            Tep::Llm::OpenAI::ModelsHandler.new)
@@ -185,17 +185,17 @@ module Tep
       def self.parse_messages(body)
         out = [Tep::Llm::Message.new("", "")]
         out.delete_at(0)
-        pos = Tep::Json.find_value_start(body, "messages")
+        pos = SpinelKit::Json.find_value_start(body, "messages")
         if pos < 0
           return out
         end
-        pos = Tep::Json.skip_ws(body, pos)
+        pos = SpinelKit::Json.skip_ws(body, pos)
         if pos >= body.length || body[pos] != "["
           return out
         end
         pos += 1
         while pos < body.length
-          pos = Tep::Json.skip_ws(body, pos)
+          pos = SpinelKit::Json.skip_ws(body, pos)
           if pos >= body.length
             return out
           end
@@ -208,9 +208,9 @@ module Tep
             next
           end
           if c == "{"
-            obj_end = Tep::Json.skip_container(body, pos)
+            obj_end = SpinelKit::Json.skip_container(body, pos)
             # Parse role + content within this object range. Run two
-            # passes scoped via Tep::Json's existing key search: the
+            # passes scoped via SpinelKit::Json's existing key search: the
             # body-wide find could match a key in a sibling object so
             # we instead walk the bytes between `pos` and `obj_end`
             # manually, looking only for `"role"` / `"content"`.
@@ -219,7 +219,7 @@ module Tep
             out.push(Tep::Llm::Message.new(role, cont))
             pos = obj_end
           else
-            pos = Tep::Json.skip_value(body, pos)
+            pos = SpinelKit::Json.skip_value(body, pos)
           end
         end
         out
@@ -236,21 +236,21 @@ module Tep
           return ""
         end
         pos = pos + needle.length
-        pos = Tep::Json.skip_ws(body, pos)
+        pos = SpinelKit::Json.skip_ws(body, pos)
         if pos >= obj_end || body[pos] != ":"
           return ""
         end
         pos += 1
-        pos = Tep::Json.skip_ws(body, pos)
+        pos = SpinelKit::Json.skip_ws(body, pos)
         if pos >= obj_end
           return ""
         end
-        Tep::Json.parse_str_value(body, pos)
+        SpinelKit::Json.parse_str_value(body, pos)
       end
 
       # Sampling parameters handed to the backend. v1 carries
       # max_tokens + temperature + top_p (the three OpenAI completion
-      # knobs every client sets). Floats parsed via Tep::Json.get_float.
+      # knobs every client sets). Floats parsed via SpinelKit::Json.get_float.
       # Defaults match OpenAI's API defaults so a backend that ignores
       # sampling gets pass-through behavior.
       class Sampling
@@ -272,9 +272,16 @@ module Tep
       # Text backends leave token_ids empty and the ids field is omitted.
       # finish_reason defaults to "stop"; a fixed-length greedy backend
       # sets "length".
+      #
+      # id is the completion id echoed as the response `id` (and the
+      # inference event's request_id). It defaults to "cmpl-tep"; a backend
+      # that mints its own per-request ids (e.g. so a downstream byte-exact
+      # ingest keeps unique ids) sets it. Leaving it default keeps existing
+      # consumers byte-identical.
       class Completion
         attr_accessor :text, :prompt_tokens, :completion_tokens
         attr_accessor :token_ids, :finish_reason
+        attr_accessor :id
 
         def initialize
           @text              = ""
@@ -285,6 +292,7 @@ module Tep
           @token_ids         = [0]
           @token_ids.delete_at(0)
           @finish_reason     = "stop"
+          @id                = "cmpl-tep"
         end
       end
 
@@ -313,13 +321,13 @@ module Tep
         def emit_token(piece)
           @completion_count = @completion_count + 1
           frame = "{" +
-            Tep::Json.encode_pair_str("id", "cmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "text_completion") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", @model) + "," +
+            SpinelKit::Json.encode_pair_str("id", "cmpl-tep") + "," +
+            SpinelKit::Json.encode_pair_str("object", "text_completion") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", @model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
-              Tep::Json.encode_pair_str("text", piece) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_str("text", piece) + "," +
               "\"finish_reason\":null" +
             "}]" +
           "}"
@@ -361,8 +369,8 @@ module Tep
           out.write("data: [DONE]\n\n")
           wall_us = (Time.now.to_i - @t0) * 1_000_000
           extra = "{" +
-            Tep::Json.encode_pair_str("request_id", @request_id) + "," +
-            Tep::Json.encode_pair_str("principal_id", @principal_id) +
+            SpinelKit::Json.encode_pair_str("request_id", @request_id) + "," +
+            SpinelKit::Json.encode_pair_str("principal_id", @principal_id) +
           "}"
           Tep::APP.openai_events.inference(
             @model, @prompt_tokens, sink.completion_count, wall_us, extra)
@@ -397,14 +405,14 @@ module Tep
         # wire shape, sent once before content frames.
         def emit_role_prelude(role)
           frame = "{" +
-            Tep::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", @model) + "," +
+            SpinelKit::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
+            SpinelKit::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", @model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
               "\"delta\":{" +
-                Tep::Json.encode_pair_str("role", role) +
+                SpinelKit::Json.encode_pair_str("role", role) +
               "}," +
               "\"finish_reason\":null" +
             "}]" +
@@ -417,14 +425,14 @@ module Tep
         def emit_token(piece)
           @completion_count = @completion_count + 1
           frame = "{" +
-            Tep::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", @model) + "," +
+            SpinelKit::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
+            SpinelKit::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", @model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
               "\"delta\":{" +
-                Tep::Json.encode_pair_str("content", piece) +
+                SpinelKit::Json.encode_pair_str("content", piece) +
               "}," +
               "\"finish_reason\":null" +
             "}]" +
@@ -437,14 +445,14 @@ module Tep
         # streamer writes data:[DONE] after this.
         def emit_finish(reason)
           frame = "{" +
-            Tep::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", @model) + "," +
+            SpinelKit::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
+            SpinelKit::Json.encode_pair_str("object", "chat.completion.chunk") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", @model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
               "\"delta\":{}," +
-              Tep::Json.encode_pair_str("finish_reason", reason) +
+              SpinelKit::Json.encode_pair_str("finish_reason", reason) +
             "}]" +
           "}"
           @out.write("data: " + frame + "\n\n")
@@ -480,8 +488,8 @@ module Tep
           out.write("data: [DONE]\n\n")
           wall_us = (Time.now.to_i - @t0) * 1_000_000
           extra = "{" +
-            Tep::Json.encode_pair_str("request_id", @request_id) + "," +
-            Tep::Json.encode_pair_str("principal_id", @principal_id) +
+            SpinelKit::Json.encode_pair_str("request_id", @request_id) + "," +
+            SpinelKit::Json.encode_pair_str("principal_id", @principal_id) +
           "}"
           Tep::APP.openai_events.inference(
             @model, @prompt_tokens, sink.completion_count, wall_us, extra)
@@ -505,10 +513,10 @@ module Tep
               out = out + ","
             end
             out = out + "{" +
-              Tep::Json.encode_pair_str("id", models[i]) + "," +
-              Tep::Json.encode_pair_str("object", "model") + "," +
-              Tep::Json.encode_pair_int("created", created) + "," +
-              Tep::Json.encode_pair_str("owned_by", owner) +
+              SpinelKit::Json.encode_pair_str("id", models[i]) + "," +
+              SpinelKit::Json.encode_pair_str("object", "model") + "," +
+              SpinelKit::Json.encode_pair_int("created", created) + "," +
+              SpinelKit::Json.encode_pair_str("owned_by", owner) +
             "}"
             i += 1
           end
@@ -525,22 +533,22 @@ module Tep
       class CompletionsHandler < Tep::Handler
         def handle(req, res)
           body      = req.raw_body
-          model     = Tep::Json.get_str(body, "model")
-          token_ids = Tep::Json.get_int_array(body, "prompt")
+          model     = SpinelKit::Json.get_str(body, "model")
+          token_ids = SpinelKit::Json.get_int_array(body, "prompt")
           sampling  = Tep::Llm::OpenAI::Sampling.new
-          sampling.max_tokens = Tep::Json.get_int(body, "max_tokens")
+          sampling.max_tokens = SpinelKit::Json.get_int(body, "max_tokens")
           # Floats from the JSON body; defaults stay at 1.0 if the
-          # key is absent (Tep::Json.get_float returns 0.0 for
+          # key is absent (SpinelKit::Json.get_float returns 0.0 for
           # missing, but we only overwrite when present).
-          if Tep::Json.has_key?(body, "temperature")
-            sampling.temperature = Tep::Json.get_float(body, "temperature")
+          if SpinelKit::Json.has_key?(body, "temperature")
+            sampling.temperature = SpinelKit::Json.get_float(body, "temperature")
           end
-          if Tep::Json.has_key?(body, "top_p")
-            sampling.top_p = Tep::Json.get_float(body, "top_p")
+          if SpinelKit::Json.has_key?(body, "top_p")
+            sampling.top_p = SpinelKit::Json.get_float(body, "top_p")
           end
 
           # OpenAI signals streaming with "stream": true in the JSON
-          # body; Tep::Json has no bool getter, so we sniff the literal
+          # body; SpinelKit::Json has no bool getter, so we sniff the literal
           # (same shape as examples/llm_gateway/app.rb). When set, the
           # response is SSE: a CompletionsStreamer pumps per-token
           # frames + the [DONE] sentinel, then emits the inference
@@ -581,8 +589,8 @@ module Tep
           # the auth-filter populated identity (anonymous if none).
           wall_us = (Time.now.to_i - t0) * 1_000_000
           extra = "{" +
-            Tep::Json.encode_pair_str("request_id", "cmpl-tep") + "," +
-            Tep::Json.encode_pair_str("principal_id", req.identity.subject) +
+            SpinelKit::Json.encode_pair_str("request_id", comp.id) + "," +
+            SpinelKit::Json.encode_pair_str("principal_id", req.identity.subject) +
           "}"
           Tep::APP.openai_events.inference(
             model, comp.prompt_tokens, comp.completion_tokens, wall_us, extra
@@ -593,24 +601,24 @@ module Tep
           # empty and the field is omitted (standard OpenAI shape).
           ids_frag = ""
           if comp.token_ids.length > 0
-            ids_frag = "\"ids\":" + Tep::Json.from_int_array(comp.token_ids) + ","
+            ids_frag = "\"ids\":" + SpinelKit::Json.from_int_array(comp.token_ids) + ","
           end
 
           "{" +
-            Tep::Json.encode_pair_str("id", "cmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "text_completion") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", model) + "," +
+            SpinelKit::Json.encode_pair_str("id", comp.id) + "," +
+            SpinelKit::Json.encode_pair_str("object", "text_completion") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
-              Tep::Json.encode_pair_str("text", comp.text) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_str("text", comp.text) + "," +
               ids_frag +
-              Tep::Json.encode_pair_str("finish_reason", comp.finish_reason) +
+              SpinelKit::Json.encode_pair_str("finish_reason", comp.finish_reason) +
             "}]," +
             "\"usage\":{" +
-              Tep::Json.encode_pair_int("prompt_tokens", comp.prompt_tokens) + "," +
-              Tep::Json.encode_pair_int("completion_tokens", comp.completion_tokens) + "," +
-              Tep::Json.encode_pair_int("total_tokens", total) +
+              SpinelKit::Json.encode_pair_int("prompt_tokens", comp.prompt_tokens) + "," +
+              SpinelKit::Json.encode_pair_int("completion_tokens", comp.completion_tokens) + "," +
+              SpinelKit::Json.encode_pair_int("total_tokens", total) +
             "}" +
           "}"
         end
@@ -631,14 +639,14 @@ module Tep
             res.set_status(501)
             return "{" +
               "\"error\":{" +
-                Tep::Json.encode_pair_str("message",
+                SpinelKit::Json.encode_pair_str("message",
                   "chat completions not supported by this backend") + "," +
-                Tep::Json.encode_pair_str("type", "not_implemented") +
+                SpinelKit::Json.encode_pair_str("type", "not_implemented") +
               "}" +
             "}"
           end
           body  = req.raw_body
-          model = Tep::Json.get_str(body, "model")
+          model = SpinelKit::Json.get_str(body, "model")
 
           # Streaming branch (#127): same "stream":true sniff as
           # CompletionsHandler. Sends an SSE response driven by
@@ -667,22 +675,22 @@ module Tep
           comp  = Tep::APP.openai_backend.chat_completion(req)
           total = comp.prompt_tokens + comp.completion_tokens
           "{" +
-            Tep::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
-            Tep::Json.encode_pair_str("object", "chat.completion") + "," +
-            Tep::Json.encode_pair_int("created", Time.now.to_i) + "," +
-            Tep::Json.encode_pair_str("model", model) + "," +
+            SpinelKit::Json.encode_pair_str("id", "chatcmpl-tep") + "," +
+            SpinelKit::Json.encode_pair_str("object", "chat.completion") + "," +
+            SpinelKit::Json.encode_pair_int("created", Time.now.to_i) + "," +
+            SpinelKit::Json.encode_pair_str("model", model) + "," +
             "\"choices\":[{" +
-              Tep::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
               "\"message\":{" +
-                Tep::Json.encode_pair_str("role", "assistant") + "," +
-                Tep::Json.encode_pair_str("content", comp.text) +
+                SpinelKit::Json.encode_pair_str("role", "assistant") + "," +
+                SpinelKit::Json.encode_pair_str("content", comp.text) +
               "}," +
-              Tep::Json.encode_pair_str("finish_reason", "stop") +
+              SpinelKit::Json.encode_pair_str("finish_reason", "stop") +
             "}]," +
             "\"usage\":{" +
-              Tep::Json.encode_pair_int("prompt_tokens", comp.prompt_tokens) + "," +
-              Tep::Json.encode_pair_int("completion_tokens", comp.completion_tokens) + "," +
-              Tep::Json.encode_pair_int("total_tokens", total) +
+              SpinelKit::Json.encode_pair_int("prompt_tokens", comp.prompt_tokens) + "," +
+              SpinelKit::Json.encode_pair_int("completion_tokens", comp.completion_tokens) + "," +
+              SpinelKit::Json.encode_pair_int("total_tokens", total) +
             "}" +
           "}"
         end
@@ -701,30 +709,30 @@ module Tep
             res.set_status(501)
             return "{" +
               "\"error\":{" +
-                Tep::Json.encode_pair_str("message",
+                SpinelKit::Json.encode_pair_str("message",
                   "embeddings not supported by this backend") + "," +
-                Tep::Json.encode_pair_str("type", "not_implemented") +
+                SpinelKit::Json.encode_pair_str("type", "not_implemented") +
               "}" +
             "}"
           end
           body  = req.raw_body
-          model = Tep::Json.get_str(body, "model")
-          ids   = Tep::Json.get_int_array(body, "input")
+          model = SpinelKit::Json.get_str(body, "model")
+          ids   = SpinelKit::Json.get_int_array(body, "input")
           if ids.length == 0
             res.set_status(400)
             return "{" +
               "\"error\":{" +
-                Tep::Json.encode_pair_str("message",
+                SpinelKit::Json.encode_pair_str("message",
                   "input must be a non-empty integer array " +
                   "(this server speaks token IDs only; tokenize client-side)") + "," +
-                Tep::Json.encode_pair_str("type", "invalid_request_error") +
+                SpinelKit::Json.encode_pair_str("type", "invalid_request_error") +
               "}" +
             "}"
           end
 
           vec = Tep::APP.openai_backend.generate_embeddings(model, ids)
 
-          # Build the embedding float array by hand: Tep::Json has no
+          # Build the embedding float array by hand: SpinelKit::Json has no
           # float-array encoder, and Float#to_s yields a JSON number.
           emb = "["
           k = 0
@@ -739,16 +747,16 @@ module Tep
 
           n = ids.length
           "{" +
-            Tep::Json.encode_pair_str("object", "list") + "," +
+            SpinelKit::Json.encode_pair_str("object", "list") + "," +
             "\"data\":[{" +
-              Tep::Json.encode_pair_str("object", "embedding") + "," +
-              Tep::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_str("object", "embedding") + "," +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
               "\"embedding\":" + emb +
             "}]," +
-            Tep::Json.encode_pair_str("model", model) + "," +
+            SpinelKit::Json.encode_pair_str("model", model) + "," +
             "\"usage\":{" +
-              Tep::Json.encode_pair_int("prompt_tokens", n) + "," +
-              Tep::Json.encode_pair_int("total_tokens", n) +
+              SpinelKit::Json.encode_pair_int("prompt_tokens", n) + "," +
+              SpinelKit::Json.encode_pair_int("total_tokens", n) +
             "}" +
           "}"
         end