tep 0.11.2 → 0.11.4

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
@@ -94,6 +94,13 @@ module Tep
           "cpu"
         end
 
+        # owned_by value for each entry in the /v1/models list. Defaults
+        # to "tep"; a backend overrides to attribute models to its own
+        # project (e.g. toy returns "toy").
+        def model_owner
+          "tep"
+        end
+
         # Backends that can embed override this -> true (gates
         # /v1/embeddings, chunk 7.3).
         def supports_embeddings?
@@ -143,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)
@@ -178,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
@@ -201,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"`.
@@ -212,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
@@ -229,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
@@ -257,13 +264,35 @@ module Tep
       end
 
       # A backend's generation result: the decoded text + token usage.
+      #
+      # token_ids carries the GENERATED token IDs for an IDs-only backend
+      # (no detokenizer): when non-empty, CompletionsHandler emits them as
+      # choices[0].ids alongside text (which such a backend leaves ""),
+      # matching the "tokenize/detokenize client-side" serving contract.
+      # 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              = ""
           @prompt_tokens     = 0
           @completion_tokens = 0
+          # Typed-empty Array[Integer] seed (the [0]; delete_at(0) landmine
+          # pattern) so Spinel emits an IntArray slot, not poly.
+          @token_ids         = [0]
+          @token_ids.delete_at(0)
+          @finish_reason     = "stop"
+          @id                = "cmpl-tep"
         end
       end
 
@@ -292,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" +
             "}]" +
           "}"
@@ -340,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)
@@ -376,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" +
             "}]" +
@@ -396,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" +
             "}]" +
@@ -416,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")
@@ -459,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)
@@ -474,7 +503,9 @@ module Tep
       class ModelsHandler < Tep::Handler
         def handle(req, res)
           res.headers["Content-Type"] = "application/json"
-          models = Tep::APP.openai_backend.list_models
+          models  = Tep::APP.openai_backend.list_models
+          owner   = Tep::APP.openai_backend.model_owner
+          created = Time.now.to_i
           out = "{\"object\":\"list\",\"data\":["
           i = 0
           while i < models.length
@@ -482,9 +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_str("owned_by", "tep") +
+              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
@@ -501,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
@@ -557,27 +589,36 @@ 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
           )
 
+          # IDs-only backends (no detokenizer) carry the generated token
+          # IDs; emit them as choices[0].ids. Text backends leave token_ids
+          # empty and the field is omitted (standard OpenAI shape).
+          ids_frag = ""
+          if comp.token_ids.length > 0
+            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) + "," +
-              Tep::Json.encode_pair_str("finish_reason", "stop") +
+              SpinelKit::Json.encode_pair_int("index", 0) + "," +
+              SpinelKit::Json.encode_pair_str("text", comp.text) + "," +
+              ids_frag +
+              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
@@ -598,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
@@ -634,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
@@ -668,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
@@ -706,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

data/lib/tep/parser.rb

@@ -33,7 +33,7 @@ module Tep
       else
         req.path  = req.raw_path[0, qmark]
         qstring   = req.raw_path[qmark + 1, req.raw_path.length - qmark - 1]
-        req.query = Url.parse_query(qstring)
+        req.query = SpinelKit::Url.parse_query(qstring)
       end
 
       i = 1
@@ -63,7 +63,7 @@ module Tep
           if eq > 0
             cname  = pair[0, eq].strip
             cvalue = pair[eq + 1, pair.length - eq - 1].strip
-            req.cookies[cname] = Url.unescape(cvalue)
+            req.cookies[cname] = SpinelKit::Url.unescape(cvalue)
           end
         end
       end

data/lib/tep/presence.rb

@@ -211,21 +211,21 @@ module Tep
     end
 
     # Flat-JSON wire format for a diff event. `kind` is one of
-    # "join" / "leave" / "status". Tep::Json's flat-object
+    # "join" / "leave" / "status". SpinelKit::Json's flat-object
     # extractors handle this on the client side (or any
     # JSON-aware peer).
     def self.encode_diff(kind, entry)
       "{" +
-        Tep::Json.encode_pair_str("kind", kind) + "," +
-        Tep::Json.encode_pair_str("topic", entry.topic) + "," +
-        Tep::Json.encode_pair_str("principal", entry.principal_id) + "," +
-        Tep::Json.encode_pair_str("ekind", entry.kind.to_s) + "," +
-        Tep::Json.encode_pair_str("agent_id", entry.agent_id) + "," +
-        Tep::Json.encode_pair_int("fd", entry.fd) + "," +
-        Tep::Json.encode_pair_int("since", entry.since) + "," +
-        Tep::Json.encode_pair_str("state", entry.status_state.to_s) + "," +
-        Tep::Json.encode_pair_str("note", entry.status_note) + "," +
-        Tep::Json.encode_pair_int("until_ts", entry.status_until) +
+        SpinelKit::Json.encode_pair_str("kind", kind) + "," +
+        SpinelKit::Json.encode_pair_str("topic", entry.topic) + "," +
+        SpinelKit::Json.encode_pair_str("principal", entry.principal_id) + "," +
+        SpinelKit::Json.encode_pair_str("ekind", entry.kind.to_s) + "," +
+        SpinelKit::Json.encode_pair_str("agent_id", entry.agent_id) + "," +
+        SpinelKit::Json.encode_pair_int("fd", entry.fd) + "," +
+        SpinelKit::Json.encode_pair_int("since", entry.since) + "," +
+        SpinelKit::Json.encode_pair_str("state", entry.status_state.to_s) + "," +
+        SpinelKit::Json.encode_pair_str("note", entry.status_note) + "," +
+        SpinelKit::Json.encode_pair_int("until_ts", entry.status_until) +
       "}"
     end
 

