tep 0.11.0

data/test/test_llm.rb

@@ -0,0 +1,250 @@
+# Tests for Tep::Llm encode/parse via a live tep app. The app
+# exposes one route per test that exercises the corresponding
+# static method and returns the result as the body; the MRI test
+# side GETs each route + asserts on the body.
+#
+# Integration coverage (Tep::Llm.chat() pointed at a live OpenAI-
+# compatible backend) is the job of examples/chat/ once it lands
+# per OriPekelman/tep#10 -- that demo exercises the network path.
+require_relative "helper"
+
+class TestLlm < TepTest
+  # Single-quoted heredoc so the Phase B test bodies (which embed
+  # `\r\n` chunked-transfer terminators) pass through literally
+  # rather than getting interpreted as raw CR+LF at heredoc-parse
+  # time.
+  app_source <<~'RB'
+    require "sinatra"
+
+    get "/build_simple" do
+      msg = Tep::Llm::Message.new("user", "Hello!")
+      Tep::Llm.build_request_body("gpt-2", "", [msg])
+    end
+
+    get "/build_system" do
+      msg = Tep::Llm::Message.new("user", "Hi")
+      Tep::Llm.build_request_body("llama3", "You are concise.", [msg])
+    end
+
+    get "/build_multiturn" do
+      msgs = [
+        Tep::Llm::Message.new("user",      "What is 2+2?"),
+        Tep::Llm::Message.new("assistant", "4"),
+        Tep::Llm::Message.new("user",      "Now multiply by 3."),
+      ]
+      Tep::Llm.build_request_body("gpt-2", "", msgs)
+    end
+
+    get "/extract_simple" do
+      Tep::Llm.extract_str_field('{"foo":"bar","baz":"qux"}', "foo", 0)
+    end
+
+    get "/extract_missing" do
+      r = Tep::Llm.extract_str_field('{"foo":"bar"}', "missing", 0)
+      # Distinguish empty-string-found from empty-string-default;
+      # the empty-string-default case is what we want here.
+      r.length == 0 ? "MISSING" : "FOUND:" + r
+    end
+
+    get "/parse_openai_happy" do
+      fake = Tep::Http::Response.new
+      fake.status = 200
+      fake.body  = '{"choices":[{"index":0,' +
+                   '"message":{"role":"assistant","content":"Hello!"},' +
+                   '"finish_reason":"stop"}]}'
+      out = Tep::Llm.parse_response(fake)
+      out.content + "|" + out.role + "|" + out.stop_reason
+    end
+
+    get "/parse_transport_error" do
+      fake = Tep::Http::Response.new
+      fake.status = 0
+      out = Tep::Llm.parse_response(fake)
+      out.stop_reason
+    end
+
+    get "/parse_http_404" do
+      fake = Tep::Http::Response.new
+      fake.status = 404
+      fake.body   = '{"error":"not found"}'
+      out = Tep::Llm.parse_response(fake)
+      out.stop_reason
+    end
+
+    get "/client_setters" do
+      c = Tep::Llm.new("http://example.test")
+      c.set_model("m")
+      c.set_api_key("k")
+      c.set_system_prompt("p")
+      c.model + "|" + c.api_key + "|" + c.system_prompt
+    end
+
+    # --- Phase B: chunked decode + SSE event consume ---
+
+    get "/hex_to_int_valid" do
+      Tep::Llm.hex_to_int("ff").to_s + "|" +
+      Tep::Llm.hex_to_int("a").to_s  + "|" +
+      Tep::Llm.hex_to_int("100").to_s
+    end
+
+    get "/hex_to_int_invalid" do
+      Tep::Llm.hex_to_int("zz").to_s + "|" +
+      Tep::Llm.hex_to_int("").to_s
+    end
+
+    # One chunked body: 5 bytes "Hello", then last-chunk 0.
+    get "/dechunk_complete" do
+      s = "5\r\nHello\r\n0\r\n\r\n"
+      Tep::Llm.dechunk_consume(s)
+    end
+
+    # Two chunks in one buffer.
+    get "/dechunk_multiple" do
+      s = "3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n"
+      Tep::Llm.dechunk_consume(s)
+    end
+
+    # Partial body: chunk header present, but body bytes not all there.
+    # dechunk_consume returns the already-consumed portion ("");
+    # dechunk_leftover returns the still-pending tail.
+    get "/dechunk_partial" do
+      s = "5\r\nHel"
+      consumed = Tep::Llm.dechunk_consume(s)
+      leftover = Tep::Llm.dechunk_leftover(s)
+      "consumed=" + consumed.length.to_s + "|leftover=" + leftover
+    end
+
+    # consume_sse_events on a buffer with one delta + DONE marker.
+    # The mock stream just counts writes and records the last write.
+    get "/sse_one_delta_then_done" do
+      state = Tep::Llm::StreamState.new
+      state.leftover = "data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n" +
+                       "data: [DONE]\n\n"
+      sink = Tep::Stream.new(0)   # write goes to fd 0 (stdout); we
+                                   # only assert on state.acc + done
+      Tep::Llm.consume_sse_events(sink, state)
+      state.acc + "|done=" + (state.done ? "true" : "false")
+    end
+
+    # Partial: one full delta, then half of the next data: line.
+    # consume_sse_events should drain the full one + leave the rest.
+    get "/sse_partial_tail" do
+      state = Tep::Llm::StreamState.new
+      state.leftover = "data: {\"choices\":[{\"delta\":{\"content\":\"X\"}}]}\n\n" +
+                       "data: {\"choices\":[{\"delta\":{\"content\""
+      sink = Tep::Stream.new(0)
+      Tep::Llm.consume_sse_events(sink, state)
+      "acc=" + state.acc + "|done=" + (state.done ? "true" : "false") +
+        "|leftover_len=" + state.leftover.length.to_s
+    end
+
+    # finish_reason in a data line should set state.done.
+    get "/sse_finish_reason_ends" do
+      state = Tep::Llm::StreamState.new
+      state.leftover = "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n"
+      sink = Tep::Stream.new(0)
+      Tep::Llm.consume_sse_events(sink, state)
+      "done=" + (state.done ? "true" : "false")
+    end
+  RB
+
+  def test_build_simple_user_message
+    res = get("/build_simple")
+    assert_equal "200", res.code
+    assert_equal(
+      '{"model":"gpt-2","messages":[{"role":"user","content":"Hello!"}]}',
+      res.body
+    )
+  end
+
+  def test_build_with_system_prompt
+    res = get("/build_system")
+    assert_equal(
+      '{"model":"llama3","messages":[' \
+      '{"role":"system","content":"You are concise."},' \
+      '{"role":"user","content":"Hi"}' \
+      ']}',
+      res.body
+    )
+  end
+
+  def test_build_multi_turn
+    res = get("/build_multiturn")
+    assert_match(/"role":"user","content":"What is 2\+2\?"/,    res.body)
+    assert_match(/"role":"assistant","content":"4"/,             res.body)
+    assert_match(/"role":"user","content":"Now multiply by 3\."/, res.body)
+  end
+
+  def test_extract_str_field_simple
+    res = get("/extract_simple")
+    assert_equal "bar", res.body
+  end
+
+  def test_extract_str_field_missing_returns_empty
+    res = get("/extract_missing")
+    assert_equal "MISSING", res.body
+  end
+
+  def test_parse_response_openai_happy_path
+    res = get("/parse_openai_happy")
+    assert_equal "Hello!|assistant|stop", res.body
+  end
+
+  def test_parse_response_transport_failure
+    res = get("/parse_transport_error")
+    assert_equal "error", res.body
+  end
+
+  def test_parse_response_http_404
+    res = get("/parse_http_404")
+    assert_equal "http_404", res.body
+  end
+
+  def test_client_setters_round_trip
+    res = get("/client_setters")
+    assert_equal "m|k|p", res.body
+  end
+
+  # --- Phase B: chunked + SSE primitives ---
+
+  def test_hex_to_int_valid
+    res = get("/hex_to_int_valid")
+    assert_equal "255|10|256", res.body
+  end
+
+  def test_hex_to_int_malformed_returns_neg_one
+    res = get("/hex_to_int_invalid")
+    assert_equal "-1|-1", res.body
+  end
+
+  def test_dechunk_complete_single_chunk
+    res = get("/dechunk_complete")
+    assert_equal "Hello", res.body
+  end
+
+  def test_dechunk_complete_multiple_chunks
+    res = get("/dechunk_multiple")
+    assert_equal "foobar", res.body
+  end
+
+  def test_dechunk_partial_tail_left_for_next_recv
+    res = get("/dechunk_partial")
+    # No full chunk yet -- consumed empty, leftover holds the full tail.
+    assert_equal "consumed=0|leftover=5\r\nHel", res.body
+  end
+
+  def test_sse_one_delta_then_done_sets_done
+    res = get("/sse_one_delta_then_done")
+    assert_equal "Hello|done=true", res.body
+  end
+
+  def test_sse_partial_tail_preserved_for_next_recv
+    res = get("/sse_partial_tail")
+    assert_match(/^acc=X\|done=false\|leftover_len=\d+/, res.body)
+  end
+
+  def test_sse_finish_reason_terminates_stream
+    res = get("/sse_finish_reason_ends")
+    assert_equal "done=true", res.body
+  end
+end

