@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/providers/gemini.js

@@ -0,0 +1,391 @@
+import { REASONING_BUDGET_MAP } from './interface.js';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { toGeminiFunctionDeclarations, toGeminiContents, fromGeminiParts, } from './tool-formats.js';
+import { summarizeError, toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const GEMINI_API_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+const GEMINI_CACHE_TTL_SECONDS = 3600;
+const NOOP_CACHE_HIT_TRACKER = {
+    recordTurn: () => { },
+};
+/**
+ * GeminiProvider — calls the Gemini generateContent API directly via fetch.
+ * Tools are `functionDeclarations` inside a `tools` array.
+ * Tool calls come as `functionCall` parts; results as `functionResponse` parts.
+ * Uses streamGenerateContent for real-time token delivery when onDelta is provided.
+ */
+export class GeminiProvider {
+    name = 'gemini';
+    /** Maps function call name → thoughtSignature for the current turn. */
+    thoughtSignatures = new Map();
+    models = [];
+    apiKey;
+    embeddingModel = 'gemini-embedding-001';
+    cacheHitTracker;
+    /** Active cached content resource name (e.g., "cachedContents/abc123") */
+    cachedContentName = null;
+    /** Hash of the content that was cached (systemPrompt + tools + model) */
+    cachedContentHash = null;
+    /** When the cache expires (epoch ms) */
+    cachedContentExpiry = 0;
+    /** Hashes known to be below the 32K cache minimum — skip API call */
+    uncacheableHashes = new Set();
+    constructor(apiKey, cacheHitTracker = NOOP_CACHE_HIT_TRACKER) {
+        this.apiKey = apiKey;
+        this.cacheHitTracker = cacheHitTracker;
+    }
+    computeCacheHash(systemPrompt, tools, model) {
+        const raw = (systemPrompt ?? '') + JSON.stringify(tools ?? []) + model;
+        const hasher = new Bun.CryptoHasher('sha256');
+        hasher.update(raw);
+        return hasher.digest('hex');
+    }
+    async ensureCachedContent(systemPrompt, tools, model) {
+        // Skip if no system prompt and no tools
+        if (!systemPrompt && (!tools || tools.length === 0))
+            return null;
+        const hash = this.computeCacheHash(systemPrompt, tools, model);
+        // Skip if previously determined to be below 32K threshold
+        if (this.uncacheableHashes.has(hash))
+            return null;
+        // Reuse existing cache if hash matches and not expired (with 60s buffer)
+        if (this.cachedContentName &&
+            this.cachedContentHash === hash &&
+            this.cachedContentExpiry > Date.now() + 60_000) {
+            return this.cachedContentName;
+        }
+        // Estimate tokens — skip if below 28K (conservative buffer below 32K minimum)
+        const estimatedChars = (systemPrompt?.length ?? 0) + JSON.stringify(tools ?? []).length;
+        if (estimatedChars / 3 < 28_000) {
+            if (this.uncacheableHashes.size >= 50)
+                this.uncacheableHashes.clear();
+            this.uncacheableHashes.add(hash);
+            logger.debug('[Gemini] Content below 32K cache threshold, skipping cache', {
+                estimatedTokens: Math.round(estimatedChars / 3),
+            });
+            return null;
+        }
+        // Delete old cache if hash changed (fire-and-forget)
+        if (this.cachedContentName && this.cachedContentHash !== hash) {
+            const oldName = this.cachedContentName;
+            fetch(`${GEMINI_API_BASE}/${oldName}`, {
+                method: 'DELETE',
+                headers: { 'x-goog-api-key': this.apiKey },
+            }).catch(err => logger.warn('[Gemini] Failed to delete old cache', { error: summarizeError(err) }));
+        }
+        // Create new cached content
+        try {
+            const cacheBody = {
+                model: `models/${model}`,
+                ttl: `${GEMINI_CACHE_TTL_SECONDS}s`,
+            };
+            if (systemPrompt) {
+                cacheBody['systemInstruction'] = { parts: [{ text: systemPrompt }] };
+            }
+            if (tools && tools.length > 0) {
+                cacheBody['tools'] = [{ functionDeclarations: toGeminiFunctionDeclarations(tools) }];
+            }
+            const res = await fetch(`${GEMINI_API_BASE}/cachedContents`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-goog-api-key': this.apiKey,
+                },
+                body: JSON.stringify(cacheBody),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => '');
+                if (text.includes('too few tokens') || text.includes('minimum')) {
+                    if (this.uncacheableHashes.size >= 50)
+                        this.uncacheableHashes.clear();
+                    this.uncacheableHashes.add(hash);
+                    logger.debug('[Gemini] Content below cache minimum', { status: res.status, error: text.slice(0, 200) });
+                }
+                else {
+                    logger.debug('[Gemini] Cache creation failed', { status: res.status, error: text.slice(0, 200) });
+                }
+                return null;
+            }
+            const data = await res.json();
+            this.cachedContentName = data.name;
+            this.cachedContentHash = hash;
+            this.cachedContentExpiry = new Date(data.expireTime).getTime();
+            logger.info(`[Gemini] Created cache: ${data.name} (expires ${data.expireTime})`);
+            return data.name;
+        }
+        catch (err) {
+            logger.debug('[Gemini] Cache creation error', { error: summarizeError(err) });
+            return null;
+        }
+    }
+    async chat(params) {
+        const { messages, tools, model, maxTokens, signal, systemPrompt, onDelta, reasoningEffort } = params;
+        return withRetry(async () => {
+            const { contents, systemInstruction } = toGeminiContents(messages, systemPrompt);
+            // Inject thoughtSignatures into both model functionCall parts and user functionResponse parts
+            // (Gemini thinking models require the signature on both sides of the round-trip)
+            for (const c of contents) {
+                for (const part of c.parts) {
+                    const p = part;
+                    if (p.functionCall) {
+                        const fc = p.functionCall;
+                        const sig = this.thoughtSignatures.get(fc.name);
+                        if (sig)
+                            p.thoughtSignature = sig;
+                    }
+                    if (p.functionResponse) {
+                        const fr = p.functionResponse;
+                        const sig = this.thoughtSignatures.get(fr.name);
+                        if (sig)
+                            p.thoughtSignature = sig;
+                    }
+                }
+            }
+            const body = { contents };
+            const cachedName = await this.ensureCachedContent(systemPrompt, tools, model);
+            if (cachedName) {
+                // Cached content already contains systemInstruction and tools — do NOT resend them
+                body['cachedContent'] = cachedName;
+            }
+            else {
+                if (systemInstruction) {
+                    body['systemInstruction'] = systemInstruction;
+                }
+                if (tools && tools.length > 0) {
+                    body['tools'] = [{
+                            functionDeclarations: toGeminiFunctionDeclarations(tools),
+                        }];
+                }
+            }
+            if (maxTokens) {
+                body['generationConfig'] = { maxOutputTokens: maxTokens };
+            }
+            if (reasoningEffort) {
+                const budget = REASONING_BUDGET_MAP[reasoningEffort];
+                if (budget !== undefined) {
+                    body['generationConfig'] = {
+                        ...(body['generationConfig'] ?? {}),
+                        thinking_config: { thinking_budget: budget },
+                    };
+                }
+            }
+            // Always use streaming endpoint; parse NDJSON chunks
+            const url = `${GEMINI_API_BASE}/models/${model}:streamGenerateContent?alt=sse`;
+            let res;
+            try {
+                res = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-goog-api-key': this.apiKey,
+                    },
+                    body: JSON.stringify(body),
+                    signal,
+                });
+            }
+            catch (err) {
+                throw toProviderError(err, {
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'request',
+                });
+            }
+            if (!res.ok) {
+                const text = await res.text().catch(() => 'unknown error');
+                throw new ProviderError(`Gemini API error ${res.status}: ${text}`, {
+                    statusCode: res.status,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'request',
+                });
+            }
+            // Accumulate state from streaming chunks
+            const allParts = [];
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let cacheReadTokens = 0;
+            let lastFinishReason = '';
+            let streamedText = '';
+            const reader = res.body?.getReader();
+            if (!reader) {
+                throw new ProviderError('Gemini chat returned no response body.', {
+                    statusCode: 502,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'response',
+                });
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6).trim();
+                        if (!data || data === '[DONE]')
+                            continue;
+                        let chunk;
+                        try {
+                            chunk = JSON.parse(data);
+                        }
+                        catch {
+                            logger.debug('Gemini SSE: failed to parse JSON chunk', { data });
+                            continue;
+                        }
+                        const candidate = chunk.candidates?.[0];
+                        if (candidate) {
+                            const parts = candidate.content?.parts ?? [];
+                            for (const part of parts) {
+                                allParts.push(part);
+                                if (part.text && onDelta) {
+                                    streamedText += part.text;
+                                    onDelta({ content: part.text });
+                                }
+                                if (part.functionCall) {
+                                    // Capture thoughtSignature if present (Gemini thinking models)
+                                    if (part.thoughtSignature) {
+                                        this.thoughtSignatures.set(part.functionCall.name, part.thoughtSignature);
+                                    }
+                                    if (onDelta) {
+                                        onDelta({ toolCalls: [{ index: 0, name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args) }] });
+                                    }
+                                }
+                            }
+                            if (candidate.finishReason) {
+                                lastFinishReason = candidate.finishReason;
+                            }
+                        }
+                        if (chunk.usageMetadata) {
+                            inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens;
+                            outputTokens = chunk.usageMetadata.candidatesTokenCount ?? outputTokens;
+                            cacheReadTokens = chunk.usageMetadata.cachedContentTokenCount ?? cacheReadTokens;
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // Use streamed text directly if available (avoids re-parsing duplicated text parts)
+            const { text: parsedText, toolCalls } = fromGeminiParts(allParts);
+            // Prefer streamedText for content; fall back to parsed if no streaming happened
+            const text = streamedText || parsedText;
+            let stopReason = 'end';
+            if (lastFinishReason === 'MAX_TOKENS')
+                stopReason = 'max_tokens';
+            else if (toolCalls.length > 0)
+                stopReason = 'tool_use';
+            // Clear old signatures — new ones were captured from this response's functionCall parts
+            // (kept across calls within a tool-use loop, cleared when no new functionCalls arrive)
+            if (toolCalls.length === 0) {
+                this.thoughtSignatures.clear();
+            }
+            this.cacheHitTracker.recordTurn({
+                inputTokens,
+                cacheReadTokens,
+            });
+            return {
+                content: text,
+                toolCalls,
+                usage: {
+                    inputTokens,
+                    outputTokens,
+                    ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
+                    // cacheWriteTokens is omitted: Gemini does not charge separately for cache writes
+                },
+                stopReason,
+            };
+        });
+    }
+    async embed(request) {
+        const model = request.model ?? this.embeddingModel;
+        const body = {
+            content: { parts: [{ text: request.text }] },
+        };
+        if (request.dimensions) {
+            body['config'] = { outputDimensionality: request.dimensions };
+        }
+        let res;
+        try {
+            res = await fetch(`${GEMINI_API_BASE}/models/${model}:embedContent`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-goog-api-key': this.apiKey,
+                },
+                body: JSON.stringify(body),
+                signal: request.signal,
+            });
+        }
+        catch (error) {
+            throw toProviderError(error, {
+                provider: this.name,
+                operation: 'embed',
+                phase: 'request',
+            });
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => 'unknown error');
+            throw new ProviderError(`Gemini embeddings API error ${res.status}: ${text}`, {
+                statusCode: res.status,
+                provider: this.name,
+                operation: 'embed',
+                phase: 'request',
+            });
+        }
+        const data = await res.json();
+        const values = data.embedding?.values ?? [];
+        return {
+            vector: Float32Array.from(values),
+            dimensions: values.length,
+            modelId: model,
+            metadata: {
+                usage: request.usage,
+                provider: this.name,
+            },
+        };
+    }
+    async describeRuntime(deps) {
+        const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.js');
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: 'gemini',
+            apiKeyEnvVars: ['GEMINI_API_KEY', 'GOOGLE_API_KEY', 'GOOGLE_GEMINI_API_KEY'],
+            serviceNames: ['gemini'],
+        }, deps);
+        return {
+            auth: {
+                mode: 'api-key',
+                configured: Boolean(this.apiKey),
+                detail: this.apiKey ? 'Gemini API key available' : 'Gemini API key is not configured',
+                envVars: ['GEMINI_API_KEY', 'GOOGLE_API_KEY', 'GOOGLE_GEMINI_API_KEY'],
+                routes: authRoutes,
+            },
+            models: {
+                models: this.models,
+                embeddingModel: this.embeddingModel,
+                embeddingDimensions: 384,
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: true,
+                notes: ['Embeddings use Gemini embedContent with reduced output dimensionality when requested.'],
+            },
+            policy: {
+                local: false,
+                streamProtocol: 'gemini-sse',
+                reasoningMode: 'thinking_budget',
+                supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+                cacheStrategy: 'gemini-cached-content',
+            },
+        };
+    }
+}