data/lib/tep/proxy.rb

@@ -12,7 +12,7 @@
 #     end
 #
 #     def after_forward(req, ures, res)
-#       Tep::Logger.info("upstream " + ures.status.to_s)
+#       LOGGER.info("upstream " + ures.status.to_s)   # LOGGER = SpinelKit::Log.new
 #       0
 #     end
 #   end
@@ -246,7 +246,7 @@ module Tep
     # An LLM gateway typically overrides this as:
     #
     #   def stream_request?(req)
-    #     Tep::Json.get_bool(req.raw_body, "stream")
+    #     SpinelKit::Json.get_bool(req.raw_body, "stream")
     #   end
     def stream_request?(req)
       false
@@ -298,10 +298,10 @@ module Tep
         res.set_status(413)
         res.headers["Content-Type"] = "application/json"
         err_body = "{\"error\":{" +
-          Tep::Json.encode_pair_str("message",
+          SpinelKit::Json.encode_pair_str("message",
             "request body exceeds proxy cap of " +
             @max_request_body_bytes.to_s + " bytes") + "," +
-          Tep::Json.encode_pair_str("type", "payload_too_large") +
+          SpinelKit::Json.encode_pair_str("type", "payload_too_large") +
         "}}"
         res.set_body(err_body)
         return err_body
@@ -378,10 +378,10 @@ module Tep
         res.set_status(502)
         res.headers["Content-Type"] = "application/json"
         err_body = "{\"error\":{" +
-          Tep::Json.encode_pair_str("message",
+          SpinelKit::Json.encode_pair_str("message",
             "upstream response body exceeds proxy cap of " +
             @max_response_body_bytes.to_s + " bytes") + "," +
-          Tep::Json.encode_pair_str("type", "upstream_body_too_large") +
+          SpinelKit::Json.encode_pair_str("type", "upstream_body_too_large") +
         "}}"
         res.set_body(err_body)
         return err_body
@@ -424,7 +424,7 @@ module Tep
     # 502 and returns "" without starting a stream.
     def start_streaming_forward(req, res, ureq)
       url   = pick_upstream(req) + ureq.path
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       if parts["scheme"] != "http"
         res.set_status(502)
         return ""

data/lib/tep/request.rb

@@ -180,7 +180,7 @@ module Tep
     # @raw_body to Content-Length.
     def parse_form_body
       if form?
-        Url.parse_query(@raw_body).each do |k, v|
+        SpinelKit::Url.parse_query(@raw_body).each do |k, v|
           @params[k] = v
         end
       elsif multipart?

data/lib/tep/response.rb

@@ -88,7 +88,7 @@ module Tep
     # (path, expires, max-age, domain, samesite, httponly, secure).
     # Empty `opts` is fine: just writes "name=value".
     def set_cookie(name, value, opts)
-      line = name + "=" + Url.escape(value)
+      line = name + "=" + SpinelKit::Url.escape(value)
       if opts.length > 0
         opts.each do |k, v|
           if v.length == 0

data/lib/tep/router.rb

@@ -77,7 +77,7 @@ module Tep
         pp = pat[i]
         if pp.length > 0 && pp[0] == ":"
           name = @r_params[pi]
-          req.params[name] = Url.unescape(rp[i])
+          req.params[name] = SpinelKit::Url.unescape(rp[i])
           pi += 1
         end
         i += 1

data/lib/tep/session.rb

@@ -46,7 +46,7 @@ module Tep
       if !Tep.timing_safe_eq(sig, expect)
         return false
       end
-      Url.parse_query(payload).each do |k, v|
+      SpinelKit::Url.parse_query(payload).each do |k, v|
         @data[k] = v
       end
       true
@@ -61,7 +61,7 @@ module Tep
         if !first
           payload = payload + "&"
         end
-        payload = payload + Url.escape(k) + "=" + Url.escape(v)
+        payload = payload + SpinelKit::Url.escape(k) + "=" + SpinelKit::Url.escape(v)
         first = false
       end
       payload + "." + Crypto.sp_crypto_hmac_sha256_hex(secret, payload)

data/lib/tep/version.rb

@@ -1,3 +1,3 @@
 module Tep
-  VERSION = "0.11.2"
+  VERSION = "0.11.4"
 end