data/test/test_llm_gateway.rb

@@ -0,0 +1,95 @@
+require_relative "helper"
+require "json"
+
+# examples/llm_gateway integration: a Tep::Proxy that streams an SSE
+# upstream through to the client AND emits one toy/v1 inference event
+# at end-of-stream via Tep::Events. Self-contained (self-call SSE
+# upstream, like test_proxy_streaming): proves proxy streaming +
+# Tep::Events compose -- the chunk-6.3 payoff.
+#
+# The example app itself uses the block DSL; here the gateway is the
+# subclass-override form so it can be built per-request with the
+# harness's runtime port (block-DSL proxies construct at load time,
+# before the port is known -- same reason test_proxy_streaming uses
+# in-handler construction).
+class TestLlmGateway < TepTest
+  EV_PATH = "/tmp/tep_gateway_test.jsonl"
+
+  app_source <<~RB
+    require 'sinatra'
+
+    set :scheduler, :scheduled
+    set :workers, 1
+
+    PATH = "#{EV_PATH}"
+    EVENTS = Tep::Events.new(PATH)
+
+    # Upstream: an OpenAI-shaped streaming chat completion.
+    class ChatSse < Tep::Streamer
+      def pump(out)
+        out.write("data: {\\"choices\\":[{\\"delta\\":{\\"content\\":\\"He\\"}}]}\\n\\n")
+        out.write("data: {\\"choices\\":[{\\"delta\\":{\\"content\\":\\"llo\\"}}]}\\n\\n")
+        out.write("data: [DONE]\\n\\n")
+      end
+    end
+
+    post '/v1/upstream' do
+      res.headers["Content-Type"] = "text/event-stream"
+      stream ChatSse.new
+    end
+
+    # The gateway: stream through + emit one inference event at end.
+    class Gateway < Tep::Proxy
+      def rewrite_path(path)
+        "/v1/upstream"
+      end
+      def stream_request?(req)
+        true
+      end
+      def on_stream_chunk(chunk, out, stats)
+        out.write(chunk.chunk_text)
+        0
+      end
+      def on_stream_end(req, out, stats)
+        model = Tep::Json.get_str(req.raw_body, "model")
+        extra = "{" + Tep::Json.encode_pair_str("request_id", "req-1") + "}"
+        EVENTS.inference(model, 0, stats.chunk_count, 1000000, extra)
+        0
+      end
+    end
+
+    post '/gw/:port' do
+      File.write(PATH, "")
+      Gateway.new("http://127.0.0.1:" + params[:port]).handle(req, res)
+      res.body
+    end
+
+    get '/events' do
+      File.read(PATH)
+    end
+  RB
+
+  def test_streams_upstream_through_gateway
+    res = post("/gw/#{@port}", "{\"model\":\"demo-llm\",\"stream\":true}")
+    assert_equal "200", res.code
+    # The three upstream SSE events pass through unchanged.
+    assert_equal "data: {\"choices\":[{\"delta\":{\"content\":\"He\"}}]}\n\n" \
+                 "data: {\"choices\":[{\"delta\":{\"content\":\"llo\"}}]}\n\n" \
+                 "data: [DONE]\n\n", res.body
+  end
+
+  def test_emits_one_inference_event
+    post("/gw/#{@port}", "{\"model\":\"demo-llm\",\"stream\":true}")
+    lines = get("/events").body.split("\n").reject(&:empty?)
+    assert_equal 1, lines.length, "expected exactly one inference event"
+    ev = JSON.parse(lines[0])
+    # toy/v1 inference shape (migrated in #136): kind "eval", name
+    # "request", and model/token fields nested under "extra".
+    assert_equal "eval", ev["kind"]
+    assert_equal "serve", ev["phase"]
+    assert_equal "request", ev["name"]
+    assert_equal "demo-llm", ev["extra"]["model"]
+    assert_equal 3, ev["extra"]["completion_tokens"]   # 3 SSE events dispatched
+    assert_equal "req-1", ev["extra"]["request_id"]
+  end
+end

