AI

import { buildConfig } from 'frogbot'

export default buildConfig({
  // secret, db, and collections omitted
  ai: {
    providers: {
      openai: true,
      anthropic: true,
      bedrock: true
    }
  }
})

ai: {
  defaultModel: 'vertex/gemini-3.5-flash',
  providers: {
    vertex: {
      project: 'example-project',
      location: 'global',
      anthropic: { location: 'us-east5' }
    }
  }
}

ai: {
  providers: {
    internal: {
      type: 'openai-compatible',
      baseUrl: 'https://models.internal.example/v1',
      apiKey: process.env.INTERNAL_AI_KEY,
      headers: { 'x-deployment': 'production' },
      models: [
        {
          id: 'legal-summary-v2',
          mode: 'chat',
          name: 'Legal Summary',
          limit: { context: 128_000, output: 8_000 },
          cost: { input: 0.5, output: 1.5 },
          modalities: { input: ['text', 'pdf'], output: ['text'] },
          tool_call: true,
          structured_output: true,
          reasoningOptions: [{ type: 'effort', values: ['low', 'high'] }]
        }
      ]
    }
  }
}

ai: {
  providers: {
    openai: true
  },
  routers: {
    fast: { model: 'openai/gpt-4o-mini' },
    careful: { model: 'openai/o3' }
  },
  defaultModel: 'fast'
}

ai: {
  providers: {
    openai: true
  },
  routers: {
    utility: { model: 'openai/gpt-5-nano' }
  },
  smallModel: 'utility' // or 'openai/gpt-5-nano'
}

const { text, usage, finishReason } = await req.frogbot.generateText({
  model: 'fast',
  prompt: 'Summarize the latest support request',
  req
})

generateText(opts: GenerateTextOpts)
streamText(opts: StreamTextOpts)
embed(opts: EmbedOpts)
embedMany(opts: EmbedManyOpts)
generateImage(opts: GenerateImageOpts)
generateSpeech(opts: GenerateSpeechOpts)
transcribe(opts: TranscribeOpts)
generateVideo(opts: GenerateVideoOpts)
rerank(opts: RerankOpts)
evaluate(opts: EvaluateOpts)

const result = await req.frogbot.evaluate({
  model: 'typesafe-ai/jev',
  state: { ticket: 'Customer was charged twice and requested a refund' },
  questions: {
    refunded: {
      type: 'boolean',
      instructions: 'Was a refund issued?'
    },
    team: {
      type: 'choice',
      instructions: 'Which team should handle the ticket?',
      criteria: { billing: 'Billing team', support: 'Support team' }
    },
    severity: {
      type: 'score',
      instructions: 'How urgent is this ticket?',
      criteria: ['Low', 'Medium', 'High']
    }
  },
  req
})

const refundProbability = result.answers.refunded.probability
const assignedTeam = result.answers.team.choice
const severityScore = result.answers.severity.score

import { Output } from 'frogbot'
import { z } from 'zod'

const result = await req.frogbot.generateText({
  model: 'fast',
  prompt: 'Extract the ticket number and priority',
  output: Output.object({
    schema: z.object({
      ticket: z.string(),
      priority: z.enum(['low', 'medium', 'high'])
    })
  }),
  req
})

const ticket = result.output

ai: {
  providers: {
    openai: true
  },
  access: {
    generate: ({ req, model }) => Boolean(req.user) && model !== 'openai/gpt-5.4',
    embed: ({ req }) => Boolean(req.user),
    transcribe: ({ req }) => Boolean(req.user),
    rerank: ({ req }) => Boolean(req.user),
    evaluate: ({ req }) => Boolean(req.user)
  }
}

ai: {
  providers: {
    openai: true
  },
  hooks: {
    beforeOperation: [({ context, user }) => {
      context.authenticated = Boolean(user)
    }],
    beforeUpstream: [({ headers }) => {
      headers.set('x-application', 'support')
    }],
    afterOperation: [({ durationMs, error }) => {
      console.info({ durationMs, failed: Boolean(error) })
    }]
  }
}

ai: {
  providers: {
    openai: true
  },
  deploymentId: 'support-production',
  telemetry: {
    enabled: true,
    enrichSpan: ({ operationId }) => ({
      'app.operation_id': operationId
    })
  }
}

import { createFrogBotSDK } from '@frogbotai/sdk'

const sdk = createFrogBotSDK({
  baseURL: '/api',
  fetch: (input, init) => fetch(input, { ...init, credentials: 'include' })
})

const result = await sdk.ai.transcribe({
  model: 'groq/whisper-large-v3',
  file: recording
})

const response = await sdk.ai.chat({
  model: 'openai/gpt-4o-mini',
  messages: [{ role: 'user', content: 'Hello' }]
})

const audio = await sdk.ai.speech({
  model: 'mistral/voxtral-mini-tts-latest',
  input: 'Hello'
})

curl http://localhost:3000/api/v1/chat/completions \
  --request POST \
  --header "Authorization: Bearer $FROGBOT_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "openai/gpt-4o-mini",
    "messages": [{ "role": "user", "content": "Hello" }]
  }'