api.tanchat.ts

import { createFileRoute } from '@tanstack/react-router'
import {
  chat,
  createChatOptions,
  maxIterations,
  toServerSentEventsResponse,
} from '@tanstack/ai'
import { openaiText } from '@tanstack/ai-openai'
import { ollamaText } from '@tanstack/ai-ollama'
import { anthropicText } from '@tanstack/ai-anthropic'
import { geminiText } from '@tanstack/ai-gemini'
import { openRouterText } from '@tanstack/ai-openrouter'
import { grokText } from '@tanstack/ai-grok'
import type { AnyTextAdapter, ChatMiddleware } from '@tanstack/ai'
import { groqText } from '@tanstack/ai-groq'
import {
  addToCartToolDef,
  addToWishListToolDef,
  calculateFinancing,
  compareGuitars,
  getGuitars,
  getPersonalGuitarPreferenceToolDef,
  recommendGuitarToolDef,
  searchGuitars,
} from '@/lib/guitar-tools'

type Provider =
  | 'openai'
  | 'anthropic'
  | 'gemini'
  | 'ollama'
  | 'grok'
  | 'groq'
  | 'openrouter'

const SYSTEM_PROMPT = `You are a helpful assistant for a guitar store.

CRITICAL INSTRUCTIONS - YOU MUST FOLLOW THIS EXACT WORKFLOW:

When a user asks for a guitar recommendation:
1. FIRST: Use the getGuitars tool (no parameters needed)
2. SECOND: Use the recommendGuitar tool with the ID of the guitar you want to recommend
3. NEVER write a recommendation directly - ALWAYS use the recommendGuitar tool

IMPORTANT:
- The recommendGuitar tool will display the guitar in a special, appealing format
- You MUST use recommendGuitar for ANY guitar recommendation
- ONLY recommend guitars from our inventory (use getGuitars first)
- The recommendGuitar tool has a buy button - this is how customers purchase
- Do NOT describe the guitar yourself - let the recommendGuitar tool do it

Example workflow:
User: "I want an acoustic guitar"
Step 1: Call getGuitars()
Step 2: Call recommendGuitar(id: "6")
Step 3: Done - do NOT add any text after calling recommendGuitar

`
const addToCartToolServer = addToCartToolDef.server((args, context) => {
  context?.emitCustomEvent('tool:progress', {
    tool: 'addToCart',
    message: `Adding ${args.quantity}x guitar ${args.guitarId} to cart`,
  })
  const cartId = 'CART_' + Date.now()
  context?.emitCustomEvent('tool:progress', {
    tool: 'addToCart',
    message: `Cart ${cartId} created successfully`,
  })
  return {
    success: true,
    cartId,
    guitarId: args.guitarId,
    quantity: args.quantity,
    totalItems: args.quantity,
  }
})

const loggingMiddleware: ChatMiddleware = {
  name: 'logging',
  onConfig(ctx, config) {
    console.log(
      `[logging] onConfig iteration=${ctx.iteration} model=${ctx.model} tools=${config.tools.length}`,
    )
  },
  onStart(ctx) {
    console.log(`[logging] onStart requestId=${ctx.requestId}`)
  },
  onIteration(ctx, info) {
    console.log(`[logging] onIteration iteration=${info.iteration}`)
  },
  onBeforeToolCall(ctx, toolCtx) {
    console.log(`[logging] onBeforeToolCall tool=${toolCtx.toolName}`)
  },
  onAfterToolCall(ctx, info) {
    console.log(
      `[logging] onAfterToolCall tool=${info.toolName} result=${JSON.stringify(info.result).slice(0, 100)}`,
    )
  },
  onFinish(ctx, info) {
    console.log(
      `[logging] onFinish reason=${info.finishReason} iterations=${ctx.iteration}`,
    )
  },
  onUsage(ctx, usage) {
    console.log(
      `[logging] onUsage tokens=${usage.totalTokens} input=${usage.promptTokens} output=${usage.completionTokens}, total: ${usage.totalTokens}`,
    )
  },
}

// ===========================
// TypedStreamChunk showcase — type-safe tool call events
// ===========================
//
// When `chat()` receives tools with typed schemas, the returned stream
// carries type information on TOOL_CALL_START and TOOL_CALL_END events.
// No casts, no `as any` — just narrow by `chunk.type` and everything is typed.

const tools = [
  getGuitars,
  recommendGuitarToolDef,
  addToCartToolServer,
  addToWishListToolDef,
  getPersonalGuitarPreferenceToolDef,
  compareGuitars,
  calculateFinancing,
  searchGuitars,
] as const

async function typedStreamShowcase() {
  const stream = chat({
    adapter: openaiText('gpt-4o'),
    messages: [
      { role: 'user' as const, content: 'Recommend an acoustic guitar' },
    ],
    tools,
  })

  for await (const chunk of stream) {
    switch (chunk.type) {
      case 'TOOL_CALL_START':
        // ✅ chunk.toolName is typed as the union of all tool name literals:
        //    'getGuitars' | 'recommendGuitar' | 'addToCart' | 'addToWishList'
        //    | 'getPersonalGuitarPreference' | 'compareGuitars'
        //    | 'calculateFinancing' | 'searchGuitars'
        //
        // ❌ Without TypedStreamChunk, this would just be `string`
        console.log(`Tool call started: ${chunk.toolName}`)
        break

      case 'TOOL_CALL_END':
        // ✅ chunk.toolName — same typed literal union as above
        // ✅ chunk.input   — union of all tool input types, inferred from Zod schemas:
        //    | {}
        //    | { id: string | number }
        //    | { guitarId: string; quantity: number }
        //    | { guitarId: string }
        //    | { guitarIds: number[] }
        //    | { guitarId: number; months: number }
        //    | { query: string }
        console.log(`Tool call ended: ${chunk.toolName}`, chunk.input)
        break

      case 'TEXT_MESSAGE_CONTENT':
        // Non-tool events are unaffected — still fully typed
        console.log(chunk.delta)
        break
    }
  }
}

// Suppress unused warning — this is a showcase, not called at runtime
void typedStreamShowcase

export const Route = createFileRoute('/api/tanchat')({
  server: {
    handlers: {
      POST: async ({ request }) => {
        // Capture request signal before reading body (it may be aborted after body is consumed)
        const requestSignal = request.signal

        // If request is already aborted, return early
        if (requestSignal.aborted) {
          return new Response(null, { status: 499 }) // 499 = Client Closed Request
        }

        const abortController = new AbortController()

        const body = await request.json()
        const { messages, data } = body

        // Extract provider and model from data
        const provider: Provider = data?.provider || 'openai'
        const model: string = data?.model || 'gpt-4o'
        const conversationId: string | undefined = data?.conversationId

        // Pre-define typed adapter configurations with full type inference
        // Model is passed to the adapter factory function for type-safe autocomplete
        const adapterConfig: Record<
          Provider,
          () => { adapter: AnyTextAdapter }
        > = {
          anthropic: () =>
            createChatOptions({
              adapter: anthropicText(
                (model || 'claude-sonnet-4-5') as 'claude-sonnet-4-5',
              ),
            }),
          openrouter: () =>
            createChatOptions({
              adapter: openRouterText('openai/gpt-5.1'),
              modelOptions: {
                models: ['openai/chatgpt-4o-latest'],
                route: 'fallback',
                reasoning: {
                  effort: 'medium',
                },
              },
            }),
          gemini: () =>
            createChatOptions({
              adapter: geminiText(
                (model || 'gemini-2.5-flash') as 'gemini-2.5-flash',
              ),
              modelOptions: {
                thinkingConfig: {
                  includeThoughts: true,
                  thinkingBudget: 100,
                },
              },
            }),
          grok: () =>
            createChatOptions({
              adapter: grokText((model || 'grok-3') as 'grok-3'),
              modelOptions: {},
            }),
          groq: () =>
            createChatOptions({
              adapter: groqText(
                (model ||
                  'llama-3.3-70b-versatile') as 'llama-3.3-70b-versatile',
              ),
            }),
          ollama: () =>
            createChatOptions({
              adapter: ollamaText((model || 'gpt-oss:120b') as 'gpt-oss:120b'),
              modelOptions: { think: 'low', options: { top_k: 1 } },
            }),
          openai: () =>
            createChatOptions({
              adapter: openaiText((model || 'gpt-4o') as 'gpt-4o'),
              modelOptions: {},
            }),
        }

        try {
          // Get typed adapter options using createChatOptions pattern
          const options = adapterConfig[provider]()

          // Note: We cast to AsyncIterable<StreamChunk> because all chat adapters
          // return streams, but TypeScript sees a union of all possible return types
          const stream = chat({
            ...options,

            tools: [
              getGuitars, // Server tool
              recommendGuitarToolDef, // No server execute - client will handle
              addToCartToolServer,
              addToWishListToolDef,
              getPersonalGuitarPreferenceToolDef,
              // Lazy tools - discovered on demand
              compareGuitars,
              calculateFinancing,
              searchGuitars,
            ],
            middleware: [loggingMiddleware],
            systemPrompts: [SYSTEM_PROMPT],
            agentLoopStrategy: maxIterations(20),
            messages,
            abortController,
            conversationId,
          })
          return toServerSentEventsResponse(stream, { abortController })
        } catch (error: any) {
          console.error('[API Route] Error in chat request:', {
            message: error?.message,
            name: error?.name,
            status: error?.status,
            statusText: error?.statusText,
            code: error?.code,
            type: error?.type,
            stack: error?.stack,
            error: error,
          })
          // If request was aborted, return early (don't send error response)
          if (error.name === 'AbortError' || abortController.signal.aborted) {
            return new Response(null, { status: 499 }) // 499 = Client Closed Request
          }
          return new Response(
            JSON.stringify({
              error: error.message || 'An error occurred',
            }),
            {
              status: 500,
              headers: { 'Content-Type': 'application/json' },
            },
          )
        }
      },
    },
  },
})