data/test/test_logger.rb

@@ -0,0 +1,101 @@
+require_relative "helper"
+
+# Tep::Logger -- levelled logger with stderr / file output.
+class TestLogger < TepTest
+  TMP_LOG = "/tmp/tep_logger_test_#{$$}.log"
+
+  app_source <<~RB
+    require 'sinatra'
+
+    LOGGER = Tep::Logger.new
+    LOGGER.set_level("debug")
+    LOGGER.to_file("#{TMP_LOG}")
+
+    before do
+      LOGGER.info(req.verb + " " + req.path)
+    end
+
+    get '/dbg' do
+      LOGGER.debug("dbg-line")
+      "ok"
+    end
+
+    get '/info' do
+      LOGGER.info("info-line")
+      "ok"
+    end
+
+    get '/warn' do
+      LOGGER.warn("warn-line")
+      "ok"
+    end
+
+    get '/err' do
+      LOGGER.error("err-line")
+      "ok"
+    end
+
+    get '/clear' do
+      File.write("#{TMP_LOG}", "")
+      "cleared"
+    end
+
+    # Toggle level at runtime.
+    get '/level/:lvl' do
+      LOGGER.set_level(params[:lvl])
+      "level=" + params[:lvl]
+    end
+  RB
+
+  Minitest.after_run do
+    File.unlink(TMP_LOG) if File.exist?(TMP_LOG)
+  end
+
+  def read_log
+    File.exist?(TMP_LOG) ? File.read(TMP_LOG) : ""
+  end
+
+  def clear_log
+    get("/clear")
+  end
+
+  def setup
+    super
+    # Tests run in randomised order against a single booted app
+    # that shares LOGGER state. Reset level + clear log per test.
+    get("/level/debug")
+    clear_log
+  end
+
+  def test_each_level_writes_a_line
+    get("/dbg")
+    get("/info")
+    get("/warn")
+    get("/err")
+    log = read_log
+    assert_match(/\[debug\] dbg-line/, log)
+    assert_match(/\[info\] info-line/, log)
+    assert_match(/\[warn\] warn-line/, log)
+    assert_match(/\[error\] err-line/, log)
+  end
+
+  def test_level_filter_drops_below_threshold
+    get("/level/warn")
+    clear_log    # drop the "/level/warn" before-filter line too
+    get("/dbg")
+    get("/info")
+    get("/warn")
+    get("/err")
+    log = read_log
+    refute_match(/\[debug\]/, log)
+    refute_match(/\[info\]/, log)
+    assert_match(/\[warn\] warn-line/, log)
+    assert_match(/\[error\] err-line/, log)
+  end
+
+  def test_format_includes_unix_timestamp
+    get("/info")
+    log = read_log
+    assert_match(/\A\[\d+\] \[info\]/, log)
+  end
+end

