vangrail 0.1.0 → 0.3.0

data/lib/vangrail/client.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'client/completion'
+require_relative 'client/turn'
 require_relative 'errors'
 require_relative 'http'
 require_relative 'result'
@@ -23,7 +23,11 @@ module Vangrail
     COMPLETIONS_PATH = '/v1/chat/completions'
     PROTOCOLS = %i[auto nested flat].freeze
 
-    RAIL_VARS = [Completion::INPUT_RAIL_VAR, Completion::OUTPUT_RAIL_VAR].freeze
+    RAIL_VARS = [Turn::INPUT_RAIL_VAR, Turn::OUTPUT_RAIL_VAR].freeze
+
+    # One guarded completion's arguments, so the wire methods take one value.
+    Request = Struct.new(:messages, :config_id, :config_ids, :options, :context,
+                         :thread_id, :model, :extra, keyword_init: true)
 
     attr_reader :config_id, :model, :protocol, :http
 
@@ -31,9 +35,12 @@ module Vangrail
     # of those happens, so a caller can report "not yet known" honestly.
     attr_reader :checks_supported
 
-    def initialize(base_url:, config_id: nil, model: nil, api_key: nil, protocol: :auto,
-                   open_timeout: HTTP::DEFAULT_OPEN_TIMEOUT, read_timeout: HTTP::DEFAULT_READ_TIMEOUT,
-                   http: nil)
+    # The 0.1.0 name. Prefer Turn in new code.
+    Completion = Turn
+
+    def initialize(http: nil, base_url: nil, config_id: nil, model: nil, api_key: nil,
+                   protocol: :auto, open_timeout: HTTP::DEFAULT_OPEN_TIMEOUT,
+                   read_timeout: HTTP::DEFAULT_READ_TIMEOUT)
       unless PROTOCOLS.include?(protocol)
         raise ArgumentError,
               "protocol must be one of #{PROTOCOLS.join(', ')}"
@@ -43,10 +50,9 @@ module Vangrail
       @model = model
       @protocol = protocol
       @checks_supported = nil
-      @http = http || HTTP.new(
-        base_url: base_url, api_key: api_key,
-        open_timeout: open_timeout, read_timeout: read_timeout
-      )
+      @http = HTTP.build(http: http, base_url: base_url, api_key: api_key,
+                         open_timeout: open_timeout, read_timeout: read_timeout,
+                         missing: 'a Client needs a base_url or an http client')
     end
 
     def base_url
@@ -93,10 +99,13 @@ module Vangrail
     # answer as well as checking it.
     def chat(messages:, config_id: nil, config_ids: nil, options: nil, context: nil,
              thread_id: nil, model: nil, **extra)
-      opts = merge_options(options)
-      body = extra.merge(messages: normalize(messages))
-      chosen = { config_id: config_id || @config_id, config_ids: config_ids }
-      Completion.new(send_payload(body, chosen, opts, context, thread_id, model))
+      request = Request.new(messages: messages, config_id: config_id, config_ids: config_ids,
+                            options: options, context: context, thread_id: thread_id,
+                            model: model, extra: extra)
+      opts = merge_options(request.options)
+      body = request.extra.merge(messages: normalize(request.messages))
+      chosen = { config_id: request.config_id || @config_id, config_ids: request.config_ids }
+      Turn.new(send_payload(body, chosen, opts, request.context, request.thread_id, request.model))
     end
 
     private
@@ -115,16 +124,17 @@ module Vangrail
         raise ProtocolError, "/v1/checks answered status #{status.inspect}"
       end
 
+      certain = body.key?('certain') ? body['certain'] : true
       Result.new(status: status.to_sym, rail: body['rail'] || rail.to_s,
-                 content: body['content'], raw: body)
+                 content: body['content'], raw: body, certain: certain)
     end
 
-    def from_completion(completion, rail)
-      return Result.passed(rail: rail.to_s, raw: completion.raw) if completion.allowed?
+    def from_completion(turn, rail)
+      return Result.passed(rail: rail.to_s, raw: turn.raw) if turn.allowed?
 
