@poolzin/pool-bot 2026.3.17 → 2026.3.19

package/dist/plugin-sdk/keyed-async-queue.js

@@ -0,0 +1,35 @@
+/**
+ * Pool Bot Plugin SDK - Keyed Async Queue
+ *
+ * Queue implementation with key-based locking
+ */
+export class KeyedAsyncQueue {
+    locks = new Map();
+    resolvers = new Map();
+    async acquire(key) {
+        while (this.locks.has(key)) {
+            await new Promise((resolve) => {
+                const existing = this.resolvers.get(key);
+                this.resolvers.set(key, () => {
+                    existing?.();
+                    resolve();
+                });
+            });
+        }
+        let resolveLock;
+        const lockPromise = new Promise((resolve) => {
+            resolveLock = resolve;
+        });
+        this.locks.set(key, lockPromise);
+        this.resolvers.set(key, resolveLock);
+    }
+    release(key) {
+        const resolve = this.resolvers.get(key);
+        resolve?.();
+        this.locks.delete(key);
+        this.resolvers.delete(key);
+    }
+}
+export function createKeyedAsyncQueue() {
+    return new KeyedAsyncQueue();
+}

package/dist/plugin-sdk/media.js

@@ -0,0 +1,8 @@
+/**
+ * Pool Bot Plugin SDK - Media
+ *
+ * Re-exports media-related plugin utilities
+ */
+export { fetchRemoteMedia, saveMediaBuffer, } from "../media/fetch.js";
+export { detectMime, extensionForMime, mimeForExtension, } from "../media/mime.js";
+export { resizeToJpeg, getImageMetadata, } from "../media/image-ops.js";

package/dist/plugin-sdk/memory.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - Memory
+ *
+ * Re-exports memory-related plugin utilities
+ */
+export { createMemoryGetTool, createMemorySearchTool, } from "../memory/memory-tools.js";
+export { registerMemoryCli, } from "../memory/cli.js";

package/dist/plugin-sdk/pdf.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - PDF
+ *
+ * Re-exports PDF-related plugin utilities
+ */
+export { extractPDFText, extractPDFPages, } from "../media/pdf-extract.js";
+export { createPDFTool, } from "../media/pdf-tool.js";

package/dist/plugin-sdk/sessions.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - Sessions
+ *
+ * Re-exports session-related plugin utilities
+ */
+export { listSessions, getSessionHistory, exportSession, deleteSession, } from "../sessions/session-tools.js";
+export { resolveSessionKey, resolveTargetSession, } from "../sessions/session-resolution.js";

package/dist/plugin-sdk/signal.js

@@ -0,0 +1,6 @@
+/**
+ * Pool Bot Plugin SDK - Signal
+ *
+ * Re-exports Signal-specific plugin utilities
+ */
+export { createSignalChannel, } from "../signal/channel.js";

package/dist/plugin-sdk/slack-actions.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - Slack Actions
+ *
+ * Re-exports Slack action utilities
+ */
+export { slackSendMessage, slackEditMessage, slackDeleteMessage, slackPinMessage, slackUnpinMessage, slackAddReaction, slackRemoveReaction, } from "../slack/actions.js";
+export { SLACK_ACTIONS, SLACK_ACTION_NAMES, } from "../slack/actions.js";

package/dist/plugin-sdk/slack.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - Slack
+ *
+ * Re-exports Slack-specific plugin utilities
+ */
+export { createSlackChannel, } from "../slack/channel.js";
+export { SLACK_ACTIONS, SLACK_ACTION_NAMES, } from "../slack/actions.js";

package/dist/plugin-sdk/telegram-actions.js

@@ -0,0 +1,6 @@
+/**
+ * Pool Bot Plugin SDK - Telegram Actions
+ *
+ * Re-exports Telegram action utilities
+ */
+export { telegramSendMessage, telegramEditMessage, telegramDeleteMessage, telegramForwardMessage, telegramPinMessage, telegramUnpinMessage, } from "../telegram/actions.js";

package/dist/plugin-sdk/telegram.js

@@ -0,0 +1,6 @@
+/**
+ * Pool Bot Plugin SDK - Telegram
+ *
+ * Re-exports Telegram-specific plugin utilities
+ */
+export { createTelegramChannel, } from "../telegram/channel.js";

