@ai-ide-bridge/copilot 1.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @ai-ide-bridge/copilot@1.0.3 build /home/runner/work/llm-bridge/llm-bridge/packages/copilot
+> tsc
+

package/README.md

@@ -0,0 +1,52 @@
+# @ai-ide-bridge/copilot
+
+The GitHub Copilot API plugin for **AI IDE Bridge**.
+
+AI IDE Bridge is a local HTTP server that translates OpenAI-compatible API requests into provider-specific calls, enabling any OpenAI-format client to use any AI IDE's model catalog.
+
+## Overview
+
+`@ai-ide-bridge/copilot` provides seamless integration with GitHub Copilot's cloud AI models. It acts as a plugin for `@ai-ide-bridge/core` to authenticate, list models, and stream chat completions.
+
+## Installation
+
+```bash
+npm install @ai-ide-bridge/copilot
+```
+
+## Configuration
+
+The plugin requires a valid `GITHUB_TOKEN` with Copilot access permissions.
+
+Set the credential via environment variable:
+
+```bash
+export GITHUB_TOKEN="ghp_your_github_token"
+```
+
+Or configure it in `~/.config/llm-bridge/config.json`:
+
+```json
+{
+  "plugins": {
+    "copilot": {
+      "GITHUB_TOKEN": "ghp_your_github_token"
+    }
+  }
+}
+```
+
+## Supported Models
+
+Models are accessible via the `copilot/` prefix:
+
+- `copilot/gpt-4o-copilot` — GPT-4o (GitHub Copilot)
+- `copilot/claude-3.5-sonnet-copilot` — Claude 3.5 Sonnet (GitHub Copilot)
+
+## Documentation
+
+For full documentation and setup instructions, please visit the main repository: [https://github.com/aeswibon/llm-bridge](https://github.com/aeswibon/llm-bridge).
+
+## License
+
+MIT

package/dist/auth.d.ts

@@ -0,0 +1,7 @@
+import type { CopilotConfig } from './types.js';
+export declare function validateToken(token: string): Promise<boolean>;
+export declare function getToken(config: CopilotConfig): string | null;
+export declare function refreshOAuthToken(_refreshToken: string, _clientId: string, _clientSecret: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;

package/dist/auth.js

@@ -0,0 +1,24 @@
+const COPILOT_API_BASE = 'https://api.github.com';
+export async function validateToken(token) {
+    try {
+        const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/v2/token`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+            },
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export function getToken(config) {
+    return config.COPILOT_TOKEN ?? config.COPILOT_OAUTH_TOKEN ?? null;
+}
+// OAuth placeholder — wired up when OAuth Phase 2 is implemented
+export async function refreshOAuthToken(_refreshToken, _clientId, _clientSecret) {
+    // TODO: Implement GitHub OAuth with PKCE flow
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { CopilotBridgePlugin } from './plugin.js';
+export { CopilotBridgeSession } from './session.js';
+export type { CopilotModel, CopilotConfig } from './types.js';
+export { COPILOT_MODELS } from './types.js';
+export { validateToken, getToken } from './auth.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { CopilotBridgePlugin } from './plugin.js';
+export { CopilotBridgeSession } from './session.js';
+export { COPILOT_MODELS } from './types.js';
+export { validateToken, getToken } from './auth.js';

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '@ai-ide-bridge/core';
+export declare class CopilotBridgePlugin implements BridgePlugin {
+    name: string;
+    version: string;
+    authenticate(config: Record<string, string>): Promise<boolean>;
+    listModels(config: Record<string, string>): Promise<ModelInfo[]>;
+    createSession(config: Record<string, string>, model: string): Promise<BridgeSession>;
+}

package/dist/plugin.js

@@ -0,0 +1,29 @@
+import { CopilotBridgeSession } from './session.js';
+import { COPILOT_MODELS } from './types.js';
+import { validateToken, getToken } from './auth.js';
+export class CopilotBridgePlugin {
+    name = 'copilot';
+    version = '2.0.0';
+    async authenticate(config) {
+        const token = getToken(config);
+        if (!token)
+            return false;
+        return validateToken(token);
+    }
+    async listModels(config) {
+        const token = getToken(config);
+        if (!token)
+            throw new Error('Missing COPILOT_TOKEN');
+        return COPILOT_MODELS.map((m) => ({
+            id: m.id,
+            name: m.name,
+            capabilities: m.capabilities,
+        }));
+    }
+    async createSession(config, model) {
+        const token = getToken(config);
+        if (!token)
+            throw new Error('Missing COPILOT_TOKEN');
+        return new CopilotBridgeSession(token, model);
+    }
+}

package/dist/session.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '@ai-ide-bridge/core';
+export declare class CopilotBridgeSession implements BridgeSession {
+    private token;
+    private modelId;
+    constructor(token: string, modelId: string);
+    send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
+    dispose(): Promise<void>;
+}

package/dist/session.js

@@ -0,0 +1,115 @@
+import { translateTools } from './tools.js';
+const COPILOT_API_BASE = 'https://api.github.com';
+export class CopilotBridgeSession {
+    token;
+    modelId;
+    constructor(token, modelId) {
+        this.token = token;
+        this.modelId = modelId;
+    }
+    async *send(messages, tools) {
+        const body = {
+            model: this.modelId,
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content ?? '',
+                ...(m.tool_calls && { tool_calls: m.tool_calls }),
+                ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+            })),
+            ...(tools && { tools: translateTools(tools) }),
+            stream: true,
+        };
+        try {
+            const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                yield {
+                    type: 'error',
+                    content: `Copilot API error: ${response.status} ${errorText}`,
+                    finishReason: 'error',
+                };
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                yield { type: 'error', content: 'No response body', finishReason: 'error' };
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let finished = false;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data:'))
+                        continue;
+                    const data = trimmed.slice(5).trim();
+                    if (data === '[DONE]') {
+                        if (!finished) {
+                            yield { type: 'done', finishReason: 'stop' };
+                        }
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const delta = parsed.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            yield { type: 'text', content: delta.content };
+                        }
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                yield {
+                                    type: 'tool_call',
+                                    toolCall: {
+                                        id: tc.id ?? '',
+                                        name: tc.function?.name ?? '',
+                                        arguments: tc.function?.arguments ?? '',
+                                    },
+                                };
+                            }
+                        }
+                        if (parsed.choices?.[0]?.finish_reason && !finished) {
+                            const reason = parsed.choices[0].finish_reason;
+                            const finishReason = reason === 'stop'
+                                ? 'stop'
+                                : reason === 'tool_calls'
+                                    ? 'tool_calls'
+                                    : reason === 'length'
+                                        ? 'length'
+                                        : 'error';
+                            yield {
+                                type: 'done',
+                                finishReason,
+                            };
+                            finished = true;
+                        }
+                    }
+                    catch {
+                        // Skip malformed SSE data
+                    }
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            yield { type: 'error', content: msg, finishReason: 'error' };
+        }
+    }
+    async dispose() {
+        // No persistent connections to dispose
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@ai-ide-bridge/core';
+export interface CopilotTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function translateTools(tools: ToolDefinition[]): CopilotTool[];

package/dist/tools.js

@@ -0,0 +1,10 @@
+export function translateTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+        },
+    }));
+}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export interface CopilotModel {
+    id: string;
+    name: string;
+    capabilities: {
+        streaming: boolean;
+        tools: boolean;
+        vision?: boolean;
+    };
+}
+export declare const COPILOT_MODELS: CopilotModel[];
+export interface CopilotConfig {
+    COPILOT_TOKEN?: string;
+    COPILOT_OAUTH_TOKEN?: string;
+    COPILOT_OAUTH_REFRESH_TOKEN?: string;
+}

package/dist/types.js

@@ -0,0 +1,27 @@
+export const COPILOT_MODELS = [
+    {
+        id: 'gpt-4-copilot',
+        name: 'GPT-4 (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gpt-4o-copilot',
+        name: 'GPT-4o (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'claude-3.5-sonnet-copilot',
+        name: 'Claude 3.5 Sonnet (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'o1-copilot',
+        name: 'o1 (Copilot)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'o1-mini-copilot',
+        name: 'o1-mini (Copilot)',
+        capabilities: { streaming: true, tools: false },
+    },
+];

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@ai-ide-bridge/copilot",
+  "version": "1.0.3",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@ai-ide-bridge/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,32 @@
+import type { CopilotConfig } from './types.js';
+
+const COPILOT_API_BASE = 'https://api.github.com';
+
+export async function validateToken(token: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/v2/token`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+      },
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export function getToken(config: CopilotConfig): string | null {
+  return config.COPILOT_TOKEN ?? config.COPILOT_OAUTH_TOKEN ?? null;
+}
+
+// OAuth placeholder — wired up when OAuth Phase 2 is implemented
+export async function refreshOAuthToken(
+  _refreshToken: string,
+  _clientId: string,
+  _clientSecret: string,
+): Promise<{ accessToken: string; refreshToken: string } | null> {
+  // TODO: Implement GitHub OAuth with PKCE flow
+  return null;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { CopilotBridgePlugin } from './plugin.js';
+export { CopilotBridgeSession } from './session.js';
+export type { CopilotModel, CopilotConfig } from './types.js';
+export { COPILOT_MODELS } from './types.js';
+export { validateToken, getToken } from './auth.js';

package/src/plugin.ts

@@ -0,0 +1,31 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '@ai-ide-bridge/core';
+import { CopilotBridgeSession } from './session.js';
+import { COPILOT_MODELS, type CopilotConfig } from './types.js';
+import { validateToken, getToken } from './auth.js';
+
+export class CopilotBridgePlugin implements BridgePlugin {
+  name = 'copilot';
+  version = '2.0.0';
+
+  async authenticate(config: Record<string, string>): Promise<boolean> {
+    const token = getToken(config as CopilotConfig);
+    if (!token) return false;
+    return validateToken(token);
+  }
+
+  async listModels(config: Record<string, string>): Promise<ModelInfo[]> {
+    const token = getToken(config as CopilotConfig);
+    if (!token) throw new Error('Missing COPILOT_TOKEN');
+    return COPILOT_MODELS.map((m) => ({
+      id: m.id,
+      name: m.name,
+      capabilities: m.capabilities,
+    }));
+  }
+
+  async createSession(config: Record<string, string>, model: string): Promise<BridgeSession> {
+    const token = getToken(config as CopilotConfig);
+    if (!token) throw new Error('Missing COPILOT_TOKEN');
+    return new CopilotBridgeSession(token, model);
+  }
+}

package/src/session.ts

@@ -0,0 +1,130 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '@ai-ide-bridge/core';
+import { translateTools } from './tools.js';
+
+const COPILOT_API_BASE = 'https://api.github.com';
+
+export class CopilotBridgeSession implements BridgeSession {
+  private token: string;
+  private modelId: string;
+
+  constructor(token: string, modelId: string) {
+    this.token = token;
+    this.modelId = modelId;
+  }
+
+  async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
+    const body = {
+      model: this.modelId,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content ?? '',
+        ...(m.tool_calls && { tool_calls: m.tool_calls }),
+        ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+      })),
+      ...(tools && { tools: translateTools(tools) }),
+      stream: true,
+    };
+
+    try {
+      const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/chat/completions`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          'Content-Type': 'application/json',
+          Accept: 'text/event-stream',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        yield {
+          type: 'error',
+          content: `Copilot API error: ${response.status} ${errorText}`,
+          finishReason: 'error',
+        };
+        return;
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        yield { type: 'error', content: 'No response body', finishReason: 'error' };
+        return;
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let finished = false;
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data:')) continue;
+
+          const data = trimmed.slice(5).trim();
+          if (data === '[DONE]') {
+            if (!finished) {
+              yield { type: 'done', finishReason: 'stop' };
+            }
+            return;
+          }
+
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta;
+
+            if (delta?.content) {
+              yield { type: 'text', content: delta.content };
+            }
+
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                yield {
+                  type: 'tool_call',
+                  toolCall: {
+                    id: tc.id ?? '',
+                    name: tc.function?.name ?? '',
+                    arguments: tc.function?.arguments ?? '',
+                  },
+                };
+              }
+            }
+
+            if (parsed.choices?.[0]?.finish_reason && !finished) {
+              const reason = parsed.choices[0].finish_reason;
+              const finishReason =
+                reason === 'stop'
+                  ? 'stop'
+                  : reason === 'tool_calls'
+                    ? 'tool_calls'
+                    : reason === 'length'
+                      ? 'length'
+                      : 'error';
+              yield {
+                type: 'done',
+                finishReason,
+              };
+              finished = true;
+            }
+          } catch {
+            // Skip malformed SSE data
+          }
+        }
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      yield { type: 'error', content: msg, finishReason: 'error' };
+    }
+  }
+
+  async dispose(): Promise<void> {
+    // No persistent connections to dispose
+  }
+}

package/src/tools.ts

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from '@ai-ide-bridge/core';
+
+export interface CopilotTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export function translateTools(tools: ToolDefinition[]): CopilotTool[] {
+  return tools.map((tool) => ({
+    type: 'function' as const,
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+    },
+  }));
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+export interface CopilotModel {
+  id: string;
+  name: string;
+  capabilities: {
+    streaming: boolean;
+    tools: boolean;
+    vision?: boolean;
+  };
+}
+
+export const COPILOT_MODELS: CopilotModel[] = [
+  {
+    id: 'gpt-4-copilot',
+    name: 'GPT-4 (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'gpt-4o-copilot',
+    name: 'GPT-4o (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'claude-3.5-sonnet-copilot',
+    name: 'Claude 3.5 Sonnet (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'o1-copilot',
+    name: 'o1 (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'o1-mini-copilot',
+    name: 'o1-mini (Copilot)',
+    capabilities: { streaming: true, tools: false },
+  },
+];
+
+export interface CopilotConfig {
+  COPILOT_TOKEN?: string;
+  COPILOT_OAUTH_TOKEN?: string;
+  COPILOT_OAUTH_REFRESH_TOKEN?: string;
+}

package/test/auth.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getToken, validateToken } from '../src/auth.js';
+
+describe('getToken', () => {
+  it('returns COPILOT_TOKEN when present', () => {
+    const result = getToken({ COPILOT_TOKEN: 'test-token' });
+    expect(result).toBe('test-token');
+  });
+
+  it('returns COPILOT_OAUTH_TOKEN when COPILOT_TOKEN is missing', () => {
+    const result = getToken({ COPILOT_OAUTH_TOKEN: 'oauth-token' });
+    expect(result).toBe('oauth-token');
+  });
+
+  it('returns null when no token is present', () => {
+    const result = getToken({});
+    expect(result).toBeNull();
+  });
+
+  it('prefers COPILOT_TOKEN over COPILOT_OAUTH_TOKEN', () => {
+    const result = getToken({
+      COPILOT_TOKEN: 'primary-token',
+      COPILOT_OAUTH_TOKEN: 'fallback-token',
+    });
+    expect(result).toBe('primary-token');
+  });
+});
+
+describe('validateToken', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns true when API responds with 200', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+    } as Response);
+    const result = await validateToken('valid-token');
+    expect(result).toBe(true);
+  });
+
+  it('returns false when API responds with error', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+    } as Response);
+    const result = await validateToken('invalid-token');
+    expect(result).toBe(false);
+  });
+
+  it('returns false on network error', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('Network error'));
+    const result = await validateToken('bad-token');
+    expect(result).toBe(false);
+  });
+});

package/test/plugin.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CopilotBridgePlugin } from '../src/plugin.js';
+import * as auth from '../src/auth.js';
+import { COPILOT_MODELS } from '../src/types.js';
+
+vi.mock('../src/auth.js', () => ({
+  validateToken: vi.fn(),
+  getToken: vi.fn(),
+  refreshOAuthToken: vi.fn(),
+}));
+
+describe('CopilotBridgePlugin', () => {
+  let plugin: CopilotBridgePlugin;
+
+  beforeEach(() => {
+    plugin = new CopilotBridgePlugin();
+    vi.clearAllMocks();
+  });
+
+  it('authenticates with valid token', async () => {
+    (auth.validateToken as any).mockResolvedValue(true);
+    (auth.getToken as any).mockReturnValue('ghp_test_token');
+    const result = await plugin.authenticate({ COPILOT_TOKEN: 'ghp_test_token' });
+    expect(result).toBe(true);
+    expect(auth.validateToken).toHaveBeenCalledWith('ghp_test_token');
+  });
+
+  it('fails authentication with missing token', async () => {
+    (auth.getToken as any).mockReturnValue(null);
+    const result = await plugin.authenticate({});
+    expect(result).toBe(false);
+  });
+
+  it('fails authentication with invalid token', async () => {
+    (auth.validateToken as any).mockResolvedValue(false);
+    (auth.getToken as any).mockReturnValue('invalid');
+    const result = await plugin.authenticate({ COPILOT_TOKEN: 'invalid' });
+    expect(result).toBe(false);
+  });
+
+  it('lists models', async () => {
+    (auth.getToken as any).mockReturnValue('ghp_test_token');
+    const models = await plugin.listModels({ COPILOT_TOKEN: 'ghp_test_token' });
+    expect(models.length).toBeGreaterThan(0);
+    expect(models[0].id).toBe(COPILOT_MODELS[0].id);
+  });
+
+  it('throws on listModels without token', async () => {
+    (auth.getToken as any).mockReturnValue(null);
+    await expect(plugin.listModels({})).rejects.toThrow('Missing COPILOT_TOKEN');
+  });
+
+  it('creates a session', async () => {
+    (auth.getToken as any).mockReturnValue('ghp_test_token');
+    const session = await plugin.createSession(
+      { COPILOT_TOKEN: 'ghp_test_token' },
+      'gpt-4o-copilot',
+    );
+    expect(session).toBeDefined();
+    expect(typeof session.send).toBe('function');
+    expect(typeof session.dispose).toBe('function');
+  });
+
+  it('throws on createSession without token', async () => {
+    (auth.getToken as any).mockReturnValue(null);
+    await expect(plugin.createSession({}, 'gpt-4o-copilot')).rejects.toThrow(
+      'Missing COPILOT_TOKEN',
+    );
+  });
+});

package/test/session.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CopilotBridgeSession } from '../src/session.js';
+import type { Message } from '@ai-ide-bridge/core';
+
+describe('CopilotBridgeSession', () => {
+  let session: CopilotBridgeSession;
+
+  beforeEach(() => {
+    session = new CopilotBridgeSession('test_token', 'gpt-4o-copilot');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('creates a session with token and model', () => {
+    expect(session).toBeDefined();
+  });
+
+  it('disposes without error', async () => {
+    await expect(session.dispose()).resolves.not.toThrow();
+  });
+
+  it('yields error chunk on HTTP error', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 401,
+      text: async () => 'Unauthorized',
+    } as Response);
+
+    const messages: Message[] = [{ role: 'user', content: 'hello' }];
+    const chunks: any[] = [];
+
+    for await (const chunk of session.send(messages)) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0].type).toBe('error');
+    expect(chunks[0].content).toContain('401');
+  });
+
+  it('yields text and done chunks on success', async () => {
+    const encoder = new TextEncoder();
+    const sseData = [
+      'data: {"choices":[{"delta":{"content":"Hello"},"finish_reason":null}]}',
+      'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}',
+      'data: [DONE]',
+    ].join('\n');
+
+    const mockReader = {
+      read: vi
+        .fn()
+        .mockResolvedValueOnce({ done: false, value: encoder.encode(sseData) })
+        .mockResolvedValueOnce({ done: true, value: undefined }),
+    };
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      body: { getReader: () => mockReader },
+    } as unknown as Response);
+
+    const messages: Message[] = [{ role: 'user', content: 'hello' }];
+    const chunks: any[] = [];
+
+    for await (const chunk of session.send(messages)) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]).toEqual({ type: 'text', content: 'Hello' });
+    expect(chunks[1]).toEqual({ type: 'done', finishReason: 'stop' });
+  });
+
+  it('yields error chunk on network failure', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('Network error'));
+
+    const messages: Message[] = [{ role: 'user', content: 'hello' }];
+    const chunks: any[] = [];
+
+    for await (const chunk of session.send(messages)) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0].type).toBe('error');
+    expect(chunks[0].content).toBe('Network error');
+  });
+});

package/test/tools.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { translateTools } from '../src/tools.js';
+import type { ToolDefinition } from '@ai-ide-bridge/core';
+
+describe('translateTools', () => {
+  it('translates OpenAI tool definitions to Copilot format', () => {
+    const tools: ToolDefinition[] = [
+      {
+        type: 'function',
+        function: {
+          name: 'search',
+          description: 'Search the web',
+          parameters: { type: 'object', properties: { q: { type: 'string' } } },
+        },
+      },
+    ];
+    const result = translateTools(tools);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe('function');
+    expect(result[0].function.name).toBe('search');
+    expect(result[0].function.description).toBe('Search the web');
+  });
+
+  it('handles multiple tools', () => {
+    const tools: ToolDefinition[] = [
+      { type: 'function', function: { name: 'a', description: 'A', parameters: {} } },
+      { type: 'function', function: { name: 'b', description: 'B', parameters: {} } },
+    ];
+    const result = translateTools(tools);
+    expect(result).toHaveLength(2);
+    expect(result[0].function.name).toBe('a');
+    expect(result[1].function.name).toBe('b');
+  });
+});

package/test/types.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { COPILOT_MODELS } from '../src/types.js';
+
+describe('COPILOT_MODELS', () => {
+  it('has 5 models', () => {
+    expect(COPILOT_MODELS).toHaveLength(5);
+  });
+
+  it('has correct model IDs', () => {
+    const ids = COPILOT_MODELS.map((m) => m.id);
+    expect(ids).toContain('gpt-4-copilot');
+    expect(ids).toContain('gpt-4o-copilot');
+    expect(ids).toContain('claude-3.5-sonnet-copilot');
+    expect(ids).toContain('o1-copilot');
+    expect(ids).toContain('o1-mini-copilot');
+  });
+
+  it('all models have streaming capability', () => {
+    for (const model of COPILOT_MODELS) {
+      expect(model.capabilities.streaming).toBe(true);
+    }
+  });
+
+  it('o1-mini-copilot has tools disabled', () => {
+    const o1Mini = COPILOT_MODELS.find((m) => m.id === 'o1-mini-copilot');
+    expect(o1Mini).toBeDefined();
+    expect(o1Mini?.capabilities.tools).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}