-      reason = completion.triggered_rail || completion.stopped_rails.first&.dig('name')
-      Result.blocked(rail: reason || rail.to_s, content: completion.content, reason: reason,
-                     raw: completion.raw)
+      reason = turn.triggered_rail || turn.stopped_rails.first&.dig('name')
+      Result.blocked(rail: reason || rail.to_s, content: turn.content, reason: reason,
+                     raw: turn.raw)
     end
 
     def check_options(rail)

data/lib/vangrail/colang/ast.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../errors'
+
 module Vangrail
   module Colang
     # The whole grammar this gem executes, as data. Everything the parser can
@@ -23,14 +25,38 @@ module Vangrail
         Program.new(
           flows: flows.merge(other.flows),
           bot_messages: bot_messages.merge(other.bot_messages),
-          user_messages: user_messages.merge(other.user_messages)
+          user_messages: user_messages.merge(other.user_messages),
         )
       end
+
+      # Every `bot <name>` in every flow has a `define bot`. The walk covers
+      # unreached `if` branches and flows no config names: a half-loaded
+      # guardrail must not load, so a dead-branch bot in a merged `.co` file
+      # fails the folder. Called after parse/merge, not during parse, so a
+      # bot defined in another file is visible once the programs are joined.
+      def check!
+        flows.each { |name, flow| check_body(flow.body, name) }
+        self
+      end
+
+      def check_body(body, flow_name)
+        Array(body).each do |node|
+          case node
+          when Bot
+            next if bot_message(node.message)
+
+            raise ColangError, "no `define bot #{node.message}` for flow #{flow_name.inspect}"
+          when If
+            check_body(node.then_body, flow_name)
+            check_body(node.else_body, flow_name)
+          end
+        end
+      end
     end
 
     Flow = Struct.new(:name, :body, :subflow, keyword_init: true)
 
-    # $var = execute action(key="value")
+    # $var = <value>
     Assign = Struct.new(:variable, :expression, keyword_init: true)
 
     # execute action(key="value")
@@ -44,7 +70,7 @@ module Vangrail
 
     If = Struct.new(:condition, :then_body, :else_body, keyword_init: true)
 
-    # Conditions
+    # Values
     Var = Struct.new(:name, keyword_init: true)
     Not = Struct.new(:expression, keyword_init: true)
     Compare = Struct.new(:left, :operator, :right, keyword_init: true)

data/lib/vangrail/colang/interpreter.rb

@@ -10,62 +10,55 @@ module Vangrail
     # The mapping onto rail statuses is the whole design:
     #
     #   `bot <message>` then `stop`     -> blocked, with the message as content
-    #   assignment to $user_message or
-    #   $bot_message                    -> modified, with the new value
+    #   a change to a content binding   -> modified, with the new value
     #   falls off the end               -> passed
     #
+    # `$user_input` is a rewrite alias of `$user_message`; `$bot_response` is
+    # a rewrite alias of `$bot_message`. Input and context seed the user pair
+    # from the turn text; output seeds the bot pair. The other pair is left
+    # unset so an output flow that reads `$user_message` is not reading the
+    # answer unless the caller put it there.
+    #
     # A `stop` without a preceding `bot` still blocks; it just has no refusal
     # text to show. Actions are plain Ruby callables, so the flow decides the
     # control shape and Ruby does the work.
     class Interpreter
-      # Variables a flow assigns to when it rewrites the turn rather than
-      # refusing it, matching the names the toolkit's own flows use.
+      # The four names a flow assigns to when it rewrites the turn. Order is
+      # the last-write winner when more than one of them changed.
       CONTENT_VARS = %w[user_message bot_message user_input bot_response].freeze
 
       Outcome = Struct.new(:status, :content, :reason, :variables, keyword_init: true)
 
-      # Raised through the interpreter to unwind a flow on `stop`.
-      class Stopped < StandardError
-        attr_reader :message_text
-
-        def initialize(message_text)
-          @message_text = message_text
-          super('flow stopped')
-        end
-      end
-
       attr_reader :program, :actions
 
       def initialize(program:, actions:)
-        @program = program
+        @program = program.check!
         @actions = actions
       end
 
       def run(flow_name, context = {})
         flow = program.flow(flow_name)
