> ## Documentation Index
> Fetch the complete documentation index at: https://bifrost-dev.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Evaluate a decision (OpenAI format)

> OpenAI's Decisions API: asks an ordered list of questions about an input
and returns one answer per question, in order. Any decision model can
answer: OpenAI's decisions models such as `gpt-6-luna`, Typesafe's jev
models, or any chat model through structured output. The request is
OpenAI's: a top-level `state` and a field a question, choice, or level
does not define (such as `criteria`) are rejected rather than
translated, while other top-level fields are forwarded unchanged.
Answers come back in OpenAI's response shape, with `name: null` for a
question sent without a name, plus Bifrost's `extra_fields` as on the
other OpenAI routes; when raw responses are enabled and OpenAI served
the request, OpenAI's own response body is returned instead.

**Note:** This endpoint also works without the `/v1` prefix (e.g., `/openai/decisions`).




## OpenAPI

````yaml /openapi/openapi.json post /openai/v1/decisions
openapi: 3.1.0
info:
  title: Bifrost API
  description: >
    Bifrost HTTP Transport API for AI model inference and gateway management.


    This API provides a unified interface for interacting with multiple AI
    providers

    including OpenAI, Anthropic, Bedrock, Gemini, and more through a single API,

    along with comprehensive management APIs for configuring and monitoring the
    gateway.


    ## API Structure


    ### Unified Inference API (`/v1/*`)

    The primary API using Bifrost's unified format. Model parameters use the
    format

    `provider/model` (e.g., `openai/gpt-4`, `anthropic/claude-3-opus`).


    ### Async Inference API (`/v1/async/*`)

    Submit inference requests for asynchronous execution. Returns a job ID
    immediately

    and allows polling for results. Supports all inference types except batches,
    files,

    and containers.


    ### Provider Integration APIs

    Native provider-format APIs for drop-in compatibility:

    - `/openai/*` - OpenAI-compatible API

    - `/anthropic/*` - Anthropic-compatible API

    - `/genai/*` - Google GenAI (Gemini) compatible API

    - `/bedrock/*` - AWS Bedrock compatible API

    - `/cohere/*` - Cohere compatible API


    ### Framework Integration APIs

    Multi-provider proxy endpoints for AI frameworks:

    - `/litellm/*` - LiteLLM proxy with all provider formats

    - `/langchain/*` - LangChain compatible endpoints

    - `/pydanticai/*` - PydanticAI compatible endpoints


    ### Management APIs (`/api/*`)

    APIs for managing and monitoring the Bifrost gateway:

    - `/api/config` - Configuration management

    - `/api/providers` - Provider and API key management

    - `/api/plugins` - Plugin management

    - `/api/governance/*` - Virtual keys, teams, customers, budgets, rate
    limits, routing rules, and pricing overrides

    - `/api/logs` - Log search and analytics

    - `/api/mcp/*` - MCP (Model Context Protocol) client management

    - `/api/session/*` - Authentication and session management

    - `/api/cache/*` - Cache management

    - `/health` - Health check endpoint


    ## Fallbacks

    Requests can include fallback models that will be tried if the primary model
    fails.
  version: 1.0.0
  contact:
    name: Contact Us
    url: https://getmaxim.ai/bifrost
  license:
    name: Apache 2.0
    url: https://opensource.org/licenses/Apache-2.0