package/dist/_internal/platform/providers/github-copilot.d.ts

@@ -0,0 +1,16 @@
+import type { ChatRequest, ChatResponse, LLMProvider, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+export interface GitHubCopilotProviderOptions {
+    readonly tokenCachePath: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly fetchFn?: typeof fetch;
+}
+export declare function getGitHubCopilotTokenCachePath(cacheDir: string): string;
+export declare class GitHubCopilotProvider implements LLMProvider {
+    private readonly options;
+    readonly name = "github-copilot";
+    readonly models: string[];
+    constructor(options: GitHubCopilotProviderOptions);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+//# sourceMappingURL=github-copilot.d.ts.map

package/dist/_internal/platform/providers/github-copilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-copilot.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/github-copilot.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAoBnI,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACjC;AAED,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvE;AA+HD,qBAAa,qBAAsB,YAAW,WAAW;IAe3C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAdpC,QAAQ,CAAC,IAAI,oBAAoB;IACjC,QAAQ,CAAC,MAAM,WAWb;gBAE2B,OAAO,EAAE,4BAA4B;IAE5D,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA2ChD,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAoC3F"}

package/dist/_internal/platform/providers/github-copilot.js

@@ -0,0 +1,234 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { AnthropicCompatProvider } from './anthropic-compat.js';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { buildStandardProviderAuthRoutes } from './runtime-metadata.js';
+import { toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const COPILOT_TOKEN_URL = 'https://api.github.com/copilot_internal/v2/token';
+const DEFAULT_COPILOT_API_BASE_URL = 'https://api.individual.githubcopilot.com';
+const COPILOT_EDITOR_VERSION = 'vscode/1.96.2';
+const COPILOT_USER_AGENT = 'GitHubCopilotChat/0.26.7';
+const COPILOT_GITHUB_API_VERSION = '2025-04-01';
+const COPILOT_TOKEN_ENV_VARS = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
+export function getGitHubCopilotTokenCachePath(cacheDir) {
+    return join(cacheDir, 'credentials', 'github-copilot.token.json');
+}
+function readFirstEnv(envVars, env) {
+    for (const envVar of envVars) {
+        const value = env[envVar];
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value.trim();
+    }
+    return null;
+}
+function buildCopilotIdeHeaders(includeApiVersion = false) {
+    return {
+        'Editor-Version': COPILOT_EDITOR_VERSION,
+        'User-Agent': COPILOT_USER_AGENT,
+        ...(includeApiVersion ? { 'X-Github-Api-Version': COPILOT_GITHUB_API_VERSION } : {}),
+    };
+}
+function hasCopilotVisionInput(messages) {
+    return messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part.type === 'image'));
+}
+function buildCopilotDynamicHeaders(messages) {
+    const last = messages[messages.length - 1];
+    const initiator = last && last.role !== 'user' ? 'agent' : 'user';
+    return {
+        ...buildCopilotIdeHeaders(false),
+        'X-Initiator': initiator,
+        'Openai-Intent': 'conversation-edits',
+        ...(hasCopilotVisionInput(messages) ? { 'Copilot-Vision-Request': 'true' } : {}),
+    };
+}
+function isTokenUsable(cache, now = Date.now()) {
+    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 record = value;
+    const token = typeof record['token'] === 'string' ? record['token'].trim() : '';
+    const rawExpiresAt = record['expires_at'];
+    if (!token)
+        throw new Error('Copilot token response missing token');
+    let expiresAt;
+    if (typeof rawExpiresAt === 'number' && Number.isFinite(rawExpiresAt)) {
+        expiresAt = rawExpiresAt < 100_000_000_000 ? rawExpiresAt * 1000 : rawExpiresAt;
+    }
+    else if (typeof rawExpiresAt === 'string' && rawExpiresAt.trim()) {
+        const parsed = Number.parseInt(rawExpiresAt.trim(), 10);
+        if (!Number.isFinite(parsed))
+            throw new Error('Copilot token response has invalid expires_at');
+        expiresAt = parsed < 100_000_000_000 ? parsed * 1000 : parsed;
+    }
+    else {
+        throw new Error('Copilot token response missing expires_at');
+    }
+    return { token, expiresAt };
+}
+function deriveCopilotApiBaseUrlFromToken(token) {
+    const match = token.trim().match(/(?:^|;)\s*proxy-ep=([^;\s]+)/i);
+    const proxyEp = match?.[1]?.trim();
+    if (!proxyEp)
+        return null;
+    const candidate = /^https?:\/\//i.test(proxyEp) ? proxyEp : `https://${proxyEp}`;
+    try {
+        const parsed = new URL(candidate);
+        const host = parsed.hostname.replace(/^proxy\./i, 'api.');
+        return `https://${host}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveCopilotToken(options) {
+    const env = options.env ?? process.env;
+    const fetchFn = options.fetchFn ?? fetch;
+    const githubToken = readFirstEnv(COPILOT_TOKEN_ENV_VARS, env);
+    if (!githubToken) {
+        throw new Error('GitHub Copilot requires COPILOT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN.');
+    }
+    const cachePath = options.tokenCachePath;
+    if (existsSync(cachePath)) {
+        try {
+            const cached = JSON.parse(readFileSync(cachePath, 'utf-8'));
+            if (cached?.token && typeof cached.expiresAt === 'number' && isTokenUsable(cached)) {
+                return {
+                    token: cached.token,
+                    baseUrl: deriveCopilotApiBaseUrlFromToken(cached.token) ?? DEFAULT_COPILOT_API_BASE_URL,
+                    expiresAt: cached.expiresAt,
+                };
+            }
+        }
+        catch {
+            // Ignore stale or malformed cache files.
+        }
+    }
+    const response = await fetchFn(COPILOT_TOKEN_URL, {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${githubToken}`,
+            ...buildCopilotIdeHeaders(true),
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Copilot token exchange failed: HTTP ${response.status}`);
+    }
+    const parsed = parseCopilotTokenResponse(await response.json());
+    const cachePayload = {
+        token: parsed.token,
+        expiresAt: parsed.expiresAt,
+        updatedAt: Date.now(),
+    };
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, JSON.stringify(cachePayload, null, 2));
+    return {
+        token: parsed.token,
+        baseUrl: deriveCopilotApiBaseUrlFromToken(parsed.token) ?? DEFAULT_COPILOT_API_BASE_URL,
+        expiresAt: parsed.expiresAt,
+    };
+}
+function usesAnthropicTransport(model) {
+    return model.trim().toLowerCase().includes('claude');
+}
+export class GitHubCopilotProvider {
+    options;
+    name = 'github-copilot';
+    models = [
+        'claude-sonnet-4.6',
+        'claude-sonnet-4.5',
+        'gpt-4o',
+        'gpt-4.1',
+        'gpt-4.1-mini',
+        'gpt-4.1-nano',
+        'gpt-5.4',
+        'o1',
+        'o1-mini',
+        'o3-mini',
+    ];
+    constructor(options) {
+        this.options = options;
+    }
+    async chat(params) {
+        try {
+            const model = params.model ?? this.models[0];
+            const session = await resolveCopilotToken(this.options);
+            const baseURL = `${session.baseUrl.replace(/\/+$/, '')}/v1`;
+            const defaultHeaders = buildCopilotDynamicHeaders(params.messages);
+            if (usesAnthropicTransport(model)) {
+                const provider = new AnthropicCompatProvider({
+                    name: this.name,
+                    baseURL,
+                    apiKey: session.token,
+                    defaultModel: model,
+                    models: this.models,
+                    defaultHeaders,
+                    authEnvVars: COPILOT_TOKEN_ENV_VARS,
+                    serviceNames: ['github-copilot'],
+                    authHeaderMode: 'bearer',
+                    streamProtocol: 'anthropic-sse',
+                });
+                return provider.chat({ ...params, model });
+            }
+            const provider = new OpenAICompatProvider({
+                name: this.name,
+                baseURL,
+                apiKey: session.token,
+                defaultModel: model,
+                models: this.models,
+                defaultHeaders,
+                authEnvVars: COPILOT_TOKEN_ENV_VARS,
+                serviceNames: ['github-copilot'],
+                aliases: ['copilot'],
+                streamProtocol: 'openai-sse',
+            });
+            return provider.chat({ ...params, model });
+        }
+        catch (error) {
+            throw toProviderError(error, {
+                provider: this.name,
+                operation: 'chat',
+            });
+        }
+    }
+    async describeRuntime(deps) {
+        const configured = readFirstEnv(COPILOT_TOKEN_ENV_VARS, this.options.env ?? process.env) !== null;
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: this.name,
+            apiKeyEnvVars: COPILOT_TOKEN_ENV_VARS,
+            secretKeys: COPILOT_TOKEN_ENV_VARS,
+            serviceNames: ['github-copilot'],
+        }, deps);
+        return {
+            auth: {
+                mode: 'api-key',
+                configured,
+                detail: configured
+                    ? 'GitHub token is available for Copilot token exchange.'
+                    : 'Set COPILOT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN to use GitHub Copilot.',
+                envVars: COPILOT_TOKEN_ENV_VARS,
+                routes: authRoutes,
+            },
+            models: {
+                defaultModel: this.models[0],
+                models: this.models,
+                aliases: ['copilot'],
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: true,
+                notes: ['Claude-family Copilot models use Anthropic transport. Other models use the OpenAI-compatible Copilot endpoint.'],
+            },
+            policy: {
+                local: false,
+                streamProtocol: 'mixed:anthropic+openai',
+                reasoningMode: 'provider-managed',
+            },
+        };
+    }
+}

package/dist/_internal/platform/providers/index.d.ts

@@ -0,0 +1,6 @@
+export type { ChatRequest, ChatResponse, ContentPart, LLMProvider, PartialToolCall, ProviderAuthRouteDescriptor, ProviderDeclaredAuthRoute, ProviderEmbeddingRequest, ProviderEmbeddingResult, ProviderMessage, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps, ProviderUsageCostMetadata, StreamDelta, } from './interface.js';
+export { createProviderApi } from './provider-api.js';
+export type { ProviderApi, ProviderApiBenchmarkStore, ProviderApiBenchmarkQuery, ProviderApiBenchmarkRecord, ProviderApiCatalogBenchmarkRecord, ProviderApiDependencies, ProviderApiFavoriteRecord, ProviderApiFavoritesStore, ProviderApiFavoriteState, ProviderApiFavoritesSnapshot, ProviderApiModelQuery, ProviderApiModelRecord, ProviderApiModelReference, ProviderApiModelRouting, ProviderApiRegistry, ProviderApiRuntimeQuery, ProviderApiRuntimeQueryResult, ProviderApiSyntheticBenchmarkRecord, ProviderApiSyntheticRouting, } from './provider-api.js';
+export type { ContextWindowProvenance, ModelDefinition, ModelTier, ProviderRegistryOptions, RuntimeProviderRegistration, TokenLimits, } from './registry-types.js';
+export type { ProviderRuntimeSnapshot, ProviderUsageSnapshot } from './runtime-snapshot.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,eAAe,EACf,2BAA2B,EAC3B,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,EACf,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,YAAY,EACV,WAAW,EACX,yBAAyB,EACzB,yBAAyB,EACzB,0BAA0B,EAC1B,iCAAiC,EACjC,uBAAuB,EACvB,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,4BAA4B,EAC5B,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,6BAA6B,EAC7B,mCAAmC,EACnC,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,uBAAuB,EACvB,eAAe,EACf,SAAS,EACT,uBAAuB,EACvB,2BAA2B,EAC3B,WAAW,GACZ,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/_internal/platform/providers/index.js

@@ -0,0 +1 @@
+export { createProviderApi } from './provider-api.js';