Quickstart

const express = require('express');
const app = express();
app.use(express.json());

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
    console.log(`Agent server running on port ${PORT}`);
});

app.post('/v1/chat', async (req, res) => {
    try {
    const { messages, stream = false } = req.body;
    
    // Get thread ID from header if present (for stateful conversations)
    const threadId = req.headers['x-thread-id'] || 'default';
    
    if (stream) {
        // Set up SSE streaming
        res.setHeader('Content-Type', 'text/event-stream');
        res.setHeader('Cache-Control', 'no-cache');
        res.setHeader('Connection', 'keep-alive');
        
        // Process messages and stream response
        await streamResponse(res, messages, threadId);
    } else {
        // Process messages and return complete response
        const response = await processMessages(messages, threadId);
        res.json(response);
    }
    } catch (error) {
    console.error('Error processing chat request:', error);
    res.status(500).json({ error: 'Internal server error' });
    }
});

app.get('/v1/agents', (req, res) => {
    res.json({
        agents: [
        {
            name: 'My Custom Agent',
            description: 'A specialized agent that helps with specific tasks',
            provider: {
            organization: 'Your Organization',
            url: 'https://your-organization.com'
            },
            version: '1.0.0',
            capabilities: {
            streaming: true
            }
        }
        ]
    });
});

async function processMessages(messages, threadId) {
    // Your agent's logic to process messages and generate a response
    // This is where you would integrate with your LLM, tools, etc.

    const response = {
        id: generateId(),
        object: 'chat.completion',
        created: Math.floor(Date.now() / 1000),
        model: 'your-agent-model',
        choices: [
        {
            index: 0,
            message: {
            role: 'assistant',
            content: 'This is a response from your agent.'
            },
            finish_reason: 'stop'
        }
        ],
        usage: {
        prompt_tokens: 0,
        completion_tokens: 0,
        total_tokens: 0
        }
    };

    return response;
}

async function streamResponse(res, messages, threadId) {
    // Example of streaming a response with thinking steps and tool calls

    // Stream thinking step
    const thinkingStep = {
        id: `step-${generateId()}`,
        object: 'thread.run.step.delta',
        thread_id: threadId,
        model: 'your-agent-model',
        created: Math.floor(Date.now() / 1000),
        choices: [
        {
            delta: {
            role: 'assistant',
            step_details: {
                type: 'thinking',
                content: 'Analyzing the user request and determining the best approach...'
            }
            }
        }
        ]
    };

    res.write(`event: thread.run.step.delta\n`);
    res.write(`data: ${JSON.stringify(thinkingStep)}\n\n`);

    // Wait a moment to simulate processing
    await new Promise(resolve => setTimeout(resolve, 1000));

    // Stream final message
    const messageChunk = {
        id: `msg-${generateId()}`,
        object: 'thread.message.delta',
        thread_id: threadId,
        model: 'your-agent-model',
        created: Math.floor(Date.now() / 1000),
        choices: [
        {
            delta: {
            role: 'assistant',
            content: 'This is a streamed response from your agent.'
            }
        }
        ]
    };

    res.write(`event: thread.message.delta\n`);
    res.write(`data: ${JSON.stringify(messageChunk)}\n\n`);

    // End the stream
    res.end();
}

function generateId() {
    return Math.random().toString(36).substring(2, 15);
}