servers:
  - url: '{baseUrl}'
    description: Your Bifrost instance
    variables:
      baseUrl:
        default: http://localhost:8080
        description: Base URL of your Bifrost instance (e.g. https://bifrost.mycompany.com)
security:
  - BearerAuth: []
  - BasicAuth: []
  - ApiKeyAuth: []
tags:
  - name: Models
    description: Model listing and information
  - name: Chat Completions
    description: Chat-based text generation
  - name: Text Completions
    description: Text completion generation
  - name: Responses
    description: OpenAI Responses API compatible endpoints
  - name: OCR
    description: Optical character recognition for documents and images
  - name: Rerank
    description: Document reranking by relevance to a query
  - name: Decisions
    description: Structured decisions evaluated against annotated function-tool definitions
  - name: Embeddings
    description: Text embedding generation
  - name: Images
    description: Image generations, editing, and variations
  - name: Videos
    description: Video generation and management
  - name: Audio
    description: Speech synthesis and transcription
  - name: Count Tokens
    description: Token counting utilities
  - name: Batch
    description: Batch processing operations
  - name: Files
    description: File management operations
  - name: Containers
    description: Container management operations
  - name: Async Jobs
    description: Asynchronous job submission and retrieval endpoints
  - name: Realtime
    description: Realtime WebSocket and WebRTC endpoints
  - name: OpenAI Integration
    description: OpenAI-compatible API endpoints (/openai/*)
  - name: Azure Integration
    description: Azure OpenAI integration endpoints
  - name: Anthropic Integration
    description: Anthropic-compatible API endpoints (/anthropic/*)
  - name: GenAI Integration
    description: Google GenAI (Gemini) compatible API endpoints (/genai/*)
  - name: Bedrock Integration
    description: AWS Bedrock compatible API endpoints (/bedrock/*)
  - name: Cohere Integration
    description: Cohere compatible API endpoints (/cohere/*)
  - name: Typesafe Integration
    description: Typesafe compatible API endpoints (/typesafe/*)
  - name: LiteLLM Integration
    description: LiteLLM proxy endpoints with multi-provider support (/litellm/*)
  - name: LangChain Integration
    description: LangChain compatible endpoints with multi-provider support (/langchain/*)
  - name: PydanticAI Integration
    description: >-
      PydanticAI compatible endpoints with multi-provider support
      (/pydanticai/*)
  - name: Health
    description: Health check endpoints
  - name: Configuration
    description: Configuration management endpoints
  - name: Session
    description: Session and authentication endpoints
  - name: Providers
    description: Provider management endpoints
  - name: Plugins
    description: Plugin management endpoints
  - name: MCP
    description: Model Context Protocol endpoints
  - name: Governance
    description: Virtual keys, teams, and customers management
  - name: Routing
    description: Routing rules and complexity analyzer configuration
  - name: Logging
    description: Log search and management endpoints
  - name: Cache
    description: Cache management endpoints
  - name: Vault
    description: Vault secret management endpoints
  - name: Skills
    description: Skills Repository management, marketplace, and download endpoints
  - name: Audit Logs
    description: >-
      CADF-compliant audit log search, export, and signature verification
      endpoints
  - name: Webhooks
    description: Webhook endpoint management and signed async-job delivery history
  - name: Notifications
    description: >-
      Role-targeted dashboard notifications, delivered over the dashboard
      WebSocket
  - name: Background Jobs
    description: >-
      Status, progress and cancellation of durable background jobs (cost
      recalculation, Warp log indexing, and others)
  - name: Warp
    description: >-
      Configuration for Warp, the dashboard agent that answers questions about
      the deployment's own telemetry
paths:
  /openai/v1/decisions:
    post:
      tags:
        - OpenAI Integration
      summary: Evaluate a decision (OpenAI format)
      description: >
        OpenAI's Decisions API: asks an ordered list of questions about an input

        and returns one answer per question, in order. Any decision model can

        answer: OpenAI's decisions models such as `gpt-6-luna`, Typesafe's jev

        models, or any chat model through structured output. The request is

        OpenAI's: a top-level `state` and a field a question, choice, or level

        does not define (such as `criteria`) are rejected rather than

        translated, while other top-level fields are forwarded unchanged.

        Answers come back in OpenAI's response shape, with `name: null` for a

        question sent without a name, plus Bifrost's `extra_fields` as on the

        other OpenAI routes; when raw responses are enabled and OpenAI served

        the request, OpenAI's own response body is returned instead.


        **Note:** This endpoint also works without the `/v1` prefix (e.g.,
        `/openai/decisions`).
      operationId: openaiCreateDecision
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/OpenAIDecisionRequest'
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIDecisionResponse'
        '400':
          description: Bad request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
      security:
        - BearerAuth: []
        - VirtualKeyAuth: []
        - ApiKeyAuth: []
components:
  schemas:
    OpenAIDecisionRequest:
      type: object
      description: >-
        OpenAI's Decisions request. A field OpenAI's question, choice, or level
        does not define (such as Typesafe's `criteria`), a top-level `state`,
        and a structured or null `input` are rejected with a 400; any other
        top-level field is forwarded to the provider unchanged, so a field a
        newer SDK sends still reaches it.
      required:
        - model
        - input
        - questions
      properties:
        model:
          type: string
          description: >-
            Model in provider/model format; a model without a provider prefix is
            OpenAI's
          example: gpt-6-luna
        input:
          description: A string of text, or user messages with text and image parts
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/DecisionInputMessage'
        questions:
          type: array
          minItems: 1
          description: Questions in the order asked. Answers follow the same order.
          items:
            $ref: '#/components/schemas/OpenAIDecisionQuestion'
        safety_identifier:
          type:
            - string
            - 'null'
          description: Stable end-user identifier, forwarded to OpenAI
        fallbacks:
          type: array
          items:
            type: string
          description: >-
            Bifrost fallback models in provider/model format; never sent
            upstream
    OpenAIDecisionResponse:
      type: object
      description: >-
        OpenAI's Decision object, plus Bifrost's extra_fields as on the other
        OpenAI routes. Every model's answers are returned in this shape, and it
        carries no id. When raw responses are enabled and OpenAI served the
        request, OpenAI's own response body is returned instead, as on the other
        OpenAI routes.
      required:
        - model
        - answers
      properties:
        model:
          type: string
          description: Model that performed the decision
        answers:
          type: array
          description: One answer per question, in question order
          items:
            $ref: '#/components/schemas/DecisionAnswer'
        usage:
          type: object
          properties:
            input_tokens:
              type: integer
            input_tokens_details:
              type: object
              description: Present when the provider reports it
              properties:
                cached_tokens:
                  type: integer
                cache_write_tokens:
                  type: integer
            output_tokens:
              type: integer
            output_tokens_details:
              type: object
              description: Present when the provider reports it
              properties:
                reasoning_tokens:
                  type: integer
            total_tokens:
              type: integer
            state_tokens:
              type: integer
              description: Laya only
            state_tokens_dropped:
              type: integer
              description: Laya only
            truncated:
              type: boolean
              description: Laya only
            truncated_questions:
              type: array
              items:
                type: string
              description: Laya only
        routing:
          type: object
          description: >-
            Laya only. The checkpoint that answered and why, passed through
            untouched
        extra_fields:
          $ref: '#/components/schemas/BifrostResponseExtraFields'
          description: >-
            Bifrost's response metadata (provider, latency, routing info, and
            the raw provider body when raw responses are on), as on the other
            OpenAI routes
    BifrostError:
      type: object
      description: Error response from Bifrost
      properties:
        event_id:
          type: string
        type:
          type: string
        is_bifrost_error:
          type: boolean
        status_code:
          type: integer
        error:
          $ref: '#/components/schemas/ErrorField'
        extra_fields:
          $ref: '#/components/schemas/BifrostErrorExtraFields'
    DecisionInputMessage:
      type: object
      required:
        - role
        - content
      properties:
        type:
          type: string
          enum:
            - message
          description: Optional item type, as OpenAI's SDKs send it
        role:
          type: string
          example: user
        content:
          description: Text, or an array of parts
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/DecisionInputPart'
    OpenAIDecisionQuestion:
      type: object
      additionalProperties: false
      required:
        - type
        - instructions
      properties:
        type:
          type: string
          enum:
            - predicate
            - choice
            - score
        name:
          type: string
        instructions:
          type: string
        choices:
          type: array
          description: Choice only
          items:
            type: object
            additionalProperties: false
            required:
              - value
            properties:
              value:
                oneOf:
                  - type: string
                  - type: boolean
              description:
                type: string
        levels:
          type: array
          description: Score only, in order
          items:
            type: object
            additionalProperties: false
            required:
              - label
            properties:
              label:
                type: string
              description:
                type: string
    DecisionAnswer:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          description: The question's type, or `refusal` when the model declined to answer
          example: choice
        name:
          type:
            - string
            - 'null'
          description: >-
            The question's name, when it had one. OpenAI sends null for an
            unnamed question
        probability:
          type: number
          description: Predicate answers. Probability in [0,1] that the condition is true
        choice:
          description: Choice answers. The chosen value
          oneOf:
            - type: string
            - type: boolean
        score:
          type: number
          description: Score answers. Probability-weighted level index
        probabilities:
          type: array
          description: >-
            Distribution over choices or levels, in question order, when
            supplied
          items:
            type: object
            properties:
              value:
                description: The choice value, or the level index
                oneOf:
                  - type: string
                  - type: boolean
                  - type: number
              label:
                type: string
                description: Score answers. The level's label
              probability:
                type: number
        confidence:
          type: number
          description: Model confidence for this answer, when supplied
        legend:
          type: object
          additionalProperties: {}
          description: Score answers. Level index to description, when supplied
        answer_confidence:
          type: number
          description: Laya only. Calibrated probability of the reported answer
        action:
          type: object
          description: Laya only. Action head output, passed through untouched
        abstention:
          type: string
          enum:
            - passed
            - abstained
            - unevaluated
          description: Laya only, when `min_confidence` is set
        abstention_threshold:
          type: number
          description: Laya only, when `min_confidence` is set
        low_confidence:
          type: boolean
          description: Laya only, when `min_confidence` is set
    BifrostResponseExtraFields:
      type: object
      description: Additional fields included in responses
      properties:
        request_type:
          type: string
          description: Type of request that was made
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model_requested:
          type: string
          description: The model that was requested
        model_deployment:
          type: string
          description: The actual model deployment used
        latency:
          type: integer
          format: int64
          description: Request latency in milliseconds
        chunk_index:
          type: integer
          description: Index of the chunk for streaming responses
        raw_request:
          type: object
          description: Raw request if enabled
        raw_response:
          type: object
          description: Raw response if enabled
        cache_debug:
          $ref: '#/components/schemas/BifrostCacheDebug'
    ErrorField:
      type: object
      properties:
        type:
          type: string
        code:
          type: string
        message:
          type: string
        param:
          type: string
        event_id:
          type: string
    BifrostErrorExtraFields:
      type: object
      properties:
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model_requested:
          type: string
        request_type:
          type: string
        error_type:
          type: string
          description: >-
            Normalized, low-cardinality classification of why the request
            failed, declared by whichever component refused it. Prefixed by
            fault domain (caller_, policy_, provider_, bifrost_). Absent on
            failures that were not classified at source.
        retry_after_ms:
          type: integer
          format: int64
          minimum: 1000
          maximum: 300000
          description: >-
            The provider's hint for how long to wait before retrying, in
            milliseconds, read from its retry-after-ms or Retry-After header or
            its google.rpc.RetryInfo error detail, and clamped to between 1000
            and 300000. Absent when the provider gave no explicit hint.
    DecisionInputPart:
      description: One part of a message's content
      oneOf:
        - $ref: '#/components/schemas/DecisionInputText'
        - $ref: '#/components/schemas/DecisionInputImage'
    ModelProvider:
      type: string
      description: AI model provider identifier
      enum:
        - anthropic
        - azure
        - bedrock
        - bedrock_mantle
        - cerebras
        - cohere
        - deepseek
        - gemini
        - groq
        - mistral
        - ollama
        - opencode-go
        - opencode-zen
        - openai
        - parasail
        - perplexity
        - sgl
        - vertex
        - openrouter
        - elevenlabs
        - huggingface
        - nebius
        - xai
        - replicate
        - vllm
        - runway
        - runware
        - fireworks
        - sarvam
        - wafer
        - databricks
        - typesafe
    BifrostCacheDebug:
      type: object
      properties:
        cache_hit:
          type: boolean
        cache_id:
          type: string
        hit_type:
          type: string
        requested_provider:
          type: string
        requested_model:
          type: string
        provider_used:
          type: string
        model_used:
          type: string
        input_tokens:
          type: integer
        threshold:
          type: number
        similarity:
          type: number
    DecisionInputText:
      type: object
      required:
        - type
        - text
      properties:
        type:
          type: string
          enum:
            - input_text
        text:
          type: string
    DecisionInputImage:
      type: object
      required:
        - type
        - image_url
      properties:
        type:
          type: string
          enum:
            - input_image
        image_url:
          type: string
          description: A base64 data URL or an HTTP(S) URL
        detail:
          type: string
          enum:
            - low
            - high
            - auto
            - original
          description: >-
            Image detail level, forwarded to models that read images (OpenAI's
            defaults to `auto`)
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >
        Bearer token authentication. Use your provider API key or Bifrost
        authentication token.

        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    BasicAuth:
      type: http
      scheme: basic
      description: >
        Basic authentication using the Bifrost admin username and password

        (`auth_config.admin_username` / `auth_config.admin_password`).

        Accepted on management APIs (`/api/*`, `/metrics`, `/ws`) only - the
        inference

        middleware never validates Basic credentials.
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: |
        API key authentication via the `x-api-key` header.
        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    VirtualKeyAuth:
      type: apiKey
      in: header
      name: x-bf-vk
      description: >
        Bifrost Virtual Key for governance, routing, and access control.
        Supported on all inference endpoints (`/v1/*`, `/openai/*`,
        `/anthropic/*`, `/bedrock/*`, `/cohere/*`, `/genai/*`, `/langchain/*`,
        `/litellm/*`, `/pydanticai/*`, `/mcp`), not on management APIs
        (`/api/*`) - with the single

        exception of the self-service `GET /api/governance/virtual-keys/quota`,
        where the virtual key is the credential.

        Example: `sk-bf-*` prefixed keys.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.