copilot-router 1.0.0

package/dist/routes/auth/routes.js

@@ -0,0 +1,158 @@
+import consola from "consola";
+import { tokenManager } from "../../lib/token-manager.js";
+import { getDeviceCode } from "../../services/github/get-device-code.js";
+import { checkAccessToken } from "../../services/github/poll-access-token.js";
+// Track device codes being processed to prevent duplicate token additions
+const processingDeviceCodes = new Set();
+export function registerAuthRoutes(app) {
+    // POST /auth/login - Start device code flow
+    app.post("/auth/login", async (c) => {
+        try {
+            const deviceCode = await getDeviceCode();
+            consola.info(`Login initiated. Please visit ${deviceCode.verification_uri} and enter code: ${deviceCode.user_code}`);
+            return c.json({
+                user_code: deviceCode.user_code,
+                verification_uri: deviceCode.verification_uri,
+                device_code: deviceCode.device_code,
+                expires_in: deviceCode.expires_in,
+                interval: deviceCode.interval,
+            });
+        }
+        catch (error) {
+            consola.error("Failed to start login:", error);
+            return c.json({ error: { message: "Failed to start login", type: "auth_error" } }, 500);
+        }
+    });
+    // POST /auth/complete - Check device code flow status (single check, client polls)
+    app.post("/auth/complete", async (c) => {
+        try {
+            const body = await c.req.json();
+            const { device_code, account_type = "individual" } = body;
+            if (!device_code) {
+                return c.json({ error: { message: "device_code is required", type: "validation_error" } }, 400);
+            }
+            // Check access token once
+            const result = await checkAccessToken(device_code);
+            if (result.error === "authorization_pending") {
+                // User hasn't authorized yet, client should continue polling
+                return c.json({ status: "pending", message: "Waiting for user authorization" });
+            }
+            if (result.error === "slow_down") {
+                // Rate limited, client should slow down
+                return c.json({ status: "slow_down", message: "Please slow down polling" });
+            }
+            if (result.error === "expired_token") {
+                return c.json({ error: { message: "Device code expired. Please try again.", type: "expired" } }, 400);
+            }
+            if (result.error === "access_denied") {
+                return c.json({ error: { message: "Access denied by user.", type: "denied" } }, 400);
+            }
+            if (result.error) {
+                return c.json({ error: { message: result.error_description || result.error, type: "auth_error" } }, 400);
+            }
+            if (!result.access_token) {
+                return c.json({ status: "pending", message: "Waiting for user authorization" });
+            }
+            // Check if this device code is already being processed
+            if (processingDeviceCodes.has(device_code)) {
+                return c.json({ status: "processing", message: "Token is being added, please wait" });
+            }
+            // Mark as processing
+            processingDeviceCodes.add(device_code);
+            try {
+                // Success! Add token to manager
+                const entry = await tokenManager.addToken(result.access_token, account_type);
+                return c.json({
+                    status: "success",
+                    id: entry.id,
+                    username: entry.username,
+                    account_type: entry.accountType,
+                    message: `Successfully logged in as ${entry.username}`,
+                });
+            }
+            finally {
+                // Remove from processing set
+                processingDeviceCodes.delete(device_code);
+            }
+        }
+        catch (error) {
+            consola.error("Failed to complete login:", error);
+            return c.json({ error: { message: "Failed to complete login", type: "auth_error" } }, 500);
+        }
+    });
+    // GET /auth/tokens - List all tokens
+    app.get("/auth/tokens", (c) => {
+        try {
+            const stats = tokenManager.getStatistics();
+            const counts = tokenManager.getTokenCount();
+            return c.json({
+                total: counts.total,
+                active: counts.active,
+                tokens: stats.map((s) => ({
+                    id: s.id,
+                    username: s.username,
+                    account_type: s.accountType,
+                    is_active: s.isActive,
+                    has_copilot_token: s.hasValidCopilotToken,
+                    copilot_token_expires_at: s.copilotTokenExpiresAt?.toISOString() ?? null,
+                    request_count: s.requestCount,
+                    error_count: s.errorCount,
+                    last_used: s.lastUsed?.toISOString() ?? null,
+                })),
+            });
+        }
+        catch (error) {
+            consola.error("Failed to list tokens:", error);
+            return c.json({ error: { message: "Failed to list tokens", type: "error" } }, 500);
+        }
+    });
+    // DELETE /auth/tokens/all - Delete all tokens (for cleanup) - must be before :id route
+    app.delete("/auth/tokens/all", async (c) => {
+        try {
+            await tokenManager.removeAllTokens();
+            return c.json({ message: "All tokens deleted" });
+        }
+        catch (error) {
+            consola.error("Failed to delete all tokens:", error);
+            return c.json({ error: { message: "Failed to delete all tokens", type: "error" } }, 500);
+        }
+    });
+    // DELETE /auth/tokens/:id - Delete a token
+    app.delete("/auth/tokens/:id", async (c) => {
+        try {
+            const id = parseInt(c.req.param("id"), 10);
+            if (isNaN(id)) {
+                return c.json({ error: { message: "Invalid token ID", type: "validation_error" } }, 400);
+            }
+            const removed = await tokenManager.removeToken(id);
+            if (!removed) {
+                return c.json({ error: { message: "Token not found", type: "not_found" } }, 404);
+            }
+            return c.json({ message: "Token deleted successfully" });
+        }
+        catch (error) {
+            consola.error("Failed to delete token:", error);
+            return c.json({ error: { message: "Failed to delete token", type: "error" } }, 500);
+        }
+    });
+    // POST /auth/tokens - Add token directly
+    app.post("/auth/tokens", async (c) => {
+        try {
+            const body = await c.req.json();
+            const { github_token, account_type = "individual" } = body;
+            if (!github_token) {
+                return c.json({ error: { message: "github_token is required", type: "validation_error" } }, 400);
+            }
+            const entry = await tokenManager.addToken(github_token, account_type);
+            return c.json({
+                id: entry.id,
+                username: entry.username,
+                message: `Token added for ${entry.username}`,
+            });
+        }
+        catch (error) {
+            consola.error("Failed to add token:", error);
+            return c.json({ error: { message: "Failed to add token", type: "error" } }, 500);
+        }
+    });
+}

