OpenAI

import OpenAI from 'openai'
import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions'
import { pyasFunctionDefinitions, runPyasToolCalls, type PyasPendingToolCall } from '@pyas/ai-tools/openai'

const openai = new OpenAI()

/** One person's conversation with the assistant. Save it between requests, for example in your database. */
export interface Conversation {
    messages: ChatCompletionMessageParam[]
    /** Changes waiting for the person, with the results that go back to the model alongside them. */
    waiting?: { results: ChatCompletionMessageParam[]; pending: PyasPendingToolCall[] }
}

/** What to show the person: the assistant's reply, or the changes waiting for their approval. */
export type Turn =
    | { reply: string }
    | { changes: Array<Pick<PyasPendingToolCall, 'id' | 'title' | 'input' | 'event'>> }

export function newConversation(): Conversation {
    // The same for the whole conversation. Today's date lets the model work out "tomorrow".
    const today = new Date().toISOString().slice(0, 10)
    return { messages: [{ role: 'system', content: `You help the user manage their calendar. Today is ${today}.` }] }
}

/** The person sends a message. */
export async function ask(conversation: Conversation, userId: string, text: string): Promise<Turn> {
    conversation.messages.push({ role: 'user', content: text })
    return run(conversation, userId)
}

/** The person answers the changes: the ids they approved. Every other change is declined. */
export async function answer(conversation: Conversation, userId: string, approved: string[]): Promise<Turn> {
    if (!conversation.waiting) throw new Error('No change is waiting for an answer.')
    const { results, pending } = conversation.waiting
    const declined = pending.map((change) => change.id).filter((id) => !approved.includes(id))
    const answered = await runPyasToolCalls(pending.map((change) => change.call), { subjectId: userId, approved, declined })
    conversation.messages.push(...results, ...answered.results)
    conversation.waiting = undefined
    return run(conversation, userId)
}

async function run(conversation: Conversation, userId: string): Promise<Turn> {
    const options = { subjectId: userId }
    for (let step = 0; step < 10; step++) {
        const response = await openai.chat.completions.create({
            model: 'gpt-5.5',
            messages: conversation.messages,
            tools: pyasFunctionDefinitions(options),
        })
        const message = response.choices[0].message
        conversation.messages.push(message)
        if (!message.tool_calls?.length) return { reply: message.content ?? '' }

        // Reads run now. Changes come back in pending, and nothing is sent to Pyas until the person approves.
        const { results, pending } = await runPyasToolCalls(message.tool_calls, options)
        if (pending.length) {
            conversation.waiting = { results, pending }
            return { changes: pending.map(({ id, title, input, event }) => ({ id, title, input, event })) }
        }
        conversation.messages.push(...results)
    }
    return { reply: 'I stopped before finishing. Please ask again.' }
}