@hyorman/copilot-proxy-core 1.0.0

package/out/assistants/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Assistants API Module
+ *
+ * Exports all assistants-related functionality:
+ * - Types for Assistant, Thread, Message, Run, RunStep, StreamEvent
+ * - State management with persistence support
+ * - Run execution engine with streaming and native tool calling
+ * - Tool utilities for ID generation and format conversion
+ * - Express routes
+ */
+export * from './types.js';
+export { state, SerializedState, PendingToolContext } from './state.js';
+export { executeRun, executeRunNonStreaming, requestRunCancellation, isRunActive, continueRunWithToolOutputs, continueRunWithToolOutputsNonStreaming, setRunnerBackend, } from './runner.js';
+export { generateToolCallId, } from './tools.js';
+export { default as assistantsRouter } from './routes.js';

package/out/assistants/index.js

@@ -0,0 +1,16 @@
+/**
+ * Assistants API Module
+ *
+ * Exports all assistants-related functionality:
+ * - Types for Assistant, Thread, Message, Run, RunStep, StreamEvent
+ * - State management with persistence support
+ * - Run execution engine with streaming and native tool calling
+ * - Tool utilities for ID generation and format conversion
+ * - Express routes
+ */
+export * from './types.js';
+export { state } from './state.js';
+export { executeRun, executeRunNonStreaming, requestRunCancellation, isRunActive, continueRunWithToolOutputs, continueRunWithToolOutputsNonStreaming, setRunnerBackend, } from './runner.js';
+export { generateToolCallId, } from './tools.js';
+export { default as assistantsRouter } from './routes.js';
+//# sourceMappingURL=index.js.map

package/out/assistants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/assistants/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAuC,MAAM,YAAY,CAAC;AACxE,OAAO,EACL,UAAU,EACV,sBAAsB,EACtB,sBAAsB,EACtB,WAAW,EACX,0BAA0B,EAC1B,sCAAsC,EACtC,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/out/assistants/routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Express Routes for OpenAI Assistants API
+ *
+ * Implements all CRUD operations for:
+ * - /v1/assistants
+ * - /v1/threads
+ * - /v1/threads/:thread_id/messages
+ * - /v1/threads/:thread_id/runs
+ *
+ * Future extensibility:
+ * - /v1/threads/runs (create thread and run)
+ * - /v1/threads/:thread_id/runs/:run_id/steps
+ * - /v1/threads/:thread_id/runs/:run_id/submit_tool_outputs
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/out/assistants/routes.js