data/test/test_maidenhead_example.rb

@@ -0,0 +1,86 @@
+require "minitest/autorun"
+require "net/http"
+require "socket"
+require "tmpdir"
+require "fileutils"
+
+# Companion to test_geohash_example.rb, but for the example whose ENTIRE
+# gem API compiles: examples/maidenhead/app.rb runs on the unmodified
+# published maidenhead 1.0.1 gem (MIT), vendored + require_relative'd.
+# Every route is checked against CRuby's Maidenhead.* output. Builds the
+# real example in place so the relative require_relative resolves.
+class TestMaidenheadExample < Minitest::Test
+  TEP_BIN = File.expand_path("../bin/tep", __dir__)
+  APP     = File.expand_path("../examples/maidenhead/app.rb", __dir__)
+  EX_DIR  = File.dirname(APP)
+
+  # The gem source under vendor/spinel is generated from the Gemfile.lock
+  # by bundler-spinel (`spinel-compat vendor`), not committed. Regenerate
+  # it before building; skip cleanly if spinelgems isn't reachable (e.g.
+  # the suite run outside the dev container, which mounts /spinelgems).
+  def ensure_vendored
+    deps = File.join(EX_DIR, "vendor", "spinel", "deps.rb")
+    return if File.exist?(deps)
+    sg = ENV["SPINELGEMS"] || "/spinelgems"
+    skip "spinelgems not at #{sg}; run `make vendor-examples`" unless File.directory?(File.join(sg, "exe"))
+    out = `cd #{EX_DIR} && ruby -I #{sg}/lib #{sg}/exe/spinel-compat vendor 2>&1`
+    skip "spinel-compat vendor failed (offline?):\n#{out}" unless $?.success? && File.exist?(deps)
+  end
+
+  def setup
+    ensure_vendored
+    @tmp  = Dir.mktmpdir("tep-maidenhead")
+    @bin  = File.join(@tmp, "maidenhead")
+    out   = `#{TEP_BIN} build #{APP} -o #{@bin} 2>&1`
+    raise "maidenhead example build failed:\n#{out}" unless $?.success? && File.executable?(@bin)
+    @port = 4960 + (Process.pid % 80)
+    @log  = File.join(@tmp, "app.log")
+    @pid  = Process.spawn(@bin, "-p", @port.to_s, out: @log, err: [:child, :out], pgroup: true)
+    wait_for_port(@port)
+  end
+
+  def teardown
+    if @pid
+      Process.kill("TERM", -@pid) rescue nil
+      Process.wait(@pid) rescue nil
+    end
+    FileUtils.remove_entry(@tmp) if @tmp && File.directory?(@tmp)
+  end
+
+  def wait_for_port(port, timeout: 10.0)
+    deadline = Time.now + timeout
+    while Time.now < deadline
+      begin
+        TCPSocket.new("127.0.0.1", port).close
+        return
+      rescue
+        sleep 0.05
+      end
+    end
+    raise "maidenhead app never bound :#{port}\n#{File.read(@log) rescue ''}"
+  end
+
+  def get(path)
+    Net::HTTP.get_response(URI("http://127.0.0.1:#{@port}#{path}")).body
+  end
+
+  def test_valid_true
+    assert_equal "true", get("/valid?loc=FN31pr")
+  end
+
+  def test_valid_false
+    assert_equal "false", get("/valid?loc=invalid")
+  end
+
+  def test_to_latlon
+    assert_equal "41.731076,-72.704514", get("/to_latlon?loc=FN31pr")
+  end
+
+  def test_to_grid_precision_3
+    assert_equal "FN20xr", get("/to_grid?lat=40.7128&lon=-74.0060&precision=3")
+  end
+
+  def test_to_grid_precision_2
+    assert_equal "IO91", get("/to_grid?lat=51.5074&lon=-0.1278&precision=2")
+  end
+end