-        raise UnknownAction, "no flow named #{flow_name.inspect}" unless flow
-
-        state = { 'context' => context }
-        last_bot = nil
-        begin
-          last_bot = execute(flow.body, state, context)
-        rescue Stopped => e
-          return Outcome.new(status: :blocked, content: e.message_text, reason: flow_name, variables: state)
-        end
+        raise ColangError, "no flow named #{flow_name.inspect}" unless flow
+
+        seeds = seed_bindings(context)
+        state = { 'context' => context }.merge(seeds)
+        result = execute(flow.body, state, context)
+        return stop_outcome(result.last, flow_name, state) if stop_tag?(result)
 
-        rewrite = CONTENT_VARS.filter_map { |v| state[v] if state.key?(v) }.last
+        rewrite = rewritten_content(state, seeds)
         if rewrite
           return Outcome.new(status: :modified, content: rewrite.to_s, reason: flow_name,
                              variables: state)
         end
 
-        Outcome.new(status: :passed, content: last_bot, reason: nil, variables: state)
+        Outcome.new(status: :passed, content: result, reason: nil, variables: state)
       end
 
       private
 
       # Returns the text of the last `bot` statement reached, so a flow that
-      # says something without stopping still hands that text back.
+      # says something without stopping still hands that text back. `stop`
+      # returns `[:stop, said]` rather than raising.
       def execute(body, state, context)
         said = nil
         body.each do |node|
@@ -73,14 +66,45 @@ module Vangrail
           when Assign then state[node.variable] = evaluate(node.expression, state, context)
           when Execute then evaluate(node, state, context)
           when Bot then said = bot_text(node.message)
-          when Stop then raise Stopped, said
-          when If then said = branch(node, state, context) || said
+          when Stop then return [:stop, said]
+          when If
+            result = branch(node, state, context)
+            return result if stop_tag?(result)
+
+            said = result || said
           else raise ColangError, "cannot execute #{node.class}"
           end
         end
         said
       end
 
+      def stop_tag?(result)
+        result.is_a?(Array) && result.first == :stop
+      end
+
+      def stop_outcome(content, flow_name, state)
+        Outcome.new(status: :blocked, content: content, reason: flow_name, variables: state)
+      end
+
+      def seed_bindings(context)
+        text = context[:text]
+        if context[:side] == :output
+          { 'bot_message' => text, 'bot_response' => text }
+        else
+          { 'user_message' => text, 'user_input' => text }
+        end
+      end
+
+      def rewritten_content(state, seeds)
+        rewritten = CONTENT_VARS.filter_map do |name|
+          next unless state.key?(name)
+          next if seeds.key?(name) && state[name] == seeds[name]
+
+          state[name]
+        end
+        rewritten.last
+      end
+
       def branch(node, state, context)
         taken = truthy?(evaluate(node.condition, state, context)) ? node.then_body : node.else_body
         execute(Array(taken), state, context)
@@ -107,13 +131,13 @@ module Vangrail
         action = actions[node.action]
         raise UnknownAction, "no action registered for #{node.action.inspect}" unless action
 
-        args = node.arguments.transform_values { |v| v.is_a?(Var) ? state[v.name] : v }
+        args = node.arguments.transform_values { |v| evaluate(v, state, context) }
         action.call(args, context)
       end
 
       def bot_text(message)
         alternatives = program.bot_message(message)
-        raise UnknownAction, "no `define bot #{message}` for this flow" unless alternatives
+        raise ColangError, "no `define bot #{message}` for this flow" unless alternatives
 
         # Deterministic: a guardrail refusal that varies between runs makes an
         # incident report harder to read for no benefit.

data/lib/vangrail/colang/parser.rb

@@ -2,6 +2,7 @@
 
 require_relative '../errors'
 require_relative 'ast'
+require_relative 'value_parser'
 
 module Vangrail
   module Colang
@@ -22,8 +23,13 @@ module Vangrail
     # matching quietly missing: a guardrail that half-loads is a guardrail that
     # reports checks it is not running.
     #
-    # Indentation defines blocks. Tabs are refused, because a file mixing tabs
-    # and spaces would otherwise parse into a different program than it looks.
+    # Indentation defines blocks. A tab anywhere in the indent run is refused,
+    # because a file mixing tabs and spaces would otherwise parse into a
+    # different program than it looks.
+    #
+    # Assignments, `if` conditions, and action arguments share one value
+    # grammar: string, int, and bool literals, `$vars`, `execute`, `not`, and
+    # `==` / `!=`.
     class Parser
       Line = Struct.new(:indent, :text, :number, keyword_init: true)
 