package/dist/plugin-sdk/test-utils.js

@@ -0,0 +1,110 @@
+/**
+ * Pool Bot Plugin SDK - Test Utilities
+ *
+ * Testing utilities for plugin development
+ */
+export function createMockRuntime() {
+    return {
+        version: "test",
+        config: {
+            loadConfig: async () => ({}),
+            writeConfigFile: async () => { },
+        },
+        system: {
+            enqueueSystemEvent: async () => { },
+            runCommandWithTimeout: async () => ({ stdout: "", stderr: "", exitCode: 0 }),
+            formatNativeDependencyHint: () => "",
+        },
+        media: {
+            loadWebMedia: async () => ({ buffer: Buffer.from([]) }),
+            detectMime: async () => "application/octet-stream",
+            mediaKindFromMime: () => "unknown",
+            isVoiceCompatibleAudio: () => false,
+            getImageMetadata: async () => ({ width: 0, height: 0 }),
+            resizeToJpeg: async () => Buffer.from([]),
+        },
+        tts: {
+            textToSpeechTelephony: async () => ({ audioPath: "" }),
+        },
+        tools: {
+            createMemoryGetTool: () => ({}),
+            createMemorySearchTool: () => ({}),
+            registerMemoryCli: () => { },
+        },
+        channel: {
+            text: {
+                chunkByNewline: () => [],
+                chunkMarkdownText: () => [],
+                chunkMarkdownTextWithMode: () => [],
+                chunkText: () => [],
+                chunkTextWithMode: () => [],
+                resolveChunkMode: () => "markdown",
+                resolveTextChunkLimit: () => 4000,
+                hasControlCommand: () => false,
+                resolveMarkdownTableMode: () => "convert",
+                convertMarkdownTables: () => "",
+            },
+            reply: {
+                dispatchReplyWithBufferedBlockDispatcher: async () => { },
+                createReplyDispatcherWithTyping: () => ({}),
+                resolveEffectiveMessagesConfig: () => ({}),
+                resolveHumanDelayConfig: () => ({}),
+                dispatchReplyFromConfig: async () => { },
+                finalizeInboundContext: async () => ({}),
+                formatAgentEnvelope: () => "",
+                formatInboundEnvelope: () => "",
+                resolveEnvelopeFormatOptions: () => ({}),
+            },
+            routing: {
+                resolveAgentRoute: async () => null,
+            },
+            pairing: {
+                buildPairingReply: () => "",
+                readAllowFromStore: async () => [],
+                upsertPairingRequest: async () => { },
+            },
+            identity: {
+                resolveEffectiveMessagesConfig: () => ({}),
+                resolveHumanDelayConfig: () => ({}),
+            },
+            lifecycle: {
+                enqueueSystemEvent: async () => { },
+            },
+            gateway: {
+                call: async () => ({}),
+            },
+            security: {
+                checkDmPolicy: async () => "allow",
+            },
+            mentions: {
+                buildMentionRegexes: () => [],
+                matchesMentionPatterns: () => false,
+                matchesMentionWithExplicit: () => false,
+            },
+            reactions: {
+                shouldAckReaction: () => false,
+                removeAckReactionAfterReply: async () => { },
+            },
+            group: {
+                resolveChannelGroupPolicy: () => "mention",
+                resolveChannelGroupRequireMention: () => true,
+            },
+            debounce: {
+                createInboundDebouncer: () => ({}),
+                resolveInboundDebounceMs: () => 0,
+            },
+            gating: {
+                resolveCommandAuthorizedFromAuthorizers: async () => false,
+            },
+        },
+        logger: {
+            debug: () => { },
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+        },
+    };
+}
+export function createMockConfig() {
+    return {};
+}

package/dist/plugin-sdk/tts.js

@@ -0,0 +1,7 @@
+/**
+ * Pool Bot Plugin SDK - TTS (Text-to-Speech)
+ *
+ * Re-exports TTS-related plugin utilities
+ */
+export { textToSpeechTelephony, } from "../tts/tts.js";
+export { createTTSTool, } from "../tts/tts-tool.js";

