265 lines
8.7 KiB
TypeScript
265 lines
8.7 KiB
TypeScript
export const dynamic = 'force-dynamic'
|
||
export const runtime = 'nodejs'
|
||
|
||
import { NextResponse } from 'next/server'
|
||
|
||
import { voiceBus } from '@/lib/voice-bus'
|
||
import { systemPrompt } from '@/lib/voice-prompts'
|
||
import { TOOL_SCHEMAS, executeTool } from '@/lib/tools/_registry'
|
||
import { cleanForSpeech, stripFillers, isResetCommand } from '@/lib/voice-text'
|
||
import {
|
||
loadHistory, saveHistory, resetHistory,
|
||
HistoryMessage,
|
||
} from '@/lib/voice-history'
|
||
|
||
const MODEL = process.env.CLAUDE_MODEL || 'claude-haiku-4-5'
|
||
const MAX_TOKENS = parseInt(process.env.VOICE_MAX_TOKENS || '300', 10)
|
||
const MAX_TOOL_ROUNDS = 4
|
||
const RATE_LIMIT_PER_MINUTE = parseInt(process.env.VOICE_RATE_LIMIT || '20', 10)
|
||
|
||
const AI_PROXY_URL = process.env.AI_PROXY_URL || 'http://192.168.31.103:3301'
|
||
const AI_PROXY_KEY = process.env.AI_PROXY_KEY || 'review-bot-proxy-d3ff719d7c87e529909c09fadcbf2748'
|
||
|
||
// Rate limit
|
||
const rateBuckets = new Map<string, { count: number; resetAt: number }>()
|
||
function rateLimit(key: string): boolean {
|
||
const now = Date.now()
|
||
const b = rateBuckets.get(key)
|
||
if (!b || b.resetAt <= now) {
|
||
rateBuckets.set(key, { count: 1, resetAt: now + 60_000 })
|
||
return true
|
||
}
|
||
if (b.count >= RATE_LIMIT_PER_MINUTE) return false
|
||
b.count++
|
||
return true
|
||
}
|
||
let lastSweep = 0
|
||
function sweep() {
|
||
const now = Date.now()
|
||
if (now - lastSweep < 5 * 60_000) return
|
||
lastSweep = now
|
||
for (const [k, v] of rateBuckets) if (v.resetAt <= now) rateBuckets.delete(k)
|
||
}
|
||
|
||
// Convert OpenAI-style tool schemas to Anthropic format
|
||
function toAnthropicTools(tools: any[]): any[] {
|
||
return tools.map(t => ({
|
||
name: t.function.name,
|
||
description: t.function.description || '',
|
||
input_schema: t.function.parameters || { type: 'object', properties: {} },
|
||
}))
|
||
}
|
||
|
||
// Convert history (OpenAI format) to Anthropic messages format
|
||
// History may contain tool calls — need to convert
|
||
function historyToAnthropicMessages(history: HistoryMessage[]): any[] {
|
||
const result: any[] = []
|
||
for (const msg of history) {
|
||
if (msg.role === 'system') continue // skip, goes in system field
|
||
if (msg.role === 'user') {
|
||
result.push({ role: 'user', content: msg.content || '' })
|
||
} else if (msg.role === 'assistant') {
|
||
if (msg.tool_calls && msg.tool_calls.length > 0) {
|
||
// Assistant with tool calls
|
||
const content: any[] = []
|
||
if (msg.content) content.push({ type: 'text', text: msg.content })
|
||
for (const tc of msg.tool_calls) {
|
||
let input: any = {}
|
||
try { input = JSON.parse(tc.function.arguments) } catch {}
|
||
content.push({ type: 'tool_use', id: tc.id, name: tc.function.name, input })
|
||
}
|
||
result.push({ role: 'assistant', content })
|
||
} else {
|
||
result.push({ role: 'assistant', content: msg.content || '' })
|
||
}
|
||
} else if (msg.role === 'tool') {
|
||
// Tool result goes as user message
|
||
const last = result[result.length - 1]
|
||
const toolResultBlock = {
|
||
type: 'tool_result',
|
||
tool_use_id: msg.tool_call_id,
|
||
content: msg.content || '',
|
||
}
|
||
if (last && last.role === 'user' && Array.isArray(last.content)) {
|
||
last.content.push(toolResultBlock)
|
||
} else {
|
||
result.push({ role: 'user', content: [toolResultBlock] })
|
||
}
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
async function claudeRequest(model: string, system: string, messages: any[], tools?: any[]): Promise<any> {
|
||
const body: any = {
|
||
model,
|
||
max_tokens: MAX_TOKENS,
|
||
system,
|
||
messages,
|
||
}
|
||
if (tools && tools.length > 0) {
|
||
body.tools = tools
|
||
}
|
||
|
||
const res = await fetch(`${AI_PROXY_URL}/v1/messages`, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'X-Proxy-Key': AI_PROXY_KEY,
|
||
'anthropic-version': '2023-06-01',
|
||
},
|
||
body: JSON.stringify(body),
|
||
})
|
||
|
||
if (!res.ok) {
|
||
const err = await res.text()
|
||
throw new Error(`claude_proxy_${res.status}: ${err}`)
|
||
}
|
||
return res.json()
|
||
}
|
||
|
||
type AgentId = 'cosmo' | 'lusya'
|
||
|
||
function emitVoice(event: string, agent: AgentId, text?: string) {
|
||
voiceBus.emit('voice', {
|
||
event, agent, text,
|
||
timestamp: new Date().toISOString(),
|
||
})
|
||
}
|
||
|
||
export async function POST(req: Request) {
|
||
const cookie = req.headers.get('cookie') || ''
|
||
const tokenMatch = cookie.match(/auth_token=([a-f0-9]{32,})/i)
|
||
const internal = req.headers.get('x-voice-internal') || ''
|
||
const fwd = req.headers.get('x-forwarded-for') || ''
|
||
const ratekey = tokenMatch?.[1] || (internal ? 'internal' : '') || fwd.split(',')[0].trim() || 'anon'
|
||
sweep()
|
||
if (!rateLimit(ratekey)) {
|
||
return NextResponse.json({ error: 'rate_limited' }, { status: 429 })
|
||
}
|
||
|
||
const body = await req.json().catch(() => null)
|
||
if (!body || typeof body.text !== 'string' || !body.text.trim()) {
|
||
return NextResponse.json({ error: 'text required' }, { status: 400 })
|
||
}
|
||
const userText: string = body.text.trim().slice(0, 4000)
|
||
const agent: AgentId = body.agent === 'lusya' ? 'lusya' : 'cosmo'
|
||
|
||
emitVoice('command', agent, userText)
|
||
|
||
if (isResetCommand(userText)) {
|
||
await resetHistory(agent)
|
||
const msg = 'Начинаю новую сессию.'
|
||
emitVoice('response', agent, msg)
|
||
return NextResponse.json({ text: msg, reset: true })
|
||
}
|
||
|
||
const history = await loadHistory(agent)
|
||
const sysPrompt = systemPrompt(agent)
|
||
const anthropicTools = toAnthropicTools(TOOL_SCHEMAS as any[])
|
||
|
||
// Build messages array
|
||
const messages: any[] = [
|
||
...historyToAnthropicMessages(history),
|
||
{ role: 'user', content: userText },
|
||
]
|
||
|
||
let finalText = ''
|
||
// Track new turns for history saving
|
||
const newTurns: HistoryMessage[] = [{ role: 'user', content: userText }]
|
||
|
||
try {
|
||
for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
|
||
const t0 = Date.now()
|
||
const resp = await claudeRequest(MODEL, sysPrompt, messages, anthropicTools)
|
||
|
||
console.log(
|
||
`[voice/chat] ${agent} round ${round + 1} ${Date.now() - t0}ms · ` +
|
||
`stop=${resp.stop_reason} · in=${resp.usage?.input_tokens} out=${resp.usage?.output_tokens}`
|
||
)
|
||
|
||
const content: any[] = resp.content || []
|
||
const stopReason: string = resp.stop_reason || 'end_turn'
|
||
|
||
if (stopReason === 'tool_use') {
|
||
const toolUseBlocks = content.filter((b: any) => b.type === 'tool_use')
|
||
const textBlocks = content.filter((b: any) => b.type === 'text')
|
||
const partialText = textBlocks.map((b: any) => b.text).join('')
|
||
|
||
// Add assistant message to messages
|
||
messages.push({ role: 'assistant', content })
|
||
newTurns.push({
|
||
role: 'assistant',
|
||
content: partialText || null,
|
||
tool_calls: toolUseBlocks.map((b: any) => ({
|
||
id: b.id,
|
||
function: { name: b.name, arguments: JSON.stringify(b.input) },
|
||
})),
|
||
})
|
||
|
||
// Execute tools and collect results
|
||
const toolResults: any[] = []
|
||
for (const tb of toolUseBlocks) {
|
||
console.log(`[voice/chat] tool ${tb.name}(${JSON.stringify(tb.input).slice(0, 200)})`)
|
||
const result = await executeTool(tb.name, tb.input || {}, agent)
|
||
toolResults.push({
|
||
type: 'tool_result',
|
||
tool_use_id: tb.id,
|
||
content: JSON.stringify(result),
|
||
})
|
||
newTurns.push({
|
||
role: 'tool',
|
||
content: JSON.stringify(result),
|
||
tool_call_id: tb.id,
|
||
})
|
||
}
|
||
|
||
// Add tool results as user message
|
||
messages.push({ role: 'user', content: toolResults })
|
||
continue
|
||
}
|
||
|
||
// end_turn — final response
|
||
const textBlocks = content.filter((b: any) => b.type === 'text')
|
||
finalText = textBlocks.map((b: any) => b.text).join('')
|
||
|
||
newTurns.push({ role: 'assistant', content: finalText })
|
||
break
|
||
}
|
||
} catch (e: any) {
|
||
const errStr = String(e?.message || e)
|
||
console.error('[voice/chat] claude error:', errStr)
|
||
const msg = 'Что-то сломалось.'
|
||
emitVoice('error', agent, msg)
|
||
return NextResponse.json({ error: 'llm_failed', detail: errStr, text: msg }, { status: 502 })
|
||
}
|
||
|
||
if (!finalText.trim()) {
|
||
const msg = 'Не получил ответ.'
|
||
emitVoice('error', agent, msg)
|
||
return NextResponse.json({ text: msg }, { status: 200 })
|
||
}
|
||
|
||
// Save history
|
||
const updatedHistory: HistoryMessage[] = [...history, ...newTurns]
|
||
await saveHistory(agent, updatedHistory)
|
||
|
||
// Filter any tool call artifacts from text
|
||
const filteredText = finalText
|
||
.split('\n')
|
||
.filter(line => {
|
||
const l = line.trim()
|
||
return !(
|
||
/^(get_|set_|control_|create_|update_|delete_|cancel_)[a-z_]+\s/.test(l) ||
|
||
l.startsWith('<function') ||
|
||
l.startsWith('function=')
|
||
)
|
||
})
|
||
.join('\n')
|
||
.trim()
|
||
|
||
const cleaned = cleanForSpeech(stripFillers(filteredText || finalText))
|
||
emitVoice('response', agent, cleaned)
|
||
return NextResponse.json({ text: cleaned })
|
||
}
|