package/dist/routes/gemini/routes.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare function registerGeminiRoutes(app: OpenAPIHono): void;

package/dist/routes/gemini/routes.js

@@ -0,0 +1,163 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { streamSSE } from "hono/streaming";
+import consola from "consola";
+import { forwardError } from "../../lib/error.js";
+import { createChatCompletions, } from "../../services/copilot/create-chat-completions.js";
+import { translateGeminiToOpenAI, translateOpenAIToGemini, translateChunkToGemini, } from "./translation.js";
+const GeminiErrorResponseSchema = z.object({
+    error: z.object({
+        code: z.number(),
+        message: z.string(),
+        status: z.string(),
+    }),
+});
+// Generate content route (non-streaming)
+const generateContentRoute = createRoute({
+    method: "post",
+    path: "/models/:modelWithMethod",
+    tags: ["Gemini API"],
+    summary: "Generate content with Gemini-compatible API",
+    description: "Generate content using the Gemini-compatible API interface, powered by GitHub Copilot.",
+    request: {
+        params: z.object({
+            modelWithMethod: z.string(),
+        }),
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+                "text/event-stream": {
+                    schema: z.string(),
+                },
+            },
+            description: "Successfully generated content",
+        },
+        400: {
+            content: { "application/json": { schema: GeminiErrorResponseSchema } },
+            description: "Bad request",
+        },
+        500: {
+            content: { "application/json": { schema: GeminiErrorResponseSchema } },
+            description: "Internal server error",
+        },
+    },
+});
+// Count tokens route
+const countTokensRoute = createRoute({
+    method: "post",
+    path: "/models/:modelWithMethod",
+    tags: ["Gemini API"],
+    summary: "Count tokens for Gemini-compatible request",
+    description: "Count the tokens for a request using the Gemini-compatible API interface.",
+    request: {
+        params: z.object({
+            modelWithMethod: z.string(),
+        }),
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        totalTokens: z.number(),
+                    }),
+                },
+            },
+            description: "Successfully counted tokens",
+        },
+        500: {
+            content: { "application/json": { schema: GeminiErrorResponseSchema } },
+            description: "Internal server error",
+        },
+    },
+});
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+function parseModelFromPath(modelWithMethod) {
+    // Format: gemini-2.5-pro:generateContent or gemini-2.5-pro:streamGenerateContent
+    const colonIndex = modelWithMethod.lastIndexOf(":");
+    if (colonIndex === -1) {
+        return { model: modelWithMethod, method: "generateContent" };
+    }
+    return {
+        model: modelWithMethod.substring(0, colonIndex),
+        method: modelWithMethod.substring(colonIndex + 1),
+    };
+}
+export function registerGeminiRoutes(app) {
+    // Handle all Gemini routes with pattern matching
+    app.post("/models/:modelWithMethod", async (c) => {
+        try {
+            const modelWithMethod = c.req.param("modelWithMethod");
+            const { model, method } = parseModelFromPath(modelWithMethod);
+            consola.debug(`Gemini request: model=${model}, method=${method}`);
+            const geminiPayload = await c.req.json();
+            if (method === "countTokens") {
+                // Simple token estimation
+                let totalChars = 0;
+                if (geminiPayload.contents) {
+                    for (const content of geminiPayload.contents) {
+                        for (const part of content.parts || []) {
+                            if (part.text) {
+                                totalChars += part.text.length;
+                            }
+                        }
+                    }
+                }
+                if (geminiPayload.systemInstruction) {
+                    for (const part of geminiPayload.systemInstruction.parts || []) {
+                        if (part.text) {
+                            totalChars += part.text.length;
+                        }
+                    }
+                }
+                const estimatedTokens = Math.ceil(totalChars / 4);
+                return c.json({ totalTokens: estimatedTokens });
+            }
+            const isStreaming = method === "streamGenerateContent";
+            const openAIPayload = translateGeminiToOpenAI(geminiPayload, model);
+            openAIPayload.stream = isStreaming;
+            consola.debug("Translated OpenAI payload:", JSON.stringify(openAIPayload));
+            const response = await createChatCompletions(openAIPayload);
+            if (isNonStreaming(response)) {
+                const geminiResponse = translateOpenAIToGemini(response);
+                return c.json(geminiResponse);
+            }
+            // Streaming response
+            return streamSSE(c, async (stream) => {
+                for await (const rawEvent of response) {
+                    if (rawEvent.data === "[DONE]")
+                        break;
+                    if (!rawEvent.data)
+                        continue;
+                    const chunk = JSON.parse(rawEvent.data);
+                    const geminiChunk = translateChunkToGemini(chunk);
+                    if (geminiChunk.candidates && geminiChunk.candidates.length > 0) {
+                        await stream.writeSSE({
+                            data: JSON.stringify(geminiChunk),
+                        });
+                    }
+                }
+            });
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+}

package/dist/routes/gemini/translation.d.ts

@@ -0,0 +1,5 @@
+import { type ChatCompletionResponse, type ChatCompletionsPayload, type ChatCompletionChunk } from "../../services/copilot/create-chat-completions.js";
+import { type GeminiGenerateContentRequest, type GeminiGenerateContentResponse } from "./types.js";
+export declare function translateGeminiToOpenAI(request: GeminiGenerateContentRequest, model: string): ChatCompletionsPayload;
+export declare function translateOpenAIToGemini(response: ChatCompletionResponse): GeminiGenerateContentResponse;
+export declare function translateChunkToGemini(chunk: ChatCompletionChunk): GeminiGenerateContentResponse;

package/dist/routes/gemini/translation.js

@@ -0,0 +1,215 @@
+// Gemini -> OpenAI translation
+export function translateGeminiToOpenAI(request, model) {
+    const messages = [];
+    // Handle system instruction
+    if (request.systemInstruction) {
+        const systemText = request.systemInstruction.parts
+            ?.map((p) => p.text)
+            .filter(Boolean)
+            .join("\n");
+        if (systemText) {
+            messages.push({ role: "system", content: systemText });
+        }
+    }
+    // Handle contents
+    if (request.contents) {
+        for (const content of request.contents) {
+            const role = content.role === "model" ? "assistant" : "user";
+            const parts = content.parts || [];
+            // Check for function calls/responses
+            const functionCalls = parts.filter((p) => p.functionCall);
+            const functionResponses = parts.filter((p) => p.functionResponse);
+            const textParts = parts.filter((p) => p.text);
+            if (functionCalls.length > 0) {
+                // Assistant with tool calls
+                const textContent = textParts.map((p) => p.text).join("\n") || null;
+                messages.push({
+                    role: "assistant",
+                    content: textContent,
+                    tool_calls: functionCalls.map((p, idx) => ({
+                        id: p.functionCall.id || `call_${idx}`,
+                        type: "function",
+                        function: {
+                            name: p.functionCall.name,
+                            arguments: JSON.stringify(p.functionCall.args || {}),
+                        },
+                    })),
+                });
+            }
+            else if (functionResponses.length > 0) {
+                // Tool results
+                for (const p of functionResponses) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: p.functionResponse.id,
+                        content: JSON.stringify(p.functionResponse.response || ""),
+                    });
+                }
+            }
+            else {
+                // Regular text message
+                const textContent = textParts.map((p) => p.text).join("\n") || "";
+                // Handle inline data (images)
+                const imageParts = parts.filter((p) => p.inlineData);
+                if (imageParts.length > 0) {
+                    messages.push({
+                        role: role,
+                        content: [
+                            ...textParts.map((p) => ({ type: "text", text: p.text })),
+                            ...imageParts.map((p) => ({
+                                type: "image_url",
+                                image_url: {
+                                    url: `data:${p.inlineData.mimeType};base64,${p.inlineData.data}`,
+                                },
+                            })),
+                        ],
+                    });
+                }
+                else {
+                    messages.push({
+                        role: role,
+                        content: textContent,
+                    });
+                }
+            }
+        }
+    }
+    // Translate tools
+    let tools;
+    if (request.tools) {
+        tools = [];
+        for (const tool of request.tools) {
+            if (tool.functionDeclarations) {
+                for (const func of tool.functionDeclarations) {
+                    tools.push({
+                        type: "function",
+                        function: {
+                            name: func.name,
+                            description: func.description,
+                            parameters: func.parameters || {},
+                        },
+                    });
+                }
+            }
+        }
+    }
+    // Translate tool config
+    let tool_choice;
+    if (request.toolConfig?.functionCallingConfig?.mode) {
+        const mode = request.toolConfig.functionCallingConfig.mode;
+        if (mode === "AUTO")
+            tool_choice = "auto";
+        else if (mode === "ANY")
+            tool_choice = "required";
+        else if (mode === "NONE")
+            tool_choice = "none";
+    }
+    return {
+        model,
+        messages,
+        temperature: request.generationConfig?.temperature,
+        top_p: request.generationConfig?.topP,
+        max_tokens: request.generationConfig?.maxOutputTokens,
+        stop: request.generationConfig?.stopSequences,
+        tools: tools && tools.length > 0 ? tools : undefined,
+        tool_choice,
+    };
+}
+// OpenAI -> Gemini translation
+export function translateOpenAIToGemini(response) {
+    const candidates = [];
+    for (const choice of response.choices) {
+        const parts = [];
+        // Handle text content
+        if (choice.message.content) {
+            parts.push({ text: choice.message.content });
+        }
+        // Handle tool calls
+        if (choice.message.tool_calls) {
+            for (const toolCall of choice.message.tool_calls) {
+                parts.push({
+                    functionCall: {
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        args: JSON.parse(toolCall.function.arguments),
+                    },
+                });
+            }
+        }
+        const content = {
+            parts,
+            role: "model",
+        };
+        const finishReasonMap = {
+            stop: "STOP",
+            length: "MAX_TOKENS",
+            tool_calls: "STOP",
+            content_filter: "SAFETY",
+        };
+        candidates.push({
+            content,
+            finishReason: finishReasonMap[choice.finish_reason] || "OTHER",
+            index: choice.index,
+        });
+    }
+    return {
+        candidates,
+        usageMetadata: response.usage
+            ? {
+                promptTokenCount: response.usage.prompt_tokens,
+                candidatesTokenCount: response.usage.completion_tokens,
+                totalTokenCount: response.usage.total_tokens,
+            }
+            : undefined,
+    };
+}
+// Stream chunk translation
+export function translateChunkToGemini(chunk) {
+    const candidates = [];
+    for (const choice of chunk.choices) {
+        const parts = [];
+        if (choice.delta.content) {
+            parts.push({ text: choice.delta.content });
+        }
+        if (choice.delta.tool_calls) {
+            for (const toolCall of choice.delta.tool_calls) {
+                if (toolCall.function?.name) {
+                    parts.push({
+                        functionCall: {
+                            id: toolCall.id,
+                            name: toolCall.function.name,
+                            args: toolCall.function.arguments
+                                ? JSON.parse(toolCall.function.arguments)
+                                : {},
+                        },
+                    });
+                }
+            }
+        }
+        if (parts.length > 0) {
+            const finishReasonMap = {
+                stop: "STOP",
+                length: "MAX_TOKENS",
+                tool_calls: "STOP",
+                content_filter: "SAFETY",
+            };
+            candidates.push({
+                content: { parts, role: "model" },
+                finishReason: choice.finish_reason
+                    ? finishReasonMap[choice.finish_reason] || "OTHER"
+                    : undefined,
+                index: choice.index,
+            });
+        }
+    }
+    return {
+        candidates,
+        usageMetadata: chunk.usage
+            ? {
+                promptTokenCount: chunk.usage.prompt_tokens,
+                candidatesTokenCount: chunk.usage.completion_tokens,
+                totalTokenCount: chunk.usage.total_tokens,
+            }
+            : undefined,
+    };
+}

