copilot-router 1.0.0

package/dist/routes/openai/routes.js

@@ -0,0 +1,215 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { streamSSE } from "hono/streaming";
+import consola from "consola";
+import { forwardError } from "../../lib/error.js";
+import { tokenManager } from "../../lib/token-manager.js";
+import { createChatCompletions, } from "../../services/copilot/create-chat-completions.js";
+import { createEmbeddings, } from "../../services/copilot/create-embeddings.js";
+import { getModels, getModelsForAllTokens } from "../../services/copilot/get-models.js";
+const CommonResponseError = z.object({
+    error: z.object({
+        message: z.string(),
+        type: z.string(),
+    }),
+});
+// Chat completions route
+const chatCompletionsRoute = createRoute({
+    method: "post",
+    path: "/chat/completions",
+    tags: ["OpenAI API"],
+    summary: "Create a chat completion",
+    description: "Create a chat completion using the OpenAI-compatible API interface.",
+    request: {
+        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 created chat completion",
+        },
+        400: {
+            content: { "application/json": { schema: CommonResponseError } },
+            description: "Bad request",
+        },
+        500: {
+            content: { "application/json": { schema: CommonResponseError } },
+            description: "Internal server error",
+        },
+    },
+});
+// Models route
+const modelsRoute = createRoute({
+    method: "get",
+    path: "/models",
+    tags: ["OpenAI API"],
+    summary: "List available models",
+    description: "List all available models from GitHub Copilot.",
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        object: z.string(),
+                        data: z.array(z.object({}).passthrough()),
+                        has_more: z.boolean(),
+                    }),
+                },
+            },
+            description: "Successfully retrieved models",
+        },
+        500: {
+            content: { "application/json": { schema: CommonResponseError } },
+            description: "Internal server error",
+        },
+    },
+});
+// Embeddings route
+const embeddingsRoute = createRoute({
+    method: "post",
+    path: "/embeddings",
+    tags: ["OpenAI API"],
+    summary: "Create embeddings",
+    description: "Create embeddings for the provided input text.",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        input: z.union([z.string(), z.array(z.string())]),
+                        model: z.string(),
+                    }),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+            },
+            description: "Successfully created embeddings",
+        },
+        500: {
+            content: { "application/json": { schema: CommonResponseError } },
+            description: "Internal server error",
+        },
+    },
+});
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+export function registerOpenAIRoutes(app) {
+    // POST /chat/completions
+    app.openapi(chatCompletionsRoute, async (c) => {
+        try {
+            const payload = await c.req.json();
+            consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+            // Get a random token entry for load balancing
+            const tokenEntry = tokenManager.getRandomTokenEntry();
+            if (!tokenEntry) {
+                return c.json({ error: { message: "No active tokens available", type: "auth_error" } }, 503);
+            }
+            // Fetch models if needed
+            if (!tokenEntry.models) {
+                try {
+                    tokenEntry.models = await getModels(tokenEntry);
+                }
+                catch (e) {
+                    consola.warn("Could not fetch models for max_tokens lookup");
+                }
+            }
+            const selectedModel = tokenEntry.models?.data.find((model) => model.id === payload.model);
+            if (!payload.max_tokens && selectedModel) {
+                payload.max_tokens = selectedModel.capabilities.limits.max_output_tokens;
+            }
+            const response = await createChatCompletions(payload, tokenEntry);
+            if (isNonStreaming(response)) {
+                consola.debug("Non-streaming response");
+                return c.json(response);
+            }
+            consola.debug("Streaming response");
+            return streamSSE(c, async (stream) => {
+                for await (const chunk of response) {
+                    consola.debug("Streaming chunk:", JSON.stringify(chunk));
+                    await stream.writeSSE(chunk);
+                }
+            });
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+    // GET /models
+    app.openapi(modelsRoute, async (c) => {
+        try {
+            // Check for grouped query parameter
+            const grouped = c.req.query("grouped") === "true";
+            if (grouped) {
+                // Return models grouped by token
+                const tokenModels = await getModelsForAllTokens();
+                return c.json({
+                    object: "list",
+                    grouped: true,
+                    tokens: tokenModels.map((tm) => ({
+                        token_id: tm.tokenId,
+                        username: tm.username,
+                        account_type: tm.accountType,
+                        error: tm.error,
+                        models: tm.models?.data.map((model) => ({
+                            id: model.id,
+                            object: "model",
+                            type: "model",
+                            created: 0,
+                            created_at: new Date(0).toISOString(),
+                            owned_by: model.vendor,
+                            display_name: model.name,
+                        })) ?? [],
+                    })),
+                });
+            }
+            // Get models from first active token
+            const modelsResponse = await getModels();
+            const models = modelsResponse.data.map((model) => ({
+                id: model.id,
+                object: "model",
+                type: "model",
+                created: 0,
+                created_at: new Date(0).toISOString(),
+                owned_by: model.vendor,
+                display_name: model.name,
+            }));
+            return c.json({
+                object: "list",
+                data: models,
+                has_more: false,
+            });
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+    // POST /embeddings
+    app.openapi(embeddingsRoute, async (c) => {
+        try {
+            const payload = await c.req.json();
+            const response = await createEmbeddings(payload);
+            return c.json(response);
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+}

package/dist/routes/utility/routes.d.ts

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

package/dist/routes/utility/routes.js

@@ -0,0 +1,28 @@
+import { tokenManager } from "../../lib/token-manager.js";
+export function registerUtilityRoutes(app) {
+    // GET /
+    app.get("/", (c) => {
+        const counts = tokenManager.getTokenCount();
+        return c.text(`Copilot Router is running (${counts.active}/${counts.total} active tokens)`);
+    });
+    // GET /token
+    app.get("/token", (c) => {
+        try {
+            const entries = tokenManager.getActiveTokenEntries();
+            const tokens = entries.map(e => ({
+                id: e.id,
+                username: e.username,
+                copilot_token: e.copilotToken?.substring(0, 20) + "...",
+                expires_at: e.copilotTokenExpiresAt?.toISOString(),
+            }));
+            return c.json({
+                count: tokens.length,
+                tokens,
+            });
+        }
+        catch (error) {
+            console.error("Error fetching token:", error);
+            return c.json({ error: { message: "Failed to fetch token", type: "error" } }, 500);
+        }
+    });
+}

package/dist/services/copilot/create-chat-completions.d.ts

@@ -0,0 +1,130 @@
+import { type TokenEntry } from "../../lib/token-manager.js";
+export declare const createChatCompletions: (payload: ChatCompletionsPayload, tokenEntry?: TokenEntry) => Promise<ChatCompletionResponse | AsyncGenerator<import("fetch-event-stream").ServerSentEventMessage, void, unknown>>;
+export interface ChatCompletionChunk {
+    id: string;
+    object: "chat.completion.chunk";
+    created: number;
+    model: string;
+    choices: Array<Choice>;
+    system_fingerprint?: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        prompt_tokens_details?: {
+            cached_tokens: number;
+        };
+        completion_tokens_details?: {
+            accepted_prediction_tokens: number;
+            rejected_prediction_tokens: number;
+        };
+    };
+}
+interface Delta {
+    content?: string | null;
+    role?: "user" | "assistant" | "system" | "tool";
+    tool_calls?: Array<{
+        index: number;
+        id?: string;
+        type?: "function";
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+}
+interface Choice {
+    index: number;
+    delta: Delta;
+    finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | null;
+    logprobs: object | null;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model: string;
+    choices: Array<ChoiceNonStreaming>;
+    system_fingerprint?: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        prompt_tokens_details?: {
+            cached_tokens: number;
+        };
+    };
+}
+interface ResponseMessage {
+    role: "assistant";
+    content: string | null;
+    tool_calls?: Array<ToolCall>;
+}
+interface ChoiceNonStreaming {
+    index: number;
+    message: ResponseMessage;
+    logprobs: object | null;
+    finish_reason: "stop" | "length" | "tool_calls" | "content_filter";
+}
+export interface ChatCompletionsPayload {
+    messages: Array<Message>;
+    model: string;
+    temperature?: number | null;
+    top_p?: number | null;
+    max_tokens?: number | null;
+    stop?: string | Array<string> | null;
+    n?: number | null;
+    stream?: boolean | null;
+    frequency_penalty?: number | null;
+    presence_penalty?: number | null;
+    logit_bias?: Record<string, number> | null;
+    logprobs?: boolean | null;
+    response_format?: {
+        type: "json_object";
+    } | null;
+    seed?: number | null;
+    tools?: Array<Tool> | null;
+    tool_choice?: "none" | "auto" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    } | null;
+    user?: string | null;
+}
+export interface Tool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface Message {
+    role: "user" | "assistant" | "system" | "tool" | "developer";
+    content: string | Array<ContentPart> | null;
+    name?: string;
+    tool_calls?: Array<ToolCall>;
+    tool_call_id?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export type ContentPart = TextPart | ImagePart;
+export interface TextPart {
+    type: "text";
+    text: string;
+}
+export interface ImagePart {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "low" | "high" | "auto";
+    };
+}
+export {};

package/dist/services/copilot/create-chat-completions.js

@@ -0,0 +1,32 @@
+import consola from "consola";
+import { events } from "fetch-event-stream";
+import { copilotHeadersForEntry, copilotBaseUrlForEntry } from "../../lib/api-config.js";
+import { HTTPError } from "../../lib/error.js";
+import { tokenManager } from "../../lib/token-manager.js";
+export const createChatCompletions = async (payload, tokenEntry) => {
+    // Get token entry - use provided one or get random for load balancing
+    const entry = tokenEntry || tokenManager.getRandomTokenEntry();
+    if (!entry)
+        throw new Error("No active tokens available");
+    const enableVision = payload.messages.some((x) => typeof x.content !== "string" &&
+        x.content?.some((x) => x.type === "image_url"));
+    const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+    const headers = {
+        ...copilotHeadersForEntry(entry, enableVision),
+        "X-Initiator": isAgentCall ? "agent" : "user",
+    };
+    const response = await fetch(`${copilotBaseUrlForEntry(entry)}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        consola.error("Failed to create chat completions", response);
+        tokenManager.reportError(entry.id);
+        throw new HTTPError("Failed to create chat completions", response);
+    }
+    if (payload.stream) {
+        return events(response);
+    }
+    return (await response.json());
+};

package/dist/services/copilot/create-embeddings.d.ts

@@ -0,0 +1,20 @@
+import { type TokenEntry } from "../../lib/token-manager.js";
+export declare const createEmbeddings: (payload: EmbeddingRequest, tokenEntry?: TokenEntry) => Promise<EmbeddingResponse>;
+export interface EmbeddingRequest {
+    input: string | Array<string>;
+    model: string;
+}
+export interface Embedding {
+    object: string;
+    embedding: Array<number>;
+    index: number;
+}
+export interface EmbeddingResponse {
+    object: string;
+    data: Array<Embedding>;
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}

package/dist/services/copilot/create-embeddings.js

@@ -0,0 +1,19 @@
+import { copilotHeadersForEntry, copilotBaseUrlForEntry } from "../../lib/api-config.js";
+import { HTTPError } from "../../lib/error.js";
+import { tokenManager } from "../../lib/token-manager.js";
+export const createEmbeddings = async (payload, tokenEntry) => {
+    // Get token entry - use provided one or get random for load balancing
+    const entry = tokenEntry || tokenManager.getRandomTokenEntry();
+    if (!entry)
+        throw new Error("No active tokens available");
+    const response = await fetch(`${copilotBaseUrlForEntry(entry)}/embeddings`, {
+        method: "POST",
+        headers: copilotHeadersForEntry(entry),
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        tokenManager.reportError(entry.id);
+        throw new HTTPError("Failed to create embeddings", response);
+    }
+    return (await response.json());
+};

package/dist/services/copilot/get-models.d.ts

@@ -0,0 +1,51 @@
+import { type TokenEntry } from "../../lib/token-manager.js";
+export declare const getModels: (tokenEntry?: TokenEntry) => Promise<ModelsResponse>;
+/**
+ * Get models for all active token entries (for grouped display)
+ */
+export declare const getModelsForAllTokens: () => Promise<TokenModelsResult[]>;
+export interface TokenModelsResult {
+    tokenId: number;
+    username: string | null;
+    accountType: string;
+    models: ModelsResponse | null;
+    error?: string;
+}
+export interface ModelsResponse {
+    data: Array<Model>;
+    object: string;
+}
+interface ModelLimits {
+    max_context_window_tokens?: number;
+    max_output_tokens?: number;
+    max_prompt_tokens?: number;
+    max_inputs?: number;
+}
+interface ModelSupports {
+    tool_calls?: boolean;
+    parallel_tool_calls?: boolean;
+    dimensions?: boolean;
+}
+interface ModelCapabilities {
+    family: string;
+    limits: ModelLimits;
+    object: string;
+    supports: ModelSupports;
+    tokenizer: string;
+    type: string;
+}
+export interface Model {
+    capabilities: ModelCapabilities;
+    id: string;
+    model_picker_enabled: boolean;
+    name: string;
+    object: string;
+    preview: boolean;
+    vendor: string;
+    version: string;
+    policy?: {
+        state: string;
+        terms: string;
+    };
+}
+export {};

package/dist/services/copilot/get-models.js

@@ -0,0 +1,45 @@
+import { copilotBaseUrlForEntry, copilotHeadersForEntry } from "../../lib/api-config.js";
+import { HTTPError } from "../../lib/error.js";
+import { tokenManager } from "../../lib/token-manager.js";
+export const getModels = async (tokenEntry) => {
+    // Get token entry - use provided one or get first active one
+    const entry = tokenEntry || tokenManager.getActiveTokenEntries()[0];
+    if (!entry)
+        throw new Error("No active tokens available");
+    const response = await fetch(`${copilotBaseUrlForEntry(entry)}/models`, {
+        headers: copilotHeadersForEntry(entry),
+    });
+    if (!response.ok) {
+        tokenManager.reportError(entry.id);
+        throw new HTTPError("Failed to get models", response);
+    }
+    return (await response.json());
+};
+/**
+ * Get models for all active token entries (for grouped display)
+ */
+export const getModelsForAllTokens = async () => {
+    const entries = tokenManager.getActiveTokenEntries();
+    const results = [];
+    for (const entry of entries) {
+        try {
+            const models = await getModels(entry);
+            results.push({
+                tokenId: entry.id,
+                username: entry.username,
+                accountType: entry.accountType,
+                models,
+            });
+        }
+        catch (error) {
+            results.push({
+                tokenId: entry.id,
+                username: entry.username,
+                accountType: entry.accountType,
+                models: null,
+                error: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    }
+    return results;
+};

package/dist/services/github/get-device-code.d.ts

@@ -0,0 +1,11 @@
+export declare const GITHUB_BASE_URL = "https://github.com";
+export declare const GITHUB_CLIENT_ID = "178c6fc778ccc68e1d6a";
+export declare const GITHUB_APP_SCOPES: string;
+export declare function getDeviceCode(): Promise<DeviceCodeResponse>;
+export interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    expires_in: number;
+    interval: number;
+}

package/dist/services/github/get-device-code.js

@@ -0,0 +1,21 @@
+import { standardHeaders } from "../../lib/api-config.js";
+import { HTTPError } from "../../lib/error.js";
+export const GITHUB_BASE_URL = "https://github.com";
+// GitHub CLI (gh) OAuth App Client ID
+export const GITHUB_CLIENT_ID = "178c6fc778ccc68e1d6a";
+// Scopes matching `gh auth login` defaults
+export const GITHUB_APP_SCOPES = ["gist", "read:org", "repo"].join(" ");
+export async function getDeviceCode() {
+    const response = await fetch(`${GITHUB_BASE_URL}/login/device/code`, {
+        method: "POST",
+        headers: standardHeaders(),
+        body: JSON.stringify({
+            client_id: GITHUB_CLIENT_ID,
+            scope: GITHUB_APP_SCOPES,
+        }),
+    });
+    if (!response.ok) {
+        throw new HTTPError("Failed to get device code", response);
+    }
+    return (await response.json());
+}

package/dist/services/github/get-user.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Get GitHub user info for a specific token
+ */
+export declare function getGitHubUserForToken(githubToken: string): Promise<GithubUserResponse>;
+export interface GithubUserResponse {
+    login: string;
+    id: number;
+    avatar_url: string;
+    name: string | null;
+    email: string | null;
+}

package/dist/services/github/get-user.js

@@ -0,0 +1,17 @@
+import { GITHUB_API_BASE_URL, standardHeaders } from "../../lib/api-config.js";
+import { HTTPError } from "../../lib/error.js";
+/**
+ * Get GitHub user info for a specific token
+ */
+export async function getGitHubUserForToken(githubToken) {
+    const response = await fetch(`${GITHUB_API_BASE_URL}/user`, {
+        headers: {
+            authorization: `token ${githubToken}`,
+            ...standardHeaders(),
+        },
+    });
+    if (!response.ok) {
+        throw new HTTPError("Failed to get GitHub user", response);
+    }
+    return (await response.json());
+}

package/dist/services/github/poll-access-token.d.ts

@@ -0,0 +1,13 @@
+import { type DeviceCodeResponse } from "./get-device-code.js";
+/**
+ * Check access token once (for client-side polling)
+ */
+export declare function checkAccessToken(deviceCode: string): Promise<{
+    access_token?: string;
+    error?: string;
+    error_description?: string;
+}>;
+/**
+ * Poll for access token after device code flow (blocking, for CLI use)
+ */
+export declare function pollAccessToken(deviceCode: DeviceCodeResponse): Promise<string>;

package/dist/services/github/poll-access-token.js

@@ -0,0 +1,56 @@
+import consola from "consola";
+import { standardHeaders } from "../../lib/api-config.js";
+import { GITHUB_BASE_URL, GITHUB_CLIENT_ID, } from "./get-device-code.js";
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check access token once (for client-side polling)
+ */
+export async function checkAccessToken(deviceCode) {
+    const response = await fetch(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
+        method: "POST",
+        headers: standardHeaders(),
+        body: JSON.stringify({
+            client_id: GITHUB_CLIENT_ID,
+            device_code: deviceCode,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        consola.error("Failed to check access token:", text);
+        return { error: "request_failed", error_description: text };
+    }
+    const json = await response.json();
+    consola.debug("Check access token response:", json);
+    return {
+        access_token: json.access_token,
+        error: json.error,
+        error_description: json.error_description,
+    };
+}
+/**
+ * Poll for access token after device code flow (blocking, for CLI use)
+ */
+export async function pollAccessToken(deviceCode) {
+    // Interval is in seconds, we need to multiply by 1000 to get milliseconds
+    // Adding another second to be safe
+    const sleepDuration = (deviceCode.interval + 1) * 1000;
+    consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+    while (true) {
+        const result = await checkAccessToken(deviceCode.device_code);
+        if (result.access_token) {
+            return result.access_token;
+        }
+        else if (result.error === "expired_token") {
+            throw new Error("Device code expired. Please try again.");
+        }
+        else {
+            await sleep(sleepDuration);
+        }
+    }
+}