lingara 0.1.0.pre.alpha.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9900f36d73945227ac18de4de3520240ed8be150dc9db270802d55d5a858d60d
+  data.tar.gz: 84897db9f327ec33dc6823a11b2489a29e5da845f86f0c7be8ed2b2b87fdbbc4
+SHA512:
+  metadata.gz: d831190d39cc8a6d840d913764c06ef40129999b2908237cfbb1f1c7529f93a894883d15925a55a0006d321153beecf78c03c075ee466bc4380ddfc93c984453
+  data.tar.gz: 683926e460ce43175de4fb365168726f61a0d145e0fc6f80dd2f482ca9171b624a633accd4934c0c8dd4b2cc0459a8f4663b181cfd8612c4b337514974d06228

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Spinning Cat Studios
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# lingara (Ruby)
+
+The official Ruby library for the [Lingara API](https://getlingara.com). It is
+built on Ruby's standard library alone: `net/http`, `openssl` and `json`. The
+gem has no runtime dependency, so `gem install lingara` fetches one gem and
+nothing else.
+
+This library is for your server. The Lingara API authenticates with a client
+secret; the [authentication guide](https://getlingara.com/guides/authentication)
+explains why credentials stay on a server.
+
+## Install
+
+```sh
+gem install lingara
+```
+
+or, with Bundler, `gem "lingara"` in your `Gemfile`. **Ruby 3.3 or newer**: the
+floor is the oldest Ruby branch still in upstream maintenance.
+
+## Quick start
+
+```ruby
+require "lingara"
+
+client = Lingara::Client.new(
+  client_id: ENV.fetch("LINGARA_CLIENT_ID"),
+  client_secret: ENV.fetch("LINGARA_CLIENT_SECRET"),
+  # version: "2026-09-knowing-tenpounder",   # optional pin
+)
+
+client.generate_vocabulary(level: 2, source_lang: "en", target_lang: "zh", count: 8) do |event|
+  case event
+  in Lingara::GenerateVocabularyEventItem => item then puts "#{item.data.word}: #{item.data.translation}"
+  else nil
+  end
+end
+
+usage = client.get_usage          # Lingara::Response
+p usage.value.allowance, usage.served_version
+```
+
+Nine methods, each the `operationId` in snake_case: `generate_vocabulary`,
+`create_lesson_plan`, `get_lesson_plan`, `stream_lesson_plan`,
+`send_tutor_message`, `get_usage`, `get_open_api_document`,
+`list_api_versions` and `get_api_version`. A path parameter is a positional
+`String` (`client.get_lesson_plan(plan_id)`); a request body is keyword
+arguments, and an unknown or missing keyword raises `ArgumentError` before any
+request is sent.
+
+A JSON method returns a `Lingara::Response`: `#value` is the generated model
+(a `Hash` for `get_open_api_document`) and `#served_version` is the
+`Lingara-Version` the server answered under, or `nil`.
+
+`get_open_api_document`, `list_api_versions` and `get_api_version` need no
+token, so `Lingara::Client.new` with no credentials calls them. A client
+without credentials sends the other six without `Authorization`, and the
+server's `401` is the answer.
+
+## Streams
+
+The four streaming methods take a block, or return a stream:
+
+- **With a block**, the call sends the request, yields each event and returns
+  a `Lingara::StreamResult` (`#served_version`). `break`, `return` or `throw`
+  out of the block closes the connection.
+- **Without a block**, the call returns a `Lingara::EventStream`, which is
+  `Enumerable`. **The request is sent lazily**, on the first `each` or
+  `next`, so a refusal surfaces there rather than at the call, and a stream
+  you never iterate holds no connection. It is **single-use**: a second
+  `each` raises `IOError`. After external iteration with `next`, call
+  `#close` if you stop before the end; the block form needs no `close`.
+
+```ruby
+stream = client.stream_lesson_plan(plan_id)
+begin
+  first = stream.next
+ensure
+  stream.close
+end
+```
+
+Each event is a generated branch class (`Lingara::GenerateVocabularyEventItem`
+has `#event` and `#data`), and `in Lingara::GenerateVocabularyEvent` matches
+any of that stream's branches. Which events end a stream is the spec's: the
+stream ends after `result` or `pending`, which are yielded, and after `done`,
+which is not. An `error` event is never yielded: it raises
+`Lingara::ApiError` with `status` 200 and, for a lesson plan, `plan_id`.
+
+A stream fails with `Lingara::TransportError` (`kind: :timeout`) after
+`stream_idle_timeout:` seconds (120 by default) in which no byte arrives
+while the library is waiting for your next event. Time you spend holding an
+event never counts.
+
+## Errors
+
+Every failure is a `Lingara::Error`, one of four:
+
+| Class | When | Fields |
+|---|---|---|
+| `Lingara::ApiError` | a `/v1` refusal, or a stream's `error` event | `status`, `code`, `message`, `retry_after`, `plan_id`, `served_version` |
+| `Lingara::OAuthError` | the token endpoint refused | `status`, `error`, `description`, `retry_after` |
+| `Lingara::MaintenanceError` | the API is in maintenance | `body`, `retry_after` |
+| `Lingara::TransportError` | no usable answer | `kind`: `:connect`, `:tls`, `:reset`, `:timeout`, `:stream_ended_early`, `:malformed_response`, `:malformed_event` |
+
+A `429` or `503` with a `Retry-After` of at most `retry_after_cap:` (60 s) is
+retried, up to `max_attempts:` (3) tries; a `401` fetches a fresh token and
+retries once. A stream that has yielded an event is never replayed. Your own
+interrupt (`Thread#raise`, `Thread#kill`, `Timeout.timeout`) is never wrapped
+and never retried.
+
+## Options
+
+Every option is a keyword of `Lingara::Client.new`:
+
+| Keyword | Default |
+|---|---|
+| `client_id:`, `client_secret:` | none: a credential-free client |
+| `auth:` | `:basic` (`client_secret_basic`); `:post` for `client_secret_post` |
+| `scopes:` | none: every scope the client is allowed |
+| `token_source:` | a client-credentials source; any object with `#token` (returning a `Lingara::AccessToken`) and `#invalidate(token)` replaces it |
+| `base_url:`, `token_url:` | `https://api.getlingara.com`, and its `/oauth/token` |
+| `version:` | no `Lingara-Version` header |
+| `on_deprecation:` | one warning per version id through `logger:`; a callable receiving a `Lingara::DeprecationNotice` replaces it |
+| `logger:` | `Kernel#warn` (so `ruby -W0` silences it); any object with `warn` and `debug`, such as `Rails.logger` |
+| `max_attempts:`, `retry_after_cap:` | `3`, `60` |
+| `stream_idle_timeout:`, `token_request_timeout:` | `120`, `30` (seconds) |
+| `user_agent_suffix:` | none; appended after the library's own product token |
+| `net_http_options:` | `{}`: forwarded to `Net::HTTP.start` (`ca_file:`, `open_timeout:` …). The library always sets `max_retries` to `0`, and a stream's `read_timeout` is the idle timeout |
+| `clock:`, `sleeper:` | `Time.now` and `sleep`. **Testing seams only**: the clock decides token freshness and HTTP-date waits, and the sleeper receives every `Retry-After` wait |
+
+The secret and every access token render as `[REDACTED]` in `inspect`,
+`to_s` and `pp`; `#expose_secret` is the one accessor that reads them. A
+client is safe to share between threads: concurrent callers share one token
+exchange, which runs on its own thread, and a process forked mid-exchange
+makes its own.
+
+## The contract
+
+This library keeps the contract every official Lingara library keeps:
+[`conformance/CONTRACT.md`](../conformance/CONTRACT.md). Each connection is
+opened for one request; the library pools none.

data/lib/lingara/access_token.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lingara
+  # Renders a secret-holding object as [REDACTED] everywhere Ruby renders
+  # one: #inspect, #to_s and pp (K1, redaction).
+  module Redacted
+    REDACTED = "[REDACTED]"
+
+    def pretty_print(q)
+      q.text(inspect)
+    end
+  end
+
+  # An opaque access token, as a token source returns it. It renders as
+  # [REDACTED]; #expose_secret is the one way to read it. A caller's own
+  # token source builds one with AccessToken.new(raw).
+  class AccessToken
+    include Redacted
+
+    def initialize(raw)
+      raise ArgumentError, "an access token is a non-empty String" unless raw.is_a?(String) && !raw.empty?
+      @raw = raw.dup.freeze
+    end
+
+    # The raw token: the one accessor that does not redact.
+    def expose_secret
+      @raw
+    end
+
+    def ==(other)
+      other.is_a?(AccessToken) && other.expose_secret == @raw
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @raw.hash
+    end
+
+    def to_s
+      REDACTED
+    end
+
+    def inspect
+      "#<Lingara::AccessToken #{REDACTED}>"
+    end
+  end
+end

data/lib/lingara/client.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lingara
+  # Calls the Lingara API. Every C2 knob is a keyword of Client.new (D3); a
+  # client is safe to share between threads.
+  #
+  #   client = Lingara::Client.new(client_id: ENV.fetch("LINGARA_CLIENT_ID"),
+  #                                client_secret: ENV.fetch("LINGARA_CLIENT_SECRET"))
+  #   client.get_usage.value
+  #
+  # clock: and sleeper: are testing seams (C2 D9): the clock is read for
+  # token freshness and HTTP-date Retry-After values, and the sleeper is
+  # handed every Retry-After wait in seconds.
+  class Client
+    include Redacted
+
+    DEFAULT_BASE_URL = "https://api.getlingara.com"
+    DEFAULT_TOKEN_URL = "https://api.getlingara.com/oauth/token"
+    CREDENTIAL_KEYWORDS = %i[client_id client_secret auth scopes].freeze
+
+    attr_reader :token_source
+
+    def initialize(client_id: nil, client_secret: nil, auth: nil, scopes: nil, token_source: nil,
+      base_url: DEFAULT_BASE_URL, token_url: DEFAULT_TOKEN_URL, version: nil, on_deprecation: nil,
+      logger: DefaultLogger.new, max_attempts: 3, retry_after_cap: 60, stream_idle_timeout: 120,
+      token_request_timeout: 30, user_agent_suffix: nil, clock: -> { Time.now },
+      sleeper: ->(seconds) { sleep(seconds) }, net_http_options: {})
+      credentials = {client_id: client_id, client_secret: client_secret, auth: auth, scopes: scopes}
+      check_options(credentials, token_source, version, stream_idle_timeout)
+      @base_url = base_url.to_s.chomp("/")
+      @version = version
+      @idle = stream_idle_timeout
+      @user_agent = UserAgent.build(user_agent_suffix)
+      @policy = RetryPolicy.new(max_attempts: max_attempts, retry_after_cap: retry_after_cap, clock: clock, sleeper: sleeper)
+      @transport = Transport.new(net_http_options: net_http_options)
+      @versions = VersionObserver.new(hook: on_deprecation, logger: logger)
+      @token_source = token_source || (client_id && ClientCredentials.new(
+        client_id: client_id, client_secret: client_secret, auth: auth || :basic, scopes: scopes, token_url: token_url,
+        transport: @transport, policy: @policy, user_agent: @user_agent, token_request_timeout: token_request_timeout
+      ))
+    end
+
+    # ── The nine operations, over operations.rb ───────────────────────────
+
+    # Streams a vocabulary list (scope vocab:generate).
+    def generate_vocabulary(**body, &block)
+      stream("generateVocabulary", [], body, &block)
+    end
+
+    # Streams a new lesson plan's generation (scope lesson_plans:write). A
+    # plan served from the library is a lone result.
+    def create_lesson_plan(**body, &block)
+      stream("createLessonPlan", [], body, &block)
+    end
+
+    # Fetches a lesson plan by its id (scope lesson_plans:read).
+    def get_lesson_plan(plan_id)
+      json("getLessonPlan", [plan_id])
+    end
+
+    # Rejoins a lesson plan's generation by its id (scope lesson_plans:read).
+    def stream_lesson_plan(plan_id, &block)
+      stream("streamLessonPlan", [plan_id], nil, &block)
+    end
+
+    # Streams the tutor's reply to one turn (scope tutor:converse).
+    def send_tutor_message(**body, &block)
+      stream("sendTutorMessage", [], body, &block)
+    end
+
+    # This client's allowance, or its ledger if it is metered (scope
+    # usage:read).
+    def get_usage
+      json("getUsage", [])
+    end
+
+    # The API's OpenAPI document, as a Hash. Needs no token.
+    def get_open_api_document
+      json("getOpenApiDocument", [])
+    end
+
+    # The API's versions. Needs no token.
+    def list_api_versions
+      json("listApiVersions", [])
+    end
+
+    # One API version, by its id. Needs no token.
+    def get_api_version(version_id)
+      json("getApiVersion", [version_id])
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#<Lingara::Client base_url=#{@base_url.inspect} version=#{@version.inspect} token_source=#{@token_source.inspect}>"
+    end
+
+    private
+
+    def check_options(credentials, token_source, version, idle)
+      if token_source && credentials.any? { |_, value| !value.nil? }
+        raise ArgumentError, "token_source: cannot be combined with #{CREDENTIAL_KEYWORDS.map { |k| "#{k}:" }.join(", ")}"
+      end
+      if credentials[:client_id].nil? != credentials[:client_secret].nil?
+        raise ArgumentError, "client_id: and client_secret: are given together or not at all"
+      end
+      raise ArgumentError, "version: must not be empty" if version == ""
+      raise ArgumentError, "stream_idle_timeout: must be a positive number" unless idle.is_a?(Numeric) && idle.positive?
+    end
+
+    def json(id, args)
+      operation = OPERATIONS.fetch(id)
+      url = url_for(operation, args)
+      pipeline(operation, url, nil) do |response, _phase, observe|
+        served = observe.call(response)
+        Response.new(value: Decoding.response(operation[:response], response.body.to_s), served_version: served)
+      end
+    end
+
+    def stream(id, args, body, &block)
+      operation = OPERATIONS.fetch(id)
+      url = url_for(operation, args)
+      # The request model's constructor refuses a bad keyword before any
+      # request is sent: a programming error, like Client.new's.
+      payload = body && JSON.generate(Lingara.const_get(operation[:request_body]).new(body).to_hash)
+      events = EventStream.new(pipeline: method(:pipeline), operation: operation, url: url, body: payload)
+      block ? events.run(&block) : events
+    end
+
+    # Sends one call: its token and the one 401 retry, the Retry-After loop,
+    # and the refusal mapping. Yields a 2xx response, its Transport::Phase and
+    # the version observer, and returns what the block returns. A client with
+    # no token source sends an operation that needs one without
+    # Authorization; the server's 401 is the answer.
+    def pipeline(operation, url, body, on_start: nil, &on_success)
+      send_all = lambda do |token|
+        @policy.run { attempt(operation, url, body, token, on_start, &on_success) }
+      end
+      result = if @token_source && operation[:needs_token]
+        RetryPolicy.with_token_retry(@token_source, &send_all)
+      else
+        send_all.call(nil)
+      end
+      return result.value if result.done
+      raise Refusal.error(:v1, result.response, result.body, @policy.now)
+    end
+
+    def attempt(operation, url, body, token, on_start)
+      observe = ->(response) { @versions.observe(response, url) }
+      result = @transport.request(operation[:method], url, headers(operation, body, token), body: body,
+        read_timeout: operation[:stream] && @idle, secrets: token ? [token.expose_secret] : [], on_start: on_start) do |response, phase|
+        next Attempt.new(response: response, body: response.body.to_s) unless (200..299).cover?(response.code.to_i)
+        Attempt.new(value: yield(response, phase, observe), done: true)
+      end
+      # Phase#leave hands back the stream's value directly.
+      result.is_a?(Attempt) ? result : Attempt.new(value: result, done: true)
+    end
+
+    def headers(operation, body, token)
+      headers = {"Accept" => operation[:stream] ? "text/event-stream" : "application/json", "User-Agent" => @user_agent}
+      headers["Content-Type"] = "application/json" if body
+      headers["Authorization"] = "Bearer #{token.expose_secret}" if token
+      headers["Lingara-Version"] = @version if @version
+      headers
+    end
+
+    # The base URL and the route's path, each path parameter percent-encoded
+    # but for A–Z a–z 0–9 - . _ ~, as the other libraries do.
+    def url_for(operation, args)
+      path = operation[:path].dup
+      operation[:path_params].zip(args).each do |name, value|
+        raise ArgumentError, "#{name} must be a non-empty String" unless value.is_a?(String) && !value.empty?
+        path.sub!("{#{name}}", value.b.gsub(/[^A-Za-z0-9\-._~]/n) { |c| format("%%%02X", c.ord) })
+      end
+      @base_url + path
+    end
+  end
+end

data/lib/lingara/client_credentials.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+require "uri"
+
+module Lingara
+  # K1: the OAuth 2.0 client-credentials token source (CONTRACT.md K1; D5).
+  #
+  # It caches one token and replaces it min(60 s, expires_in / 2) before it
+  # expires, shares one exchange between concurrent callers, and clears only
+  # the token a 401 was answered with. The exchange runs on a thread of its
+  # own, and every caller, the one that started it included, waits on a
+  # ConditionVariable: a caller's interrupt ends only that caller's wait,
+  # while the flight completes and caches its token. Detached from every
+  # caller, each HTTP attempt of it carries token_request_timeout:.
+  #
+  # Any object with #token (returning an AccessToken) and #invalidate(token)
+  # is a token source; this is the one a client builds from client_id: and
+  # client_secret:.
+  class ClientCredentials
+    include Redacted
+
+    # The one exchange every concurrent caller waits on. +pid+ is the process
+    # that started it: a thread does not survive fork.
+    Flight = Struct.new(:pid, :done, :token, :error)
+    Cached = Struct.new(:token, :stale_at)
+
+    attr_reader :client_id
+
+    def initialize(client_id:, client_secret:, token_url:, transport:, policy:, user_agent:, auth: :basic, scopes: nil,
+      token_request_timeout: 30)
+      raise ArgumentError, "auth: must be :basic or :post" unless %i[basic post].include?(auth)
+      raise ArgumentError, "token_request_timeout: must be a positive number" unless token_request_timeout.is_a?(Numeric) && token_request_timeout.positive?
+      @client_id = client_id
+      @secret = client_secret
+      @config = {token_url: token_url, transport: transport, user_agent: user_agent, auth: auth, scopes: Array(scopes), timeout: token_request_timeout}
+      @policy = policy
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @cached = nil
+      @flight = nil
+    end
+
+    # The raw client secret: the one accessor that does not redact.
+    def expose_secret
+      @secret
+    end
+
+    # The cached token while it is fresh; otherwise the result of the one
+    # flight, started if none is running.
+    def token
+      @mutex.synchronize do
+        # A flight another process started has no thread here (D5, fork).
+        @flight = nil if @flight && @flight.pid != Process.pid
+        return @cached.token if @cached && @policy.now < @cached.stale_at
+        flight = @flight ||= start_flight
+        @cv.wait(@mutex) until flight.done
+        raise flight.error if flight.error
+        flight.token
+      end
+    end
+
+    # Forgets +token+ only if it is still the cached one. During an exchange
+    # it is a no-op: nothing is cached yet.
+    def invalidate(token)
+      @mutex.synchronize do
+        @cached = nil if @cached && @cached.token == token
+      end
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#<Lingara::ClientCredentials client_id=#{@client_id.inspect} client_secret=#{REDACTED}>"
+    end
+
+    private
+
+    # Called with @mutex held.
+    def start_flight
+      flight = Flight.new(Process.pid, false, nil, nil)
+      thread = Thread.new { fly(flight) }
+      thread.name = "lingara-token"
+      thread.report_on_exception = false
+      flight
+    end
+
+    def fly(flight)
+      cached = exchange
+    rescue => e
+      error = e
+    ensure
+      @mutex.synchronize do
+        @flight = nil if @flight.equal?(flight)
+        if cached
+          @cached = cached
+          flight.token = cached.token
+        else
+          flight.error = error || TransportError.new(:connect, "the token exchange ended without an answer")
+        end
+        flight.done = true
+        @cv.broadcast
+      end
+    end
+
+    def exchange
+      sent_at = nil
+      attempt = @policy.run do
+        # obtained_at is when the request that succeeded was sent.
+        sent_at = @policy.now
+        post
+      end
+      unless (200..299).cover?(attempt.status)
+        raise Refusal.error(:token, attempt.response, attempt.body, @policy.now)
+      end
+      token, lifetime = grant(attempt.body)
+      skew = [60, lifetime / 2.0].min
+      Cached.new(token, sent_at + lifetime - skew)
+    end
+
+    # One exchange attempt and its whole body, under the token request
+    # timeout. Retry-After sleeps happen between attempts, so they never
+    # count against it.
+    def post
+      Timeout.timeout(@config[:timeout], TokenAttemptTimeout) do
+        @config[:transport].request("POST", @config[:token_url], headers, body: form, secrets: [@secret]) do |response, _phase|
+          Attempt.new(response: response, body: response.body.to_s)
+        end
+      end
+    rescue TokenAttemptTimeout
+      raise TransportError.new(:timeout, "the token request timed out")
+    end
+
+    def headers
+      headers = {
+        "Content-Type" => "application/x-www-form-urlencoded",
+        "Accept" => "application/json",
+        "User-Agent" => @config[:user_agent]
+      }
+      headers["Authorization"] = basic_auth if @config[:auth] == :basic
+      headers
+    end
+
+    # The grant, any scopes, and the credentials only under
+    # client_secret_post: never both places.
+    def form
+      pairs = [["grant_type", "client_credentials"]]
+      pairs << ["scope", @config[:scopes].join(" ")] unless @config[:scopes].empty?
+      pairs.push(["client_id", @client_id], ["client_secret", @secret]) if @config[:auth] == :post
+      URI.encode_www_form(pairs)
+    end
+
+    # Basic base64(form(id) ":" form(secret)), each half form-encoded per
+    # RFC 6749 §2.3.1. [s].pack("m0") is base64 with no bundled gem.
+    def basic_auth
+      pair = "#{URI.encode_www_form_component(@client_id)}:#{URI.encode_www_form_component(@secret)}"
+      "Basic #{[pair].pack("m0")}"
+    end
+
+    # A 200's token and lifetime: malformed unless it has an access_token, an
+    # expires_in and a Bearer token_type.
+    def grant(body)
+      fields = JSON.parse(body)
+      raw, lifetime, type = fields.values_at("access_token", "expires_in", "token_type") if fields.is_a?(Hash)
+      unless raw.is_a?(String) && !raw.empty? && lifetime.is_a?(Numeric) && lifetime >= 0 && type.is_a?(String) && type.casecmp?("bearer")
+        raise TransportError.new(:malformed_response, "the token response lacks access_token, expires_in or a Bearer token_type")
+      end
+      [AccessToken.new(raw), lifetime]
+    rescue JSON::ParserError
+      raise TransportError.new(:malformed_response, "the token response is not JSON")
+    end
+  end
+end