@lota-sdk/core 0.1.17 → 0.1.19

package/src/bifrost/bifrost.ts

@@ -1,325 +0,0 @@
-import { devToolsMiddleware } from '@ai-sdk/devtools'
-import { createOpenAI } from '@ai-sdk/openai'
-import { wrapLanguageModel } from 'ai'
-import type { LanguageModelMiddleware } from 'ai'
-
-import { getRequiredEnv } from '../utils/env'
-import { isRecord, readString } from '../utils/string'
-
-type BifrostLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
-type BifrostExtraParams = Record<string, unknown>
-type BifrostChatResponse = { body?: unknown }
-type BifrostTransformParamsOptions = Parameters<NonNullable<LanguageModelMiddleware['transformParams']>>[0]
-type WrapStreamOptions = Parameters<NonNullable<LanguageModelMiddleware['wrapStream']>>[0]
-type BifrostCallOptions = WrapStreamOptions['params']
-type BifrostGenerateResult = Awaited<ReturnType<WrapStreamOptions['doGenerate']>>
-type BifrostStreamResult = Awaited<ReturnType<WrapStreamOptions['doStream']>>
-type BifrostGeneratedContent = BifrostGenerateResult['content'][number]
-type BifrostStreamPart = BifrostStreamResult['stream'] extends ReadableStream<infer T> ? T : never
-
-const OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS = {
-  plugins: [{ id: 'response-healing' }],
-} as const satisfies BifrostExtraParams
-
-function readRequiredGatewayEnv(name: 'AI_GATEWAY_KEY' | 'AI_GATEWAY_URL'): string {
-  return getRequiredEnv(name).trim()
-}
-
-function readReasoningDetailsText(value: unknown): string | null {
-  if (!Array.isArray(value)) return null
-
-  const textParts = value
-    .map((item) => (isRecord(item) ? readString(item.text) : null))
-    .filter((item): item is string => item !== null)
-
-  if (textParts.length === 0) return null
-
-  return textParts.join('\n\n')
-}
-
-function readReasoningDeltaText(value: unknown): string | null {
-  return typeof value === 'string' && value.length > 0 ? value : null
-}
-
-function readBifrostChatReasoningText(message: Record<string, unknown>): string | null {
-  return (
-    readString(message.reasoning) ??
-    readString(message.reasoning_content) ??
-    readReasoningDetailsText(message.reasoning_details)
-  )
-}
-
-export function extractBifrostChatReasoningText(responseBody: unknown): string | null {
-  if (!isRecord(responseBody) || !Array.isArray(responseBody.choices)) return null
-
-  for (const choice of responseBody.choices) {
-    if (!isRecord(choice) || !isRecord(choice.message)) continue
-
-    const reasoningText = readBifrostChatReasoningText(choice.message)
-    if (reasoningText) return reasoningText
-  }
-
-  return null
-}
-
-export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string | null {
-  if (!isRecord(rawChunk) || !Array.isArray(rawChunk.choices)) return null
-
-  for (const choice of rawChunk.choices) {
-    if (!isRecord(choice) || !isRecord(choice.delta)) continue
-
-    const reasoningText =
-      readReasoningDeltaText(choice.delta.reasoning) ??
-      readReasoningDeltaText(choice.delta.reasoning_content) ??
-      readReasoningDetailsText(choice.delta.reasoning_details)
-    if (reasoningText) return reasoningText
-  }
-
-  return null
-}
-
-type BifrostResponsesReasoningDelta = { id: string; delta: string; itemId: string }
-
-export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): BifrostResponsesReasoningDelta | null {
-  if (!isRecord(rawChunk) || rawChunk.type !== 'response.reasoning_summary_text.delta') return null
-  if ('summary_index' in rawChunk) return null
-
-  const itemId = readString(rawChunk.item_id)
-  const delta = readReasoningDeltaText(rawChunk.delta)
-  if (!itemId || !delta) return null
-
-  return { id: `${itemId}:0`, delta, itemId }
-}
-
-export function injectBifrostChatReasoningContent(
-  content: readonly BifrostGeneratedContent[],
-  response?: BifrostChatResponse,
-): BifrostGeneratedContent[] {
-  if (content.some((part) => part.type === 'reasoning')) {
-    return [...content]
-  }
-
-  const reasoningText = extractBifrostChatReasoningText(response?.body)
-  if (!reasoningText) return [...content]
-
-  return [{ type: 'reasoning', text: reasoningText }, ...content]
-}
-
-function isReasoningEnabled(params: BifrostCallOptions): boolean {
-  if (!isRecord(params.providerOptions) || !isRecord(params.providerOptions.openai)) return false
-
-  const openaiOptions = params.providerOptions.openai
-  if (openaiOptions.forceReasoning === true) return true
-  if (typeof openaiOptions.reasoningSummary === 'string' && openaiOptions.reasoningSummary.length > 0) return true
-  return typeof openaiOptions.reasoningEffort === 'string' && openaiOptions.reasoningEffort !== 'none'
-}
-
-function shouldCloseInjectedReasoning(chunk: BifrostStreamPart): boolean {
-  return chunk.type !== 'stream-start' && chunk.type !== 'response-metadata' && chunk.type !== 'raw'
-}
-
-export function injectBifrostChatReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
-  const reasoningId = 'bifrost-reasoning-0'
-  let reasoningOpen = false
-  let reasoningClosed = false
-
-  return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
-      transform(chunk, controller) {
-        const closeReasoning = () => {
-          if (!reasoningOpen || reasoningClosed) return
-
-          controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
-          reasoningClosed = true
-        }
-
-        if (chunk.type === 'raw') {
-          const reasoningDelta = reasoningClosed ? null : extractBifrostChatReasoningDeltaText(chunk.rawValue)
-          controller.enqueue(chunk)
-
-          if (reasoningDelta) {
-            if (!reasoningOpen) {
-              controller.enqueue({ type: 'reasoning-start', id: reasoningId } satisfies BifrostStreamPart)
-              reasoningOpen = true
-            }
-
-            controller.enqueue({
-              type: 'reasoning-delta',
-              id: reasoningId,
-              delta: reasoningDelta,
-            } satisfies BifrostStreamPart)
-          }
-          return
-        }
-
-        if (shouldCloseInjectedReasoning(chunk)) {
-          closeReasoning()
-        }
-
-        controller.enqueue(chunk)
-      },
-      flush(controller) {
-        if (!reasoningOpen || reasoningClosed) return
-        controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
-      },
-    }),
-  )
-}
-
-export function injectBifrostResponsesReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
-  return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
-      transform(chunk, controller) {
-        controller.enqueue(chunk)
-
-        if (chunk.type !== 'raw') return
-
-        const reasoningDelta = extractBifrostResponsesReasoningDelta(chunk.rawValue)
-        if (!reasoningDelta) return
-
-        controller.enqueue({
-          type: 'reasoning-delta',
-          id: reasoningDelta.id,
-          delta: reasoningDelta.delta,
-          providerMetadata: { openai: { itemId: reasoningDelta.itemId } },
-        } satisfies BifrostStreamPart)
-      },
-    }),
-  )
-}
-
-function addBifrostReasoningRawChunks(
-  params: BifrostCallOptions,
-  type: BifrostTransformParamsOptions['type'],
-): BifrostCallOptions {
-  if (type !== 'stream' || !isReasoningEnabled(params) || params.includeRawChunks === true) {
-    return params
-  }
-
-  return { ...params, includeRawChunks: true }
-}
-
-export function injectBifrostExtraParamsRequestBody(
-  body: BodyInit | null | undefined,
-  extraParams: BifrostExtraParams,
-): BodyInit | null | undefined {
-  if (typeof body !== 'string') return body
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(body)
-  } catch {
-    return body
-  }
-
-  if (!isRecord(parsed)) return body
-
-  const mergedExtraParams = isRecord(parsed.extra_params)
-    ? { ...parsed.extra_params, ...extraParams }
-    : { ...extraParams }
-
-  return JSON.stringify({ ...parsed, extra_params: mergedExtraParams })
-}
-
-function createBifrostFetchWithExtraParams(extraParams: BifrostExtraParams): typeof fetch {
-  const fetchWithExtraParams = (input: RequestInfo | URL, init?: RequestInit | BunFetchRequestInit) =>
-    globalThis.fetch(input, { ...init, body: injectBifrostExtraParamsRequestBody(init?.body, extraParams) })
-
-  return Object.assign(fetchWithExtraParams, { preconnect: globalThis.fetch.preconnect.bind(globalThis.fetch) })
-}
-
-function createBifrostProvider(extraParams?: BifrostExtraParams) {
-  const apiKey = readRequiredGatewayEnv('AI_GATEWAY_KEY')
-  if (!apiKey.startsWith('sk-bf-')) {
-    throw new Error('[bifrost] AI_GATEWAY_KEY must use the Bifrost virtual-key format (sk-bf-*).')
-  }
-
-  return createOpenAI({
-    baseURL: readRequiredGatewayEnv('AI_GATEWAY_URL'),
-    apiKey,
-    headers: { 'x-bf-vk': apiKey, ...(extraParams ? { 'x-bf-passthrough-extra-params': 'true' } : {}) },
-    ...(extraParams ? { fetch: createBifrostFetchWithExtraParams(extraParams) } : {}),
-  })
-}
-
-function withBifrostDevTools<TModel extends BifrostLanguageModel>(model: TModel): TModel {
-  return wrapLanguageModel({ model, middleware: devToolsMiddleware() }) as TModel
-}
-
-let provider: ReturnType<typeof createOpenAI> | null = null
-let openRouterResponseHealingProvider: ReturnType<typeof createOpenAI> | null = null
-
-export function getBifrostProvider() {
-  if (provider) return provider
-
-  provider = createBifrostProvider()
-
-  return provider
-}
-
-export function getBifrostOpenRouterResponseHealingProvider() {
-  if (openRouterResponseHealingProvider) return openRouterResponseHealingProvider
-
-  openRouterResponseHealingProvider = createBifrostProvider(OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS)
-
-  return openRouterResponseHealingProvider
-}
-
-export function bifrostModel(modelId: string) {
-  return withBifrostDevTools(
-    wrapLanguageModel({
-      model: getBifrostProvider()(modelId),
-      middleware: {
-        specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
-        wrapStream: async ({ doStream, params }) => {
-          const result = await doStream()
-          if (!isReasoningEnabled(params)) return result
-
-          return { ...result, stream: injectBifrostResponsesReasoningStream(result.stream) }
-        },
-      },
-    }),
-  )
-}
-
-export function bifrostOpenRouterResponseHealingModel(modelId: string) {
-  return withBifrostDevTools(getBifrostOpenRouterResponseHealingProvider()(modelId))
-}
-
-export function bifrostChatModel(modelId: string) {
-  return withBifrostDevTools(
-    wrapLanguageModel({
-      model: getBifrostProvider().chat(modelId),
-      middleware: {
-        specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
-        wrapGenerate: async ({ doGenerate }) => {
-          const result = await doGenerate()
-
-          return {
-            ...result,
-            content: injectBifrostChatReasoningContent(
-              result.content,
-              result.response as BifrostChatResponse | undefined,
-            ),
-          }
-        },
-        wrapStream: async ({ doStream, params }) => {
-          const result = await doStream()
-          if (!isReasoningEnabled(params)) return result
-
-          return { ...result, stream: injectBifrostChatReasoningStream(result.stream) }
-        },
-      },
-    }),
-  )
-}
-
-export function bifrostEmbeddingModel(modelId: string) {
-  return getBifrostProvider().embeddingModel(modelId)
-}

package/src/bifrost/cache-headers.ts

@@ -1,8 +0,0 @@
-const BIFROST_CACHE_KEY_HEADER = 'x-bf-cache-key'
-const BIFROST_CACHE_TTL_HEADER = 'x-bf-cache-ttl'
-
-export function buildBifrostCacheHeaders(cacheKey: string, ttl?: string): Record<string, string> {
-  const headers: Record<string, string> = { [BIFROST_CACHE_KEY_HEADER]: cacheKey }
-  if (ttl) headers[BIFROST_CACHE_TTL_HEADER] = ttl
-  return headers
-}