@@ -51,7 +57,8 @@ module Vangrail
       def significant_lines
         @source.lines.each_with_index.filter_map do |raw, i|
           number = i + 1
-          raise error('tabs are not allowed in Colang indentation', number) if raw.start_with?("\t")
+          indent_run = raw[/\A[ \t]*/]
+          raise error('tabs are not allowed in Colang indentation', number) if indent_run.include?("\t")
 
           text = raw.rstrip
           stripped = text.strip
@@ -107,10 +114,13 @@ module Vangrail
         line = lines[index]
         case line.text
         when /\A\$(\w+)\s*=\s*(.+)\z/
-          [Assign.new(variable: Regexp.last_match(1), expression: expression(Regexp.last_match(2), line)),
+          [Assign.new(variable: Regexp.last_match(1), expression: value(Regexp.last_match(2), line)),
            index + 1]
-        when /\Aexecute\s+(.+)\z/
-          [action_call(Regexp.last_match(1), line), index + 1]
+        when /\Aexecute\s+/
+          node = value(line.text, line)
+          raise error("unsupported statement #{line.text.inspect}", line.number) unless node.is_a?(Execute)
+
+          [node, index + 1]
         when /\Abot\s+(.+)\z/
           [Bot.new(message: Regexp.last_match(1).strip), index + 1]
         when /\Astop\z/
@@ -127,7 +137,7 @@ module Vangrail
       end
 
       def conditional(lines, index, line, condition_text)
-        condition = condition(condition_text, line)
+        condition = value(condition_text, line)
         then_lines, index = block(lines, index + 1, line.indent)
         else_lines = []
         if index < lines.length && lines[index].text == 'else' && lines[index].indent == line.indent
@@ -137,60 +147,8 @@ module Vangrail
          index]
       end
 
-      def expression(text, line)
-        return action_call(Regexp.last_match(1), line) if text =~ /\Aexecute\s+(.+)\z/
-        return Literal.new(value: unquote(text)) if quoted?(text)
-        return Var.new(name: Regexp.last_match(1)) if text =~ /\A\$(\w+)\z/
-
-        raise error("unsupported expression #{text.inspect}", line.number)
-      end
-
-      def action_call(text, line)
-        name, args = text.match(/\A([\w.]+)\s*(?:\((.*)\))?\s*\z/)&.captures
-        raise error("unsupported action call #{text.inspect}", line.number) unless name
-
-        Execute.new(action: name, arguments: arguments(args, line))
-      end
-
-      # key="value", key=$var, key=42. Positional arguments are refused: an
-      # action here is a Ruby method taking a keyword hash.
-      def arguments(text, line)
-        return {} if text.nil? || text.strip.empty?
-
-        text.split(/,(?=(?:[^"]*"[^"]*")*[^"]*\z)/).to_h do |pair|
-          key, value = pair.split('=', 2).map { |s| s.to_s.strip }
-          raise error("argument #{pair.inspect} needs a name", line.number) if value.nil? || key.empty?
-
-          [key, argument_value(value, line)]
-        end
-      end
-
-      def argument_value(value, line)
-        return unquote(value) if quoted?(value)
-        return Var.new(name: Regexp.last_match(1)) if value =~ /\A\$(\w+)\z/
-        return value.to_i if value.match?(/\A-?\d+\z/)
-        return true if %w[True true].include?(value)
-        return false if %w[False false].include?(value)
-
-        raise error("unsupported argument value #{value.inspect}", line.number)
-      end
-
-      def condition(text, line)
-        text = text.strip
-        return Not.new(expression: condition(Regexp.last_match(1), line)) if text =~ /\Anot\s+(.+)\z/
-        if text =~ /\A(.+?)\s*(==|!=)\s*(.+)\z/
-          return Compare.new(
-            left: condition(Regexp.last_match(1), line),
-            operator: Regexp.last_match(2),
-            right: condition(Regexp.last_match(3), line)
-          )
-        end
-        return Var.new(name: Regexp.last_match(1)) if text =~ /\A\$(\w+)\z/
-        return Literal.new(value: unquote(text)) if quoted?(text)
-        return Literal.new(value: true) if %w[True true].include?(text)
-        return Literal.new(value: false) if %w[False false].include?(text)
-
-        raise error("unsupported condition #{text.inspect}", line.number)
+      def value(text, line)
+        ValueParser.parse(text, line, method(:error))
       end
 
       def strings(lines)

data/lib/vangrail/colang/value_parser.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'ast'
+
+module Vangrail
+  module Colang
+    # One grammar for assign RHS, `if` conditions, and action arguments.
+    #
+    # Strings are tokenized before `==` / `!=` is considered, so
+    # `"a == b" == $x` is a compare of a literal against a variable.
+    class ValueParser
+      def self.parse(text, line, error)
+        new(text, line, error).parse
+      end
+
+      def initialize(text, line, error)
+        @text = text
+        @line = line
+        @error = error
+      end
+
+      def parse
+        tokens = tokenize
+        node, index = parse_value(tokens, 0)
+        raise fail_value(@text) unless tokens[index][0] == :eof
+
+        node
+      end
+
+      private
+
+      def tokenize
+        tokens = []
+        index = 0
+        while index < @text.length
+          if @text[index] == ' '
+            index += 1
+          else
+            token, index = next_token(index)
+            tokens << token
+          end
+        end
+        tokens << [:eof]
+        tokens
+      end
+
+      def next_token(index)
+        char = @text[index]
+        if char == '"' || char == "'"
+          read_string(index)
+        elsif char == '$' && (name = @text[(index + 1)..][/\A\w+/])
+          [[:var, name], index + 1 + name.length]
+        elsif @text[index, 2] == '=='
+          [[:eqeq, '=='], index + 2]
+        elsif @text[index, 2] == '!='
+          [[:neq, '!='], index + 2]
+        elsif char == '='
+          [[:eq, '='], index + 1]
+        elsif char == '('
+          [[:lparen], index + 1]
+        elsif char == ')'
+          [[:rparen], index + 1]
+        elsif char == ','
+          [[:comma], index + 1]
+        elsif (num = @text[index..][/\A-?\d+/])
+          [[:int, num.to_i], index + num.length]
+        elsif (word = @text[index..][/\A[\w.]+/])
+          [[:ident, word], index + word.length]
+        else
+          raise fail_value(@text)
+        end
+      end
+
+      def read_string(start)
+        quote = @text[start]
+        index = start + 1
+        while index < @text.length
+          return [[:string, unquote(@text[start..index])], index + 1] if @text[index] == quote
+
+          index += @text[index] == '\\' && index + 1 < @text.length ? 2 : 1
+        end
+        raise @error.call("unterminated string in #{@text.inspect}", @line.number)
+      end
+
+      def parse_value(tokens, index)
+        tok = tokens[index]
+        if tok[0] == :ident && tok[1] == 'not'
+          expr, index = parse_value(tokens, index + 1)
+          return [Not.new(expression: expr), index]
+        end
+
+        left, index = parse_atom(tokens, index)
+        op = tokens[index]
+        return [left, index] unless %i[eqeq neq].include?(op[0])
+
+        right, index = parse_value(tokens, index + 1)
+        [Compare.new(left: left, operator: op[1], right: right), index]
+      end
+
+      def parse_atom(tokens, index)
+        tok = tokens[index]
+        case tok[0]
+        when :string then [Literal.new(value: tok[1]), index + 1]
+        when :int then [Literal.new(value: tok[1]), index + 1]
+        when :var then [Var.new(name: tok[1]), index + 1]
+        when :ident
+          word = tok[1]
+          return parse_execute(tokens, index + 1) if word == 'execute'
+          return [Literal.new(value: true), index + 1] if %w[True true].include?(word)
+          return [Literal.new(value: false), index + 1] if %w[False false].include?(word)
+
+          raise fail_value(word)
+        else
+          raise fail_value(tok)
+        end
+      end
+
+      # execute name / execute name(key=value, ...). Positional arguments
+      # are refused: an action here is a Ruby method taking a keyword hash.
+      def parse_execute(tokens, index)
+        name_tok = tokens[index]
+        raise fail_value(name_tok) unless name_tok[0] == :ident
+
+        name = name_tok[1]
+        index += 1
+        return [Execute.new(action: name, arguments: {}), index] unless tokens[index][0] == :lparen
+
+        args, index = parse_arguments(tokens, index + 1)
+        [Execute.new(action: name, arguments: args), index]
+      end
+
+      def parse_arguments(tokens, index)
+        return [{}, index + 1] if tokens[index][0] == :rparen
+
+        args = {}
+        loop do
+          key = tokens[index]
+          unless key[0] == :ident && tokens[index + 1][0] == :eq
+            raise @error.call("argument #{key[1].inspect} needs a name", @line.number)
+          end
+
+          val, index = parse_value(tokens, index + 2)
+          args[key[1]] = val
+          case tokens[index][0]
+          when :comma then index += 1
+          when :rparen then return [args, index + 1]
+          else raise fail_value(@text)
+          end
+        end
+      end
+
+      def unquote(text)
+        text[1..-2].gsub('\\"', '"').gsub("\\'", "'")
+      end
+
+      def fail_value(what)
+        @error.call("unsupported value #{what.inspect}", @line.number)
+      end
+    end
+  end
+end

data/lib/vangrail/completion.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'http'
+
+module Vangrail
+  # The other OpenAI-compatible endpoint: /completions, asked to score text
+  # rather than to write any.
+  #
+  # It exists for one job. A chat endpoint returns what a model would say next
+  # and never says how surprising the text it was given was, and that number is
+  # what the published perplexity detectors are built on. The legacy completions
+  # endpoint answers it directly: echo the prompt, generate nothing, and return
+  # the log probability the model assigned each token of it.
+  #
+  # Support is genuinely uneven. Local servers built on llama.cpp and vLLM
+  # answer it; several hosted APIs removed the endpoint, and a proxy in front of
+  # a chat-only model cannot synthesise it. So `supported?` is a question worth
+  # asking rather than an assumption, and everything here raises ProtocolError
+  # rather than inventing a score when the fields are missing. A rail reading
+  # this turns that into an uncertain result, which is the truth: the check did
+  # not run.
+  class Completion
+    PATH = '/completions'
+
+    attr_reader :model, :http
+
+    def initialize(model:, http: nil, base_url: nil, api_key: nil,
+                   open_timeout: HTTP::DEFAULT_OPEN_TIMEOUT,
+                   read_timeout: HTTP::DEFAULT_READ_TIMEOUT)
+      @model = model
+      @http = HTTP.build(http: http, base_url: base_url, api_key: api_key,
+                         open_timeout: open_timeout, read_timeout: read_timeout,
+                         missing: 'a Completion needs a base_url or an http client')
+    end
+
+    # The log probability of each token of `text`, under this model.
+    #
+    # The first token has none, by construction: nothing preceded it. It is
+    # dropped rather than counted as zero, because zero is a log probability of
+    # one and would report the opening word as perfectly predicted.
+    def token_logprobs(text)
+      body = http.post_json(PATH, {
+                              'model' => model,
+                              'prompt' => text.to_s,
+                              'max_tokens' => 0,
+                              'echo' => true,
+                              'logprobs' => 0,
+                              'temperature' => 0,
+                            })
+      values = logprobs_in(body)
+      raise ProtocolError, 'completions endpoint returned no token logprobs' if values.empty?
+
+      values.compact
+    end
+
+    # Whether this endpoint can score at all. ProtocolError and HTTP 404 mean
+    # it cannot; TransportError means it is down, which is a different
+    # question. Asked once and kept, so a rail does not spend a scoring
+    # request on a boolean every check.
+    def supported?
+      return @supported unless @supported.nil?
+
+      @supported = token_logprobs('the quick brown fox').size > 1
+    rescue ProtocolError
+      @supported = false
+    rescue HTTPError => e
+      raise unless e.status == 404
+
+      @supported = false
+    end
+
+    private
+
+    def logprobs_in(body)
+      choices = body.is_a?(Hash) ? body['choices'] : nil
+      logprobs = choices.is_a?(Array) ? choices.dig(0, 'logprobs') : nil
+      raise ProtocolError, 'completions endpoint returned no logprobs field' unless logprobs.is_a?(Hash)
+
+      values = logprobs['token_logprobs']
+      raise ProtocolError, 'completions endpoint returned no token_logprobs array' unless values.is_a?(Array)
+
+      values.map { |value| value&.to_f }
+    end
+  end
+end