package/dist/routes/gemini/types.d.ts

@@ -0,0 +1,63 @@
+export interface GeminiContent {
+    parts: GeminiPart[];
+    role?: "user" | "model";
+}
+export interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        id?: string;
+        name: string;
+        args?: Record<string, unknown>;
+    };
+    functionResponse?: {
+        id: string;
+        response?: unknown;
+    };
+}
+export interface GeminiTool {
+    functionDeclarations?: GeminiFunctionDeclaration[];
+}
+export interface GeminiFunctionDeclaration {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+}
+export interface GeminiToolConfig {
+    functionCallingConfig?: {
+        mode?: "AUTO" | "ANY" | "NONE";
+        allowedFunctionNames?: string[];
+    };
+}
+export interface GeminiGenerationConfig {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxOutputTokens?: number;
+    stopSequences?: string[];
+}
+export interface GeminiGenerateContentRequest {
+    contents?: GeminiContent[];
+    tools?: GeminiTool[];
+    toolConfig?: GeminiToolConfig;
+    systemInstruction?: GeminiContent;
+    generationConfig?: GeminiGenerationConfig;
+}
+export interface GeminiCandidate {
+    content: GeminiContent;
+    finishReason?: "STOP" | "MAX_TOKENS" | "SAFETY" | "RECITATION" | "OTHER";
+    index?: number;
+}
+export interface GeminiUsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+}
+export interface GeminiGenerateContentResponse {
+    candidates?: GeminiCandidate[];
+    usageMetadata?: GeminiUsageMetadata;
+    modelVersion?: string;
+}

package/dist/routes/gemini/types.js

@@ -0,0 +1,2 @@
+// Gemini API Types
+export {};

package/dist/routes/openai/routes.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare function registerOpenAIRoutes(app: OpenAPIHono): void;