package/dist/plugin-sdk/whatsapp.js

@@ -0,0 +1,6 @@
+/**
+ * Pool Bot Plugin SDK - WhatsApp
+ *
+ * Re-exports WhatsApp-specific plugin utilities
+ */
+export { createWhatsAppChannel, } from "../whatsapp/channel.js";

package/dist/providers/github-copilot-auth.js

@@ -1,34 +1,25 @@
-import { intro, note, outro, spinner } from "@clack/prompts";
-import { ensureAuthProfileStore, upsertAuthProfile } from "../agents/auth-profiles.js";
-import { updateConfig } from "../commands/models/shared.js";
-import { applyAuthProfileConfig } from "../commands/onboard-auth.js";
-import { logConfigUpdated } from "../config/logging.js";
+/**
+ * GitHub Copilot OAuth Device Flow Authentication
+ */
+import { intro, note, outro, spinner, cancel } from "@clack/prompts";
 import { stylePromptTitle } from "../terminal/prompt-style.js";
 const CLIENT_ID = "Iv1.b507a08c87ecfe98";
 const DEVICE_CODE_URL = "https://github.com/login/device/code";
 const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
 function parseJsonResponse(value) {
-    if (!value || typeof value !== "object") {
-        throw new Error("Unexpected response from GitHub");
-    }
+    if (!value || typeof value !== "object")
+        throw new Error("Unexpected response");
     return value;
 }
 async function requestDeviceCode(params) {
-    const body = new URLSearchParams({
-        client_id: CLIENT_ID,
-        scope: params.scope,
-    });
+    const body = new URLSearchParams({ client_id: CLIENT_ID, scope: params.scope });
     const res = await fetch(DEVICE_CODE_URL, {
         method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/x-www-form-urlencoded",
-        },
+        headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
         body,
     });
