omni_agent 0.1.10 → 0.2.0

data/lib/omni_agent/mcp/oauth/jwt_verifier.rb

@@ -0,0 +1,122 @@
+module OmniAgent
+  module MCP
+    module OAuth
+      # Verifies JWT access tokens (RFC 9068) with the authorization server's
+      # JSON Web Key Set. Returns the payload, or nil when the token is invalid.
+      # Issuer, audience and scopes are checked afterwards by ResourceServer.
+      class JWTVerifier
+        # Asymmetric algorithms only: a JWKS publishes public keys.
+        DEFAULT_ALGORITHMS = %w[RS256 RS384 RS512 PS256 PS384 PS512 ES256 ES384 ES512].freeze
+        CACHE_TTL = 300
+        # A token signed with an unknown `kid` refetches the key set (key
+        # rotation), but at most this often, so forged tokens cannot make every
+        # request call the authorization server. Also the wait after a failed fetch.
+        MIN_REFRESH_INTERVAL = 30
+
+        def self.require_jwt!
+          require "jwt"
+        rescue LoadError
+          raise OmniAgent::MissingDependencyError,
+                "The 'jwt' gem is required for `authenticate :oauth, jwks_uri: ...`. " \
+                "Please add `gem 'jwt'` to your Gemfile."
+        end
+
+        def initialize(jwks_uri, algorithms: DEFAULT_ALGORITHMS, leeway: 0)
+          self.class.require_jwt!
+
+          @jwks_uri = jwks_uri
+          @algorithms = Array(algorithms).map(&:to_s)
+          @leeway = leeway
+          # Held only while fetching, so at most one fetch runs at a time.
+          # Reading the cached keys never takes it.
+          @fetch_mutex = Mutex.new
+          @jwks = nil
+          @fetched_at = nil
+          @failed_at = nil
+        end
+
+        def call(token, _request = nil)
+          payload, _header = ::JWT.decode(
+            token, nil, true,
+            algorithms: @algorithms,
+            jwks: method(:jwks),
+            required_claims: %w[exp iss],
+            leeway: @leeway
+          )
+          payload
+        rescue ::JWT::DecodeError
+          nil
+        end
+
+        private
+
+        # Key loader for JWT.decode. Called with `kid_not_found: true` when the
+        # token's `kid` is not in the cached set.
+        def jwks(options = {})
+          if @jwks.nil?
+            load_initial_jwks
+          elsif refresh_due?(options) && @fetch_mutex.try_lock
+            # Only the thread that got the lock refreshes; the others keep
+            # using the cached keys instead of waiting for it.
+            begin
+              fetch_jwks
+            ensure
+              @fetch_mutex.unlock
+            end
+          end
+
+          @jwks
+        end
+
+        # With no keys yet, concurrent requests wait for one shared fetch rather
+        # than each fetching in turn. After a failure they fail fast until
+        # MIN_REFRESH_INTERVAL has passed, so a down authorization server does
+        # not tie up every app thread on timeouts.
+        def load_initial_jwks
+          raise_unavailable if backing_off?
+
+          @fetch_mutex.synchronize do
+            next if @jwks
+            raise_unavailable if backing_off?
+
+            fetch_jwks
+          end
+
+          raise_unavailable if @jwks.nil?
+        end
+
+        def refresh_due?(options)
+          return false if backing_off?
+
+          age = monotonic_now - @fetched_at
+          age > CACHE_TTL || (options[:kid_not_found] && age > MIN_REFRESH_INTERVAL)
+        end
+
+        def fetch_jwks
+          keys = HTTPClient.get_json(OAuth.resolve(@jwks_uri))
+          # @fetched_at first: readers that see @jwks expect it to be set.
+          @fetched_at = monotonic_now
+          @jwks = keys
+          @failed_at = nil
+        rescue VerificationError => e
+          @failed_at = monotonic_now
+          fallback = @jwks ? "using cached keys" : "retrying in #{MIN_REFRESH_INTERVAL}s"
+          MCP.logger&.warn("[OmniAgent::MCP] Could not fetch JWKS, #{fallback}: #{e.message}")
+        end
+
+        def backing_off?
+          failed_at = @failed_at
+          !failed_at.nil? && monotonic_now - failed_at < MIN_REFRESH_INTERVAL
+        end
+
+        def raise_unavailable
+          raise VerificationError, "JWKS from #{OAuth.resolve(@jwks_uri)} is unavailable"
+        end
+
+        def monotonic_now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth/resource_server.rb

@@ -0,0 +1,166 @@
+require "uri"
+
+module OmniAgent
+  module MCP
+    module OAuth
+      # Built by `authenticate :oauth, ...`. Validates bearer access tokens
+      # (signature or introspection, issuer, audience, expiry and scopes) and
+      # describes the server in Protected Resource Metadata (RFC 9728) so MCP
+      # clients can find the authorization server.
+      class ResourceServer
+        METADATA_PATH = "/.well-known/oauth-protected-resource".freeze
+        # Seconds of clock skew tolerated when checking exp and nbf.
+        LEEWAY = 30
+
+        attr_reader :scopes
+
+        def initialize(resource:, authorization_servers:, scopes: [], scopes_supported: nil, audience: nil,
+                       jwks_uri: nil, algorithms: JWTVerifier::DEFAULT_ALGORITHMS, introspection: nil,
+                       verify_token: nil, &principal_block)
+          raise ArgumentError, "authenticate :oauth requires resource:" if resource.nil?
+          raise ArgumentError, "authenticate :oauth requires authorization_servers:" if Array(authorization_servers).empty?
+
+          validate_resource!(resource) unless resource.respond_to?(:call)
+
+          @resource = resource
+          @authorization_servers = authorization_servers
+          @scopes = Array(scopes).map(&:to_s).freeze
+          @scopes_supported = scopes_supported && Array(scopes_supported).map(&:to_s).freeze
+          @audience = audience
+          @principal_block = principal_block
+          @verifier = build_verifier(jwks_uri, algorithms, introspection, verify_token)
+        end
+
+        # Returns an Authenticator::Result. `error` is nil when no token was
+        # sent, :invalid_token or :insufficient_scope (RFC 6750 section 3.1).
+        def authenticate(request)
+          token = request.bearer_token
+          return failure(nil) if token.nil?
+
+          claims = verify(token, request)
+          return failure(:invalid_token) unless claims.is_a?(Hash)
+
+          access_token = AccessToken.new(token, claims)
+          return failure(:invalid_token) unless valid?(access_token)
+          return failure(:insufficient_scope) unless access_token.scope?(scopes)
+
+          principal = @principal_block ? @principal_block.call(access_token, request) : access_token
+          return failure(:invalid_token) unless principal
+
+          Authenticator::Result.new(true, principal, nil, access_token)
+        rescue VerificationError => e
+          MCP.logger&.error("[OmniAgent::MCP] OAuth token verification failed: #{e.message}")
+          failure(:invalid_token)
+        end
+
+        def metadata(resource_name: nil)
+          supported = @scopes_supported || scopes
+
+          {
+            resource: resource,
+            authorization_servers: authorization_servers,
+            scopes_supported: supported.empty? ? nil : supported,
+            bearer_methods_supported: [ "header" ],
+            resource_name: resource_name
+          }.compact
+        end
+
+        # Value of the WWW-Authenticate header for a 401 or 403 response.
+        def challenge(realm:, error: nil)
+          params = { realm: realm, resource_metadata: metadata_url }
+          params[:error] = error.to_s if error
+          params[:scope] = scopes.join(" ") unless scopes.empty?
+
+          "Bearer " + params.map { |key, value| %(#{key}="#{value}") }.join(", ")
+        end
+
+        # Served by RackApp under the MCP endpoint itself, so it works wherever
+        # the server is mounted.
+        def metadata_url
+          "#{resource.chomp('/')}#{METADATA_PATH}"
+        end
+
+        def resource
+          OAuth.resolve(@resource).to_s
+        end
+
+        def authorization_servers
+          Array(OAuth.resolve(@authorization_servers)).map(&:to_s)
+        end
+
+        private
+
+        def build_verifier(jwks_uri, algorithms, introspection, verify_token)
+          given = { jwks_uri: jwks_uri, introspection: introspection, verify_token: verify_token }.compact
+          unless given.size == 1
+            raise ArgumentError, "authenticate :oauth requires exactly one of jwks_uri:, introspection: or verify_token:"
+          end
+
+          if jwks_uri
+            JWTVerifier.new(jwks_uri, algorithms: algorithms, leeway: LEEWAY)
+          elsif introspection
+            IntrospectionVerifier.new(**introspection.transform_keys(&:to_sym))
+          else
+            raise ArgumentError, "verify_token: must respond to #call" unless verify_token.respond_to?(:call)
+
+            verify_token
+          end
+        end
+
+        def verify(token, request)
+          if @verifier.respond_to?(:arity) && @verifier.arity == 1
+            @verifier.call(token)
+          else
+            @verifier.call(token, request)
+          end
+        end
+
+        def valid?(access_token)
+          claims = access_token.claims
+
+          fresh?(claims) && trusted_issuer?(claims) && intended_audience?(access_token)
+        end
+
+        def fresh?(claims)
+          now = Time.now.to_i
+          return false if claims.key?("exp") && !(claims["exp"].is_a?(Numeric) && now < claims["exp"] + LEEWAY)
+          return false if claims.key?("nbf") && !(claims["nbf"].is_a?(Numeric) && now >= claims["nbf"] - LEEWAY)
+
+          true
+        end
+
+        # JWTs must carry `iss`; introspection responses and custom verifiers may omit it.
+        def trusted_issuer?(claims)
+          return true unless claims.key?("iss")
+
+          authorization_servers.map { |server| normalize(server) }.include?(normalize(claims["iss"]))
+        end
+
+        # RFC 8707: the token must have been issued for this server. Tokens
+        # meant for another resource are rejected, never passed through.
+        def intended_audience?(access_token)
+          expected = Array(OAuth.resolve(@audience) || resource).map { |value| normalize(value) }
+
+          access_token.audience.any? { |value| expected.include?(normalize(value)) }
+        end
+
+        def normalize(uri)
+          uri.to_s.chomp("/")
+        end
+
+        def validate_resource!(resource)
+          uri = URI.parse(resource.to_s)
+          return if uri.is_a?(URI::HTTP) && uri.host && uri.fragment.nil?
+
+          raise ArgumentError, "resource: must be the absolute http(s) URL of the MCP endpoint, without a fragment"
+        rescue URI::InvalidURIError
+          raise ArgumentError, "resource: #{resource.inspect} is not a valid URL"
+        end
+
+        def failure(error)
+          Authenticator::Result.new(false, nil, error, nil)
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth.rb

@@ -0,0 +1,18 @@
+module OmniAgent
+  module MCP
+    # Resource server side of the MCP authorization spec (OAuth 2.1). Access
+    # tokens are issued by an external authorization server and validated here;
+    # see ResourceServer.
+    module OAuth
+      # The authorization server could not be reached or answered with something
+      # unusable. The request is rejected as unauthenticated.
+      class VerificationError < OmniAgent::MCPError; end
+
+      # Settings accept a value or a callable, so they can be read from ENV or
+      # credentials on every request.
+      def self.resolve(value)
+        value.respond_to?(:call) ? value.call : value
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/rack_app.rb

@@ -7,6 +7,11 @@ module OmniAgent
     class RackApp
       JSON_HEADERS = { "content-type" => "application/json" }.freeze
       PARSE_FAILED = Object.new.freeze
+      METADATA_CORS_HEADERS = {
+        "access-control-allow-origin" => "*",
+        "access-control-allow-methods" => "GET, OPTIONS",
+        "access-control-allow-headers" => "mcp-protocol-version"
+      }.freeze
 
       # Accepts the server class or its name. Passing a String defers the
       # constant lookup to request time, which keeps routes reload-safe.
@@ -23,11 +28,17 @@ module OmniAgent
       def call(env)
         server_class = MCP.resolve_server_class(@server)
         request = Request.new(env)
+        resource_server = server_class.configured_oauth_resource_server
+
+        # Public, so clients can discover the authorization server before they have a token.
+        if resource_server && request.path_info == OAuth::ResourceServer::METADATA_PATH
+          return protected_resource_metadata(server_class, resource_server, request)
+        end
 
         return forbidden unless origin_allowed?(request, server_class)
 
         auth = Authenticator.new(server_class).authenticate(request)
-        return unauthorized(server_class) unless auth.authenticated?
+        return unauthorized(server_class, resource_server, auth) unless auth.authenticated?
 
         return method_not_allowed unless request.post?
 
@@ -41,7 +52,7 @@ module OmniAgent
         message = parse_json(body)
         return json_response(400, parse_error_response) if message.equal?(PARSE_FAILED)
 
-        server = server_class.new(principal: auth.principal, request: request, transport: :http)
+        server = server_class.new(principal: auth.principal, access_token: auth.access_token, request: request, transport: :http)
         response = Handler.new(server).call(message)
         return [ 202, {}, [] ] if response.nil?
 
@@ -94,13 +105,26 @@ module OmniAgent
         http_error(403, "Origin not allowed")
       end
 
-      def method_not_allowed
-        [ 405, JSON_HEADERS.merge("allow" => "POST"), [ JSON.generate({ error: "Method not allowed" }) ] ]
+      def method_not_allowed(allow = "POST")
+        [ 405, JSON_HEADERS.merge("allow" => allow), [ JSON.generate({ error: "Method not allowed" }) ] ]
+      end
+
+      def unauthorized(server_class, resource_server, auth)
+        realm = server_class.server_name
+        challenge = resource_server ? resource_server.challenge(realm: realm, error: auth.error) : %(Bearer realm="#{realm}")
+        status, message = auth.error == :insufficient_scope ? [ 403, "Insufficient scope" ] : [ 401, "Unauthorized" ]
+
+        [ status, JSON_HEADERS.merge("www-authenticate" => challenge), [ JSON.generate({ error: message }) ] ]
       end
 
-      def unauthorized(server_class)
-        headers = JSON_HEADERS.merge("www-authenticate" => %(Bearer realm="#{server_class.server_name}"))
-        [ 401, headers, [ JSON.generate({ error: "Unauthorized" }) ] ]
+      # RFC 9728 Protected Resource Metadata. Browser-based clients fetch it
+      # cross-origin, and it holds nothing secret, so any origin may read it.
+      def protected_resource_metadata(server_class, resource_server, request)
+        return [ 204, METADATA_CORS_HEADERS.dup, [] ] if request.options?
+        return method_not_allowed("GET") unless request.get? || request.head?
+
+        metadata = resource_server.metadata(resource_name: server_class.server_name)
+        [ 200, JSON_HEADERS.merge(METADATA_CORS_HEADERS), [ JSON.generate(metadata) ] ]
       end
     end
   end

data/lib/omni_agent/mcp/server.rb

@@ -50,8 +50,17 @@ module OmniAgent
           add_tool_declaration(type: :tool, tool_class: tool_class, name: as.to_s)
         end
 
-        def authenticate(strategy = nil, tokens: nil, &block)
-          @authentication = if block
+        def authenticate(strategy = nil, tokens: nil, **oauth_options, &block)
+          if strategy != :oauth && oauth_options.any?
+            raise ArgumentError, "unknown keywords for authenticate: #{oauth_options.keys.map(&:inspect).join(', ')}"
+          end
+
+          @authentication = if strategy == :oauth
+            raise ArgumentError, "authenticate :oauth does not take tokens:" unless tokens.nil?
+
+            # The block, if any, maps the validated access token to the principal.
+            { strategy: :oauth, resource_server: OAuth::ResourceServer.new(**oauth_options, &block) }
+          elsif block
             { strategy: :custom, block: block }
           elsif strategy == :none
             { strategy: :none }
@@ -60,7 +69,7 @@ module OmniAgent
 
             { strategy: :bearer, tokens: tokens }
           else
-            raise ArgumentError, "authenticate expects :bearer (with tokens:), :none, or a block"
+            raise ArgumentError, "authenticate expects :bearer (with tokens:), :oauth, :none, or a block"
           end
         end
 
@@ -93,6 +102,11 @@ module OmniAgent
         def configured_stdio_principal_block; setting(:@stdio_principal_block); end
         def configured_allowed_origins; list_setting(:@allowed_origins); end
 
+        def configured_oauth_resource_server
+          authentication = configured_authentication
+          authentication[:resource_server] if authentication && authentication[:strategy] == :oauth
+        end
+
         # Ordered { "ToolName" => tool_class }: for each server in the
         # inheritance chain, its <Server>::Tools namespace first, then its
         # declared tools. Resolved on every call so lazily referenced tools
@@ -203,12 +217,14 @@ module OmniAgent
         end
       end
 
-      attr_reader :principal, :request, :transport
+      # access_token is the OAuth::AccessToken for `authenticate :oauth`, nil otherwise.
+      attr_reader :principal, :request, :transport, :access_token
 
-      def initialize(principal: nil, request: nil, transport: :http)
+      def initialize(principal: nil, request: nil, transport: :http, access_token: nil)
         @principal = principal
         @request = request
         @transport = transport
+        @access_token = access_token
       end
 
       def visible_tools
@@ -227,6 +243,7 @@ module OmniAgent
 
       def tool_context
         base = { mcp_principal: principal, mcp_request: request }
+        base[:mcp_access_token] = access_token if access_token
         context_block = self.class.configured_context_block
         return base unless context_block
 

data/lib/omni_agent/providers/base.rb

@@ -13,6 +13,20 @@ module OmniAgent
         raise NotImplementedError, "Providers must implement #chat"
       end
 
+      # Returns one embedding vector (Array of Floats) per text in `texts`.
+      # `model` is the embedding model; it defaults per provider, never to the
+      # chat model.
+      def embed(texts, model: nil)
+        raise NotImplementedError, "#{self.class.name.split('::').last} does not support embeddings"
+      end
+
+      # Providers that return true receive an agent's output schema as the
+      # `output_schema:` keyword of #chat. Otherwise the schema is only
+      # described in the system prompt.
+      def supports_structured_output?
+        false
+      end
+
       def validate_messages!(messages, allowed_roles:)
         unless messages.is_a?(Array)
           raise OmniAgent::Error, "messages must be an array"

data/lib/omni_agent/providers/mock.rb

@@ -1,20 +1,25 @@
+require "json"
+require "digest"
+
 module OmniAgent
   module Providers
     class Mock < Base
       LOREM_IPSUM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
 
-      def chat(messages:, tools: [], stream: nil, **_options)
+      def chat(messages:, tools: [], stream: nil, output_schema: nil, **_options)
         validate_messages!(messages, allowed_roles: %i[system user assistant tool])
 
+        content = output_schema ? JSON.generate(sample_output(output_schema)) : LOREM_IPSUM
+
         if stream
-          LOREM_IPSUM.split(" ").each_with_index do |word, index|
+          content.split(" ").each_with_index do |word, index|
             chunk = index.zero? ? word : " #{word}"
             stream.call(OmniAgent::Streaming::Event.text(chunk))
           end
         end
 
         OmniAgent::Providers::Response.new(
-          content: LOREM_IPSUM,
+          content: content,
           raw_request: {
             model: model,
             messages: messages,
@@ -24,7 +29,7 @@ module OmniAgent
             "choices" => [
               {
                 "message" => {
-                  "content" => LOREM_IPSUM
+                  "content" => content
                 }
               }
             ]
@@ -33,6 +38,16 @@ module OmniAgent
         )
       end
 
+      # Deterministic placeholder vectors derived from the text, so specs can
+      # index and search without calling a real embedding model.
+      def embed(texts, model: nil)
+        texts.map { |text| Digest::SHA256.digest(text.to_s).bytes.first(8).map { |byte| byte / 255.0 } }
+      end
+
+      def supports_structured_output?
+        true
+      end
+
       protected
 
       def default_api_key
@@ -42,6 +57,76 @@ module OmniAgent
       def default_model
         "mock"
       end
+
+      private
+
+      # Builds a placeholder value for every property so agents with an output
+      # schema get a parseable response without calling a real model. Raises
+      # when a field needs a value the mock can't invent (pattern, custom
+      # validate:, polymorphic resolve: true).
+      def sample_output(output_schema)
+        unresolvable = output_schema.polymorphics.find { |_name, group| group[:resolve] }
+        unsatisfiable!(unresolvable.first, "it is polymorphic with resolve: true") if unresolvable
+
+        sample = sample_object(output_schema.json_schema)
+
+        output_schema.validators.each do |name, validator|
+          passed = begin
+            validator.call(sample[name]) != false
+          rescue StandardError
+            false
+          end
+          unsatisfiable!(name, "its validate: proc rejects the placeholder #{sample[name].inspect}") unless passed
+        end
+
+        sample
+      end
+
+      def sample_object(schema, path = nil)
+        (schema[:properties] || {}).to_h do |name, property|
+          [ name, sample_value(property, [ path, name ].compact.join(".")) ]
+        end
+      end
+
+      def sample_value(property, path)
+        return property[:enum].first if property[:enum]
+
+        case property[:type]
+        when "string" then sample_string(property, path)
+        when "integer" then sample_number(property, integer: true)
+        when "number" then sample_number(property).to_f
+        when "boolean" then true
+        when "array" then Array.new([ property[:minItems].to_i, 1 ].max) { sample_value(property[:items] || {}, "#{path}[]") }
+        when "object" then sample_object(property, path)
+        end
+      end
+
+      def sample_number(property, integer: false)
+        minimum = property[:minimum]
+        maximum = property[:maximum]
+        return integer ? minimum.ceil : minimum if minimum
+        return integer ? maximum.floor : maximum if maximum && maximum < 0
+
+        0
+      end
+
+      def sample_string(property, path)
+        text = LOREM_IPSUM
+        text = text.ljust(property[:minLength], "x") if property[:minLength]
+        text = text[0, property[:maxLength]] if property[:maxLength]
+
+        if property[:pattern] && !text.match?(Regexp.new(property[:pattern]))
+          unsatisfiable!(path, "its value must match the pattern #{property[:pattern]}")
+        end
+
+        text
+      end
+
+      def unsatisfiable!(field, reason)
+        raise OmniAgent::Error,
+              "The mock provider can't generate structured output for `#{field}` because #{reason}. " \
+              "Stub the provider's #chat response in this test instead."
+      end
     end
   end
 end

data/lib/omni_agent/providers/ollama.rb

@@ -20,6 +20,10 @@ module OmniAgent
         ENV.fetch("OLLAMA_MODEL", "llama3.1")
       end
 
+      def default_embedding_model
+        ENV.fetch("OLLAMA_EMBEDDING_MODEL", "nomic-embed-text")
+      end
+
       private
 
       def base_url

data/lib/omni_agent/providers/openai.rb

@@ -12,13 +12,14 @@ module OmniAgent
               "Please add `gem 'openai'` to your Gemfile."
       end
 
-      def chat(messages:, tools: [], stream: nil, **options)
+      def chat(messages:, tools: [], stream: nil, output_schema: nil, **options)
         validate_messages!(messages, allowed_roles: %i[system user assistant tool])
 
         messages = messages.map do |msg|
           clean_msg = msg.reject { |_, v| v.nil? }
 
-          if !clean_msg.key?(:tool_calls) && !clean_msg[:content].is_a?(String)
+          # Arrays are OpenAI content parts (text, image_url, file) and pass through.
+          if !clean_msg.key?(:tool_calls) && !clean_msg[:content].is_a?(String) && !clean_msg[:content].is_a?(Array)
             clean_msg[:content] = ""
           end
 
@@ -42,6 +43,7 @@ module OmniAgent
           messages: messages
         }
         payload[:tools] = openai_tools if openai_tools.any?
+        payload[:response_format] = format_response_format(output_schema) if output_schema
         payload.merge!(options) if options.any?
 
         response = if stream
@@ -55,8 +57,26 @@ module OmniAgent
         raise OmniAgent::Error, "Error during #{provider_label} chat: #{e.message}"
       end
 
+      def embed(texts, model: nil)
+        response = with_retries do
+          client.embeddings.create(input: texts, model: model || default_embedding_model)
+        end
+
+        response.data.map(&:embedding)
+      rescue => e
+        raise OmniAgent::Error, "Error during #{provider_label} embed: #{e.message}"
+      end
+
+      def supports_structured_output?
+        true
+      end
+
       protected
 
+      def default_embedding_model
+        "text-embedding-3-small"
+      end
+
       def provider_label
         "OpenAI"
       end
@@ -109,6 +129,17 @@ module OmniAgent
         }
       end
 
+      def format_response_format(output_schema)
+        {
+          type: "json_schema",
+          json_schema: {
+            name: "structured_output",
+            schema: output_schema.json_schema,
+            strict: output_schema.strict_compatible?
+          }
+        }
+      end
+
       def parse_response(raw_response, raw_request)
         provider_raw_response = raw_response.respond_to?(:to_h) ? raw_response.to_h : raw_response
         choices = raw_response.respond_to?(:choices) ? raw_response.choices : provider_raw_response["choices"]