@@ -0,0 +1,597 @@
+/**
+ * Express Routes for OpenAI Assistants API
+ *
+ * Implements all CRUD operations for:
+ * - /v1/assistants
+ * - /v1/threads
+ * - /v1/threads/:thread_id/messages
+ * - /v1/threads/:thread_id/runs
+ *
+ * Future extensibility:
+ * - /v1/threads/runs (create thread and run)
+ * - /v1/threads/:thread_id/runs/:run_id/steps
+ * - /v1/threads/:thread_id/runs/:run_id/submit_tool_outputs
+ */
+import { Router } from 'express';
+import { state } from './state.js';
+import { executeRun, executeRunNonStreaming, requestRunCancellation, continueRunWithToolOutputs, continueRunWithToolOutputsNonStreaming } from './runner.js';
+import { errorResponse, notFoundError, createMessage } from '../utils.js';
+const router = Router();
+// ==================== Validation Helpers ======================================
+function validateRequired(body, fields) {
+    for (const field of fields) {
+        if (body[field] === undefined || body[field] === null) {
+            return `Missing required field: ${String(field)}`;
+        }
+    }
+    return null;
+}
+function parsePaginationParams(query) {
+    return {
+        limit: query.limit ? Math.min(parseInt(query.limit, 10), 100) : 20,
+        order: query.order ?? 'desc',
+        after: query.after,
+        before: query.before
+    };
+}
+// ==================== Assistants Routes ====================
+// Create assistant
+router.post('/v1/assistants', (req, res) => {
+    const body = req.body;
+    const validationError = validateRequired(body, ['model']);
+    if (validationError) {
+        return res.status(400).json(errorResponse(validationError, 'invalid_request_error', 'model'));
+    }
+    const assistant = {
+        id: state.generateAssistantId(),
+        object: 'assistant',
+        created_at: Math.floor(Date.now() / 1000),
+        name: body.name ?? null,
+        description: body.description ?? null,
+        model: body.model,
+        instructions: body.instructions ?? null,
+        tools: body.tools ?? [],
+        skills: body.skills ?? [],
+        metadata: body.metadata ?? {}
+    };
+    state.createAssistant(assistant);
+    res.status(201).json(assistant);
+});
+// List assistants
+router.get('/v1/assistants', (req, res) => {
+    const params = parsePaginationParams(req.query);
+    const result = state.listAssistants(params);
+    res.json(result);
+});
+// Get assistant
+router.get('/v1/assistants/:assistant_id', (req, res) => {
+    const assistant = state.getAssistant(req.params.assistant_id);
+    if (!assistant) {
+        return res.status(404).json(notFoundError('assistant'));
+    }
+    res.json(assistant);
+});
+// Update assistant (POST for OpenAI compatibility)
+router.post('/v1/assistants/:assistant_id', (req, res) => {
+    const body = req.body;
+    const updated = state.updateAssistant(req.params.assistant_id, body);
+    if (!updated) {
+        return res.status(404).json(notFoundError('assistant'));
+    }
+    res.json(updated);
+});
+// Delete assistant
+router.delete('/v1/assistants/:assistant_id', (req, res) => {
+    const deleted = state.deleteAssistant(req.params.assistant_id);
+    res.json({
+        id: req.params.assistant_id,
+        object: 'assistant.deleted',
+        deleted
+    });
+});
+// ==================== Threads Routes ====================
+// Create thread
+router.post('/v1/threads', (req, res) => {
+    const body = (req.body || {});
+    const thread = {
+        id: state.generateThreadId(),
+        object: 'thread',
+        created_at: Math.floor(Date.now() / 1000),
+        metadata: body.metadata ?? {}
+    };
+    state.createThread(thread);
+    // Add initial messages if provided
+    if (body.messages && Array.isArray(body.messages)) {
+        for (const msg of body.messages) {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content);
+            const message = createMessage({
+                threadId: thread.id,
+                messageId: state.generateMessageId(),
+                content,
+                role: msg.role || 'user',
+                attachments: msg.attachments ?? [],
+                metadata: msg.metadata ?? {}
+            });
+            state.addMessage(thread.id, message);
+        }
+    }
+    res.status(201).json(thread);
+});
+// Get thread
+router.get('/v1/threads/:thread_id', (req, res) => {
+    const thread = state.getThread(req.params.thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    res.json(thread);
+});
+// Update thread (POST for OpenAI compatibility)
+router.post('/v1/threads/:thread_id', (req, res) => {
+    const updated = state.updateThread(req.params.thread_id, req.body);
+    if (!updated) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    res.json(updated);
+});
+// Delete thread
+router.delete('/v1/threads/:thread_id', (req, res) => {
+    const deleted = state.deleteThread(req.params.thread_id);
+    res.json({
+        id: req.params.thread_id,
+        object: 'thread.deleted',
+        deleted
+    });
+});
+// ==================== Messages Routes ====================
+// Create message
+router.post('/v1/threads/:thread_id/messages', (req, res) => {
+    const { thread_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const body = req.body;
+    const validationError = validateRequired(body, ['role', 'content']);
+    if (validationError) {
+        return res.status(400).json(errorResponse(validationError));
+    }
+    const content = typeof body.content === 'string'
+        ? body.content
+        : JSON.stringify(body.content);
+    const message = createMessage({
+        threadId: thread_id,
+        messageId: state.generateMessageId(),
+        content,
+        role: body.role,
+        attachments: body.attachments ?? [],
+        metadata: body.metadata ?? {}
+    });
+    state.addMessage(thread_id, message);
+    res.status(201).json(message);
+});
+// List messages
+router.get('/v1/threads/:thread_id/messages', (req, res) => {
+    const { thread_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const params = {
+        ...parsePaginationParams(req.query),
+        run_id: req.query.run_id
+    };
+    const result = state.getMessages(thread_id, params);
+    res.json(result);
+});
+// Get message
+router.get('/v1/threads/:thread_id/messages/:message_id', (req, res) => {
+    const { thread_id, message_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const message = state.getMessage(thread_id, message_id);
+    if (!message) {
+        return res.status(404).json(notFoundError('message'));
+    }
+    res.json(message);
+});
+// Update message (POST for OpenAI compatibility) - only metadata can be updated
+router.post('/v1/threads/:thread_id/messages/:message_id', (req, res) => {
+    const { thread_id, message_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    // Only metadata updates allowed
+    const updated = state.updateMessage(thread_id, message_id, {
+        metadata: req.body.metadata
+    });
+    if (!updated) {
+        return res.status(404).json(notFoundError('message'));
+    }
+    res.json(updated);
+});
+// Delete message
+router.delete('/v1/threads/:thread_id/messages/:message_id', (req, res) => {
+    const { thread_id, message_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const deleted = state.deleteMessage(thread_id, message_id);
+    res.json({
+        id: message_id,
+        object: 'thread.message.deleted',
+        deleted
+    });
+});
+// ==================== Runs Routes ====================
+// Create run
+router.post('/v1/threads/:thread_id/runs', async (req, res) => {
+    const { thread_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const body = req.body;
+    const validationError = validateRequired(body, ['assistant_id']);
+    if (validationError) {
+        return res.status(400).json(errorResponse(validationError, 'invalid_request_error', 'assistant_id'));
+    }
+    const assistant = state.getAssistant(body.assistant_id);
+    if (!assistant) {
+        return res.status(404).json(notFoundError('assistant'));
+    }
+    // Add additional messages if provided
+    if (body.additional_messages && Array.isArray(body.additional_messages)) {
+        for (const msg of body.additional_messages) {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content);
+            const message = createMessage({
+                threadId: thread_id,
+                messageId: state.generateMessageId(),
+                content,
+                role: msg.role || 'user',
+                attachments: msg.attachments ?? [],
+                metadata: msg.metadata ?? {}
+            });
+            state.addMessage(thread_id, message);
+        }
+    }
+    const run = {
+        id: state.generateRunId(),
+        object: 'thread.run',
+        created_at: Math.floor(Date.now() / 1000),
+        thread_id,
+        assistant_id: body.assistant_id,
+        status: 'queued',
+        required_action: null,
+        last_error: null,
+        expires_at: Math.floor(Date.now() / 1000) + 600, // 10 minutes
+        started_at: null,
+        cancelled_at: null,
+        failed_at: null,
+        completed_at: null,
+        incomplete_details: null,
+        model: body.model ?? assistant.model,
+        instructions: body.instructions ?? null,
+        tools: body.tools ?? assistant.tools,
+        skills: body.skills ?? assistant.skills,
+        metadata: body.metadata ?? {},
+        usage: null
+    };
+    state.addRun(thread_id, run);
+    // Check if streaming is requested
+    if (body.stream) {
+        // Streaming mode: use SSE
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        // Execute run with streaming
+        (async () => {
+            try {
+                const generator = executeRun(thread_id, run.id, true);
+                for await (const event of generator) {
+                    if (event.event === 'done') {
+                        res.write(`event: done\ndata: [DONE]\n\n`);
+                    }
+                    else {
+                        res.write(`event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`);
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Streaming run error:', err);
+                res.write(`event: error\ndata: ${JSON.stringify({ error: { message: 'Stream error' } })}\n\n`);
+            }
+            finally {
+                res.end();
+            }
+        })();
+    }
+    else {
+        // Non-streaming mode: return immediately, execute async
+        res.status(201).json(run);
+        // Execute in background (don't await)
+        executeRunNonStreaming(thread_id, run.id).catch(err => {
+            console.error('Run execution failed:', err);
+        });
+    }
+});
+// List runs
+router.get('/v1/threads/:thread_id/runs', (req, res) => {
+    const { thread_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const params = parsePaginationParams(req.query);
+    const result = state.getRuns(thread_id, params);
+    res.json(result);
+});
+// Get run
+router.get('/v1/threads/:thread_id/runs/:run_id', (req, res) => {
+    const { thread_id, run_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const run = state.getRun(thread_id, run_id);
+    if (!run) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    res.json(run);
+});
+// Update run (POST for OpenAI compatibility) - only metadata can be updated
+router.post('/v1/threads/:thread_id/runs/:run_id', (req, res) => {
+    const { thread_id, run_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const updated = state.updateRun(thread_id, run_id, {
+        metadata: req.body.metadata
+    });
+    if (!updated) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    res.json(updated);
+});
+// Cancel run
+router.post('/v1/threads/:thread_id/runs/:run_id/cancel', (req, res) => {
+    const { thread_id, run_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const run = state.getRun(thread_id, run_id);
+    if (!run) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    // Check if run can be cancelled
+    const cancellableStatuses = ['queued', 'in_progress', 'requires_action'];
+    if (!cancellableStatuses.includes(run.status)) {
+        return res.status(400).json(errorResponse(`Cannot cancel run with status: ${run.status}`, 'invalid_request_error', 'status'));
+    }
+    // Request cancellation
+    requestRunCancellation(thread_id, run_id);
+    const updated = state.updateRun(thread_id, run_id, {
+        status: 'cancelling',
+        cancelled_at: Math.floor(Date.now() / 1000)
+    });
+    // After a short delay, mark as cancelled
+    setTimeout(() => {
+        const currentRun = state.getRun(thread_id, run_id);
+        if (currentRun?.status === 'cancelling') {
+            state.updateRun(thread_id, run_id, { status: 'cancelled' });
+        }
+    }, 100);
+    res.json(updated);
+});
+// ==================== Create Thread and Run ====================
+router.post('/v1/threads/runs', async (req, res) => {
+    const body = req.body;
+    const validationError = validateRequired(body, ['assistant_id']);
+    if (validationError) {
+        return res.status(400).json(errorResponse(validationError, 'invalid_request_error', 'assistant_id'));
+    }
+    const assistant = state.getAssistant(body.assistant_id);
+    if (!assistant) {
+        return res.status(404).json(notFoundError('assistant'));
+    }
+    // Create thread
+    const threadBody = body.thread ?? {};
+    const thread = {
+        id: state.generateThreadId(),
+        object: 'thread',
+        created_at: Math.floor(Date.now() / 1000),
+        metadata: threadBody.metadata ?? {}
+    };
+    state.createThread(thread);
+    // Add initial messages if provided
+    if (threadBody.messages && Array.isArray(threadBody.messages)) {
+        for (const msg of threadBody.messages) {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify(msg.content);
+            const message = createMessage({
+                threadId: thread.id,
+                messageId: state.generateMessageId(),
+                content,
+                role: msg.role || 'user',
+                attachments: msg.attachments ?? [],
+                metadata: msg.metadata ?? {}
+            });
+            state.addMessage(thread.id, message);
+        }
+    }
+    // Create run
+    const run = {
+        id: state.generateRunId(),
+        object: 'thread.run',
+        created_at: Math.floor(Date.now() / 1000),
+        thread_id: thread.id,
+        assistant_id: body.assistant_id,
+        status: 'queued',
+        required_action: null,
+        last_error: null,
+        expires_at: Math.floor(Date.now() / 1000) + 600,
+        started_at: null,
+        cancelled_at: null,
+        failed_at: null,
+        completed_at: null,
+        incomplete_details: null,
+        model: body.model ?? assistant.model,
+        instructions: body.instructions ?? null,
+        tools: body.tools ?? assistant.tools,
+        skills: body.skills ?? assistant.skills,
+        metadata: body.metadata ?? {},
+        usage: null
+    };
+    state.addRun(thread.id, run);
+    // Check if streaming is requested
+    if (body.stream) {
+        // Streaming mode: use SSE
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        // Execute run with streaming
+        (async () => {
+            try {
+                const generator = executeRun(thread.id, run.id, true);
+                for await (const event of generator) {
+                    if (event.event === 'done') {
+                        res.write(`event: done\ndata: [DONE]\n\n`);
+                    }
+                    else {
+                        res.write(`event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`);
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Streaming run error:', err);
+                res.write(`event: error\ndata: ${JSON.stringify({ error: { message: 'Stream error' } })}\n\n`);
+            }
+            finally {
+                res.end();
+            }
+        })();
+    }
+    else {
+        // Non-streaming mode: return immediately, execute async
+        res.status(201).json(run);
+        // Execute in background
+        executeRunNonStreaming(thread.id, run.id).catch(err => {
+            console.error('Run execution failed:', err);
+        });
+    }
+});
+// ==================== Submit Tool Outputs ====================
+router.post('/v1/threads/:thread_id/runs/:run_id/submit_tool_outputs', async (req, res) => {
+    const { thread_id, run_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const run = state.getRun(thread_id, run_id);
+    if (!run) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    // Check if run is in requires_action status
+    if (run.status !== 'requires_action') {
+        return res.status(400).json(errorResponse(`Run is not in requires_action status. Current status: ${run.status}`, 'invalid_request_error', 'status'));
+    }
+    const body = req.body;
+    const validationError = validateRequired(body, ['tool_outputs']);
+    if (validationError) {
+        return res.status(400).json(errorResponse(validationError, 'invalid_request_error', 'tool_outputs'));
+    }
+    // Validate that all required tool calls are provided
+    const requiredToolCallIds = new Set(run.required_action?.submit_tool_outputs.tool_calls.map(tc => tc.id) ?? []);
+    const providedToolCallIds = new Set(body.tool_outputs.map(o => o.tool_call_id));
+    for (const requiredId of requiredToolCallIds) {
+        if (!providedToolCallIds.has(requiredId)) {
+            return res.status(400).json(errorResponse(`Missing output for tool call: ${requiredId}`, 'invalid_request_error', 'tool_outputs'));
+        }
+    }
+    // Check if streaming is requested
+    if (body.stream) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        (async () => {
+            try {
+                const generator = continueRunWithToolOutputs(thread_id, run_id, body.tool_outputs, true);
+                for await (const event of generator) {
+                    if (event.event === 'done') {
+                        res.write(`event: done\ndata: [DONE]\n\n`);
+                    }
+                    else {
+                        res.write(`event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`);
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Streaming continue error:', err);
+                res.write(`event: error\ndata: ${JSON.stringify({ error: { message: 'Stream error' } })}\n\n`);
+            }
+            finally {
+                res.end();
+            }
+        })();
+    }
+    else {
+        // Non-streaming mode: return the run immediately, execute async
+        const updatedRun = state.updateRun(thread_id, run_id, {
+            status: 'in_progress',
+            required_action: null
+        });
+        res.json(updatedRun);
+        // Continue execution in background
+        continueRunWithToolOutputsNonStreaming(thread_id, run_id, body.tool_outputs).catch(err => {
+            console.error('Continue run failed:', err);
+        });
+    }
+});
+// ==================== Run Steps ====================
+// List run steps
+router.get('/v1/threads/:thread_id/runs/:run_id/steps', (req, res) => {
+    const { thread_id, run_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const run = state.getRun(thread_id, run_id);
+    if (!run) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    const params = parsePaginationParams(req.query);
+    const result = state.getRunSteps(run_id, params);
+    res.json(result);
+});
+// Get run step
+router.get('/v1/threads/:thread_id/runs/:run_id/steps/:step_id', (req, res) => {
+    const { thread_id, run_id, step_id } = req.params;
+    const thread = state.getThread(thread_id);
+    if (!thread) {
+        return res.status(404).json(notFoundError('thread'));
+    }
+    const run = state.getRun(thread_id, run_id);
+    if (!run) {
+        return res.status(404).json(notFoundError('run'));
+    }
+    const step = state.getRunStep(run_id, step_id);
+    if (!step) {
+        return res.status(404).json(notFoundError('run step'));
+    }
+    res.json(step);
+});
+export default router;
+//# sourceMappingURL=routes.js.map