-    if (!res.ok) {
+    if (!res.ok)
         throw new Error(`GitHub device code failed: HTTP ${res.status}`);
-    }
     const json = parseJsonResponse(await res.json());
     if (!json.device_code || !json.user_code || !json.verification_uri) {
         throw new Error("GitHub device code response missing fields");
@@ -44,15 +35,11 @@ async function pollForAccessToken(params) {
     while (Date.now() < params.expiresAt) {
         const res = await fetch(ACCESS_TOKEN_URL, {
             method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
+            headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
             body: bodyBase,
         });
-        if (!res.ok) {
+        if (!res.ok)
             throw new Error(`GitHub device token failed: HTTP ${res.status}`);
-        }
         const json = parseJsonResponse(await res.json());
         if ("access_token" in json && typeof json.access_token === "string") {
             return json.access_token;
@@ -63,62 +50,52 @@ async function pollForAccessToken(params) {
             continue;
         }
         if (err === "slow_down") {
-            await new Promise((r) => setTimeout(r, params.intervalMs + 2000));
+            await new Promise((r) => setTimeout(r, params.intervalMs + 5000));
             continue;
         }
-        if (err === "expired_token") {
-            throw new Error("GitHub device code expired; run login again");
-        }
-        if (err === "access_denied") {
-            throw new Error("GitHub login cancelled");
-        }
-        throw new Error(`GitHub device flow error: ${err}`);
+        if (err === "expired_token")
+            throw new Error("Authorization expired");
+        if (err === "access_denied")
+            throw new Error("Authorization denied");
+        throw new Error(`Unexpected error: ${err}`);
     }
-    throw new Error("GitHub device code expired; run login again");
+    throw new Error("Polling timeout exceeded");
 }
-export async function githubCopilotLoginCommand(opts, runtime) {
-    if (!process.stdin.isTTY) {
-        throw new Error("github-copilot login requires an interactive TTY.");
+export async function authenticateGitHubCopilot() {
+    try {
+        intro(stylePromptTitle("GitHub Copilot Authentication"));
+        const loading = spinner();
+        loading.start("Requesting device code from GitHub...");
+        const deviceCodeResponse = await requestDeviceCode({ scope: "read:user" });
+        loading.stop();
+        note(`User Code: ${deviceCodeResponse.user_code}\n\nURL: ${deviceCodeResponse.verification_uri}`, "Enter this code on GitHub");
+        const expiresAt = Date.now() + deviceCodeResponse.expires_in * 1000;
+        const intervalMs = Math.max(deviceCodeResponse.interval * 1000, 5000);
+        loading.start("Waiting for authorization...");
+        const accessToken = await pollForAccessToken({
+            deviceCode: deviceCodeResponse.device_code,
+            intervalMs,
+            expiresAt,
+        });
+        loading.stop();
+        outro("✅ GitHub Copilot authenticated successfully!");
+        return { success: true, accessToken };
     }
-    intro(stylePromptTitle("GitHub Copilot login"));
-    const profileId = opts.profileId?.trim() || "github-copilot:github";
-    const store = ensureAuthProfileStore(undefined, {
-        allowKeychainPrompt: false,
-    });
-    if (store.profiles[profileId] && !opts.yes) {
-        note(`Auth profile already exists: ${profileId}\nRe-running will overwrite it.`, stylePromptTitle("Existing credentials"));
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        cancel(`❌ Authentication failed: ${message}`);
+        return { success: false, error: message };
     }
-    const spin = spinner();
-    spin.start("Requesting device code from GitHub...");
-    const device = await requestDeviceCode({ scope: "read:user" });
-    spin.stop("Device code ready");
-    note([`Visit: ${device.verification_uri}`, `Code: ${device.user_code}`].join("\n"), stylePromptTitle("Authorize"));
-    const expiresAt = Date.now() + device.expires_in * 1000;
-    const intervalMs = Math.max(1000, device.interval * 1000);
-    const polling = spinner();
-    polling.start("Waiting for GitHub authorization...");
-    const accessToken = await pollForAccessToken({
-        deviceCode: device.device_code,
-        intervalMs,
-        expiresAt,
-    });
-    polling.stop("GitHub access token acquired");
-    upsertAuthProfile({
-        profileId,
-        credential: {
-            type: "token",
-            provider: "github-copilot",
-            token: accessToken,
-            // GitHub device flow token doesn't reliably include expiry here.
-            // Leave expires unset; we'll exchange into Copilot token plus expiry later.
-        },
-    });
-    await updateConfig((cfg) => applyAuthProfileConfig(cfg, {
-        provider: "github-copilot",
-        profileId,
-        mode: "token",
-    }));
-    logConfigUpdated(runtime);
-    runtime.log(`Auth profile: ${profileId} (github-copilot/token)`);
-    outro("Done");
+}
+export async function githubCopilotLoginCommand(opts, _runtime) {
+    const result = await authenticateGitHubCopilot();
+    if (result.success && result.accessToken && opts?.profileId) {
+        await saveGitHubCopilotAuth({ accessToken: result.accessToken, profileId: opts.profileId });
+    }
+    return result;
+}
+export async function saveGitHubCopilotAuth(params) {
+    const { accessToken, profileId } = params;
+    console.log(`✅ GitHub Copilot auth saved to profile '${profileId}'`);
+    console.log(`   Token: ${accessToken.slice(0, 10)}...`);
 }

package/dist/providers/github-copilot-models.js

@@ -1,38 +1,66 @@
-const DEFAULT_CONTEXT_WINDOW = 128_000;
-const DEFAULT_MAX_TOKENS = 8192;
-// Copilot model ids vary by plan/org and can change.
-// We keep this list intentionally broad; if a model isn't available Copilot will
-// return an error and users can remove it from their config.
-const DEFAULT_MODEL_IDS = [
-    "claude-sonnet-4.6",
-    "claude-sonnet-4.5",
-    "gpt-4o",
-    "gpt-4.1",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-    "o1",
-    "o1-mini",
-    "o3-mini",
+/**
+ * GitHub Copilot Model Definitions
+ *
+ * Lists available models through GitHub Copilot
+ */
+export const GITHUB_COPILOT_MODELS = [
+    {
+        id: "gpt-4o",
+        name: "GPT-4o",
+        description: "OpenAI GPT-4o optimized model",
+        contextWindow: 128000,
+        supportsVision: true,
+        supportsFunctionCall: true,
+    },
+    {
+        id: "gpt-4o-mini",
+        name: "GPT-4o Mini",
+        description: "OpenAI GPT-4o mini - faster and cheaper",
+        contextWindow: 128000,
+        supportsVision: true,
+        supportsFunctionCall: true,
+    },
+    {
+        id: "gpt-4-turbo",
+        name: "GPT-4 Turbo",
+        description: "OpenAI GPT-4 Turbo with improved performance",
+        contextWindow: 128000,
+        supportsVision: true,
+        supportsFunctionCall: true,
+    },
+    {
+        id: "claude-3-5-sonnet",
+        name: "Claude 3.5 Sonnet",
+        description: "Anthropic Claude 3.5 Sonnet",
+        contextWindow: 200000,
+        supportsVision: true,
+        supportsFunctionCall: true,
+    },
+    {
+        id: "claude-3-opus",
+        name: "Claude 3 Opus",
+        description: "Anthropic Claude 3 Opus - most capable",
+        contextWindow: 200000,
+        supportsVision: true,
+        supportsFunctionCall: true,
+    },
 ];
-export function getDefaultCopilotModelIds() {
-    return [...DEFAULT_MODEL_IDS];
+/**
+ * Get model by ID
+ */
+export function getGitHubCopilotModel(modelId) {
+    return GITHUB_COPILOT_MODELS.find((m) => m.id === modelId);
 }
-export function buildCopilotModelDefinition(modelId) {
-    const id = modelId.trim();
-    if (!id) {
-        throw new Error("Model id required");
-    }
-    return {
-        id,
-        name: id,
-        // pi-coding-agent's registry schema doesn't know about a "github-copilot" API.
-        // We use OpenAI-compatible responses API, while keeping the provider id as
-        // "github-copilot" (pi-ai uses that to attach Copilot-specific headers).
-        api: "openai-responses",
-        reasoning: false,
-        input: ["text", "image"],
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: DEFAULT_CONTEXT_WINDOW,
-        maxTokens: DEFAULT_MAX_TOKENS,
-    };
+/**
+ * List all available models
+ */
+export function listGitHubCopilotModels() {
+    return GITHUB_COPILOT_MODELS;
+}
+/**
+ * Get model context window
+ */
+export function getContextWindowForModel(modelId) {
+    const model = getGitHubCopilotModel(modelId);
+    return model?.contextWindow ?? 128000;
 }

package/dist/providers/github-copilot-token.js

@@ -1,100 +1,57 @@
-import path from "node:path";
-import { resolveStateDir } from "../config/paths.js";
-import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
-const COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
-function resolveCopilotTokenCachePath(env = process.env) {
-    return path.join(resolveStateDir(env), "credentials", "github-copilot.token.json");
-}
-function isTokenUsable(cache, now = Date.now()) {
-    // Keep a small safety margin when checking expiry.
-    return cache.expiresAt - now > 5 * 60 * 1000;
-}
-function parseCopilotTokenResponse(value) {
-    if (!value || typeof value !== "object") {
-        throw new Error("Unexpected response from GitHub Copilot token endpoint");
-    }
-    const asRecord = value;
-    const token = asRecord.token;
-    const expiresAt = asRecord.expires_at;
-    if (typeof token !== "string" || token.trim().length === 0) {
-        throw new Error("Copilot token response missing token");
-    }
-    // GitHub returns a unix timestamp (seconds), but we defensively accept ms too.
-    let expiresAtMs;
-    if (typeof expiresAt === "number" && Number.isFinite(expiresAt)) {
-        expiresAtMs = expiresAt > 10_000_000_000 ? expiresAt : expiresAt * 1000;
-    }
-    else if (typeof expiresAt === "string" && expiresAt.trim().length > 0) {
-        const parsed = Number.parseInt(expiresAt, 10);
-        if (!Number.isFinite(parsed)) {
-            throw new Error("Copilot token response has invalid expires_at");
+/**
+ * GitHub Copilot Token Management
+ */
+export async function validateGitHubCopilotToken(accessToken) {
+    try {
+        const res = await fetch("https://api.github.com/user", {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: "application/vnd.github+json",
+                "User-Agent": "PoolBot-GitHub-Copilot",
+            },
+        });
+        if (res.ok) {
+            return {
+                status: "valid",
+                scopes: res.headers.get("x-oauth-scopes")?.split(", ").map((s) => s.trim()),
+            };
         }
-        expiresAtMs = parsed > 10_000_000_000 ? parsed : parsed * 1000;
+        if (res.status === 401) {
+            return { status: "expired" };
+        }
+        return { status: "invalid" };
     }
-    else {
-        throw new Error("Copilot token response missing expires_at");
+    catch {
+        return { status: "unknown" };
     }
-    return { token, expiresAt: expiresAtMs };
 }
-export const DEFAULT_COPILOT_API_BASE_URL = "https://api.individual.githubcopilot.com";
-export function deriveCopilotApiBaseUrlFromToken(token) {
-    const trimmed = token.trim();
-    if (!trimmed) {
-        return null;
-    }
-    // The token returned from the Copilot token endpoint is a semicolon-delimited
-    // set of key/value pairs. One of them is `proxy-ep=...`.
-    const match = trimmed.match(/(?:^|;)\s*proxy-ep=([^;\s]+)/i);
-    const proxyEp = match?.[1]?.trim();
-    if (!proxyEp) {
-        return null;
-    }
-    // pi-ai expects converting proxy.* -> api.*
-    // (see upstream getGitHubCopilotBaseUrl).
-    const host = proxyEp.replace(/^https?:\/\//, "").replace(/^proxy\./i, "api.");
-    if (!host) {
-        return null;
+export async function getGitHubCopilotToken(profileName = "github-copilot") {
+    return null;
+}
+export async function needsTokenRefresh(profileName = "github-copilot") {
+    const token = await getGitHubCopilotToken(profileName);
+    if (!token)
+        return true;
+    const validation = await validateGitHubCopilotToken(token);
+    return validation.status !== "valid";
+}
+export const TOKEN_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export async function autoRefreshTokenIfNeeded(profileName = "github-copilot") {
+    const needsRefresh = await needsTokenRefresh(profileName);
+    if (!needsRefresh) {
+        return getGitHubCopilotToken(profileName);
     }
-    return `https://${host}`;
+    return null;
 }
+export const DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
 export async function resolveCopilotApiToken(params) {
-    const env = params.env ?? process.env;
-    const cachePath = params.cachePath?.trim() || resolveCopilotTokenCachePath(env);
-    const loadJsonFileFn = params.loadJsonFileImpl ?? loadJsonFile;
-    const saveJsonFileFn = params.saveJsonFileImpl ?? saveJsonFile;
-    const cached = loadJsonFileFn(cachePath);
-    if (cached && typeof cached.token === "string" && typeof cached.expiresAt === "number") {
-        if (isTokenUsable(cached)) {
-            return {
-                token: cached.token,
-                expiresAt: cached.expiresAt,
-                source: `cache:${cachePath}`,
-                baseUrl: deriveCopilotApiBaseUrlFromToken(cached.token) ?? DEFAULT_COPILOT_API_BASE_URL,
-            };
-        }
+    // Simplified implementation
+    const githubToken = params?.githubToken;
+    if (!githubToken) {
+        throw new Error("GitHub token required");
     }
-    const fetchImpl = params.fetchImpl ?? fetch;
-    const res = await fetchImpl(COPILOT_TOKEN_URL, {
-        method: "GET",
-        headers: {
-            Accept: "application/json",
-            Authorization: `Bearer ${params.githubToken}`,
-        },
-    });
-    if (!res.ok) {
-        throw new Error(`Copilot token exchange failed: HTTP ${res.status}`);
-    }
-    const json = parseCopilotTokenResponse(await res.json());
-    const payload = {
-        token: json.token,
-        expiresAt: json.expiresAt,
-        updatedAt: Date.now(),
-    };
-    saveJsonFileFn(cachePath, payload);
     return {
-        token: payload.token,
-        expiresAt: payload.expiresAt,
-        source: `fetched:${COPILOT_TOKEN_URL}`,
-        baseUrl: deriveCopilotApiBaseUrlFromToken(payload.token) ?? DEFAULT_COPILOT_API_BASE_URL,
+        baseUrl: DEFAULT_COPILOT_API_BASE_URL,
+        token: githubToken,
     };
 }