Build a support assistant

// server.js  (node server.js)
import http from 'node:http'
import { TOOLS, runTool } from './tools.js'
import { SYSTEM } from './prompt.js'
 
const API = 'https://app.syntic.ai/v1/chat/completions'
const HEADERS = { Authorization: `Bearer ${process.env.SYNTIC_API_KEY}`, 'Content-Type': 'application/json' }
const MODEL = process.env.SUPPORT_MODEL ?? 'Amara S1.2'
const sessions = new Map() // use a database in production
 
async function complete(body) {
  const res = await fetch(API, { method: 'POST', headers: HEADERS, body: JSON.stringify({ model: MODEL, ...body }) })
  if (!res.ok) throw Object.assign(new Error('api_error'), { status: res.status, body: await res.text() })
  return res
}
 
async function reply(session, userText, out) {
  session.messages.push({ role: 'user', content: userText })
 
  // Tool rounds: not streamed.
  for (let round = 0; round < 4; round++) {
    const res = await complete({ stream: false, max_tokens: 600, tools: TOOLS, messages: session.messages })
    const message = (await res.json()).choices[0].message
    if (!message.tool_calls?.length) break
    session.messages.push(message)
    for (const call of message.tool_calls) {
      const result = await runTool(call.function.name, JSON.parse(call.function.arguments || '{}'), session)
      session.messages.push({ role: 'tool', tool_call_id: call.id, content: JSON.stringify(result) })
    }
  }
 
  // Final answer: streamed to the browser as plain text.
  const res = await complete({ stream: true, max_tokens: 600, tool_choice: 'none', tools: TOOLS, messages: session.messages })
  const decoder = new TextDecoder()
  let buffer = ''
  let text = ''
  for await (const bytes of res.body) {
    buffer += decoder.decode(bytes, { stream: true })
    const lines = buffer.split('\n')
    buffer = lines.pop()
    for (const line of lines) {
      if (!line.startsWith('data: ') || line === 'data: [DONE]') continue
      const event = JSON.parse(line.slice(6))
      if (event.error) throw new Error(event.error) // stream_error
      const piece = event.choices?.[0]?.delta?.content
      if (piece) { text += piece; out.write(piece) }
    }
  }
  session.messages.push({ role: 'assistant', content: text })
}
 
http.createServer(async (req, res) => {
  if (req.method !== 'POST' || req.url !== '/chat') return res.writeHead(404).end()
  let raw = ''
  for await (const chunk of req) raw += chunk
  const { chatId, text } = JSON.parse(raw)
 
  const session = sessions.get(chatId) ?? { id: chatId, messages: [{ role: 'system', content: SYSTEM }] }
  sessions.set(chatId, session)
 
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' })
  try {
    await reply(session, text, res)
  } catch (err) {
    console.error(err.status, err.body ?? err.message)
    res.write('\nSorry, something went wrong on our side. Please try again in a moment.')
  }
  res.end()
}).listen(3000)

# The same reply logic with an OpenAI-compatible Python client, e.g. inside a FastAPI or Flask route.
import json
import os
 
from openai import OpenAI
 
from prompt import SYSTEM
from tools import TOOLS, run_tool  # Python versions of the tools above
 
client = OpenAI(base_url="https://app.syntic.ai/v1", api_key=os.environ["SYNTIC_API_KEY"])
MODEL = os.environ.get("SUPPORT_MODEL", "Amara S1.2")
 
 
def reply(session: dict, user_text: str):
    """Yields the final answer piece by piece; runs tool rounds first."""
    messages = session.setdefault("messages", [{"role": "system", "content": SYSTEM}])
    messages.append({"role": "user", "content": user_text})
 
    for _ in range(4):
        r = client.chat.completions.create(
            model=MODEL, stream=False, max_tokens=600, tools=TOOLS, messages=messages,
        )
        message = r.choices[0].message
        if not message.tool_calls:
            break
        messages.append(message.model_dump(exclude_none=True))
        for call in message.tool_calls:
            result = run_tool(call.function.name, json.loads(call.function.arguments or "{}"), session)
            messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
 
    text = ""
    stream = client.chat.completions.create(
        model=MODEL, stream=True, max_tokens=600, tool_choice="none", tools=TOOLS, messages=messages,
    )
    for chunk in stream:
        piece = chunk.choices[0].delta.content if chunk.choices else None
        if piece:
            text += piece
            yield piece
    messages.append({"role": "assistant", "content": text})