fix: tui can recevie message and auto load gateway

src/components/PromptInput/PromptInputFooter.tsx

@@ -10,6 +10,7 @@ import { useSettings } from '../../hooks/useSettings.js';
 import { useTerminalSize } from '../../hooks/useTerminalSize.js';
 import { Box, Text } from '../../ink.js';
 import type { MCPServerConnection } from '../../services/mcp/types.js';
+import { telegramService } from '../../services/telegram/TelegramService.js';
 import { useAppState } from '../../state/AppState.js';
 import type { ToolPermissionContext } from '../../Tool.js';
 import type { Message } from '../../types/message.js';
@@ -144,6 +145,7 @@ function PromptInputFooter({
         <Box flexShrink={1} gap={1}>
           {isFullscreen ? null : <Notifications apiKeyStatus={apiKeyStatus} autoUpdaterResult={autoUpdaterResult} debug={debug} isAutoUpdating={isAutoUpdating} verbose={verbose} messages={messages} onAutoUpdaterResult={onAutoUpdaterResult} onChangeIsUpdating={onChangeIsUpdating} ideSelection={ideSelection} mcpClients={mcpClients} isInputWrapped={isInputWrapped} isNarrow={isNarrow} />}
           {"external" === 'ant' && isUndercover() && <Text dimColor>undercover</Text>}
+          <TelegramStatusIndicator />
           <BridgeStatusIndicator bridgeSelected={bridgeSelected} />
         </Box>
       </Box>
@@ -151,6 +153,23 @@ function PromptInputFooter({
     </>;
 }
 export default memo(PromptInputFooter);
+
+function TelegramStatusIndicator(): React.ReactNode {
+  const state = React.useSyncExternalStore(
+    telegramService.subscribe,
+    telegramService.getStateSnapshot,
+    telegramService.getStateSnapshot,
+  );
+
+  if (state.status !== 'running' && state.status !== 'starting') {
+    return null;
+  }
+
+  return <Text color={state.status === 'running' ? 'notice' : 'warning'}>
+      ✈
+    </Text>;
+}
+
 type BridgeStatusProps = {
   bridgeSelected: boolean;
 };

src/hooks/useTelegramBridge.ts

@@ -1,49 +1,132 @@
 import { useEffect, useRef } from 'react'
+import type { AppStateStore } from '../state/AppState.js'
 import { telegramService } from '../services/telegram/TelegramService.js'
 import {
   TELEGRAM_CHANNEL_SERVER,
   type TelegramInboundEvent,
 } from '../services/telegram/telegramTypes.js'
+import {
+  handleTelegramCallback,
+  logTelegramInteractiveError,
+  maybeHandleTelegramInteractiveInput,
+} from '../services/telegram/interactiveCommands.js'
+import { hasTelegramRuntimeConfig } from '../services/telegram/telegramConfig.js'
 import type { Message } from '../types/message.js'
 import { enqueue } from '../utils/messageQueueManager.js'
 import { getContentText } from '../utils/messages.js'
-import { logForDebugging } from '../utils/debug.js'
+
+// 日志函数 - 只写入文件
+function logTelegramDebug(message: string, level: 'debug' | 'error' | 'info' = 'debug'): void {
+  try {
+    const fs = require('node:fs')
+    const path = require('node:path')
+    const LOG_FILE_PATH = path.join(process.cwd(), 'log.md')
+    const timestamp = new Date().toISOString()
+    const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`
+    fs.appendFileSync(LOG_FILE_PATH, logEntry, 'utf-8')
+  } catch (error) {
+    // 忽略文件写入错误
+  }
+}
 
 type Props = {
   messages: Message[]
   isLoading: boolean
+  store: AppStateStore
 }
 
 type ActiveTelegramTurn = {
   chatId: string
-  lastAssistantText?: string
+  responseParts: string[]
+}
+
+function stripXmlTags(text: string): string {
+  return text.replace(/<[^>]+>/g, '').trim()
 }
 
-export function useTelegramBridge({ messages, isLoading }: Props): void {
+export function useTelegramBridge({ messages, isLoading, store }: Props): void {
   const pendingInboundRef = useRef<TelegramInboundEvent[]>([])
   const activeTurnRef = useRef<ActiveTelegramTurn | null>(null)
   const lastProcessedMessageCountRef = useRef(messages.length)
   const previousLoadingRef = useRef(isLoading)
+  const autoStartAttemptedRef = useRef(false)
 
   useEffect(() => {
-    return telegramService.subscribeToInbound(event => {
-      pendingInboundRef.current.push(event)
-      enqueue({
-        value: event.text,
-        mode: 'prompt',
-        skipSlashCommands: true,
-        origin: {
-          kind: 'channel',
-          server: TELEGRAM_CHANNEL_SERVER,
-        } as const,
-      })
+    if (autoStartAttemptedRef.current) return
+    autoStartAttemptedRef.current = true
+    if (!hasTelegramRuntimeConfig()) return
+
+    void telegramService.startFromSavedConfig().catch(error => {
+      logTelegramDebug(`[telegram] auto-start failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
     })
   }, [])
 
+  useEffect(() => {
+    return telegramService.subscribeToInbound(event => {
+      void (async () => {
+        try {
+          logTelegramDebug(`[telegram] received inbound event: chatId=${event.chatId}, text=${event.text.slice(0, 50)}`)
+
+          if (await maybeHandleTelegramInteractiveInput(event, store)) {
+            return
+          }
+
+          pendingInboundRef.current.push(event)
+          logTelegramDebug(`[telegram] added to pendingInboundRef: chatId=${event.chatId}`)
+
+          enqueue({
+            value: event.text,
+            mode: 'prompt',
+            skipSlashCommands: true,
+            bridgeOrigin: true,
+            origin: {
+              kind: 'channel',
+              server: TELEGRAM_CHANNEL_SERVER,
+            } as const,
+          })
+        } catch (error) {
+          logTelegramInteractiveError(error)
+          await telegramService.sendMessage(
+            event.chatId,
+            `Telegram 交互处理失败: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          ).catch(() => {})
+        }
+      })()
+    })
+  }, [store])
+
+  useEffect(() => {
+    return telegramService.subscribeToCallbacks(event => {
+      void (async () => {
+        try {
+          await handleTelegramCallback(event, store)
+        } catch (error) {
+          logTelegramInteractiveError(error)
+          await telegramService.answerCallbackQuery(
+            event.callbackQueryId,
+            '处理按钮操作失败',
+          ).catch(() => {})
+          await telegramService.sendMessage(
+            event.chatId,
+            `Telegram 按钮操作失败: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          ).catch(() => {})
+        }
+      })()
+    })
+  }, [store])
+
   useEffect(() => {
     const newMessages = messages.slice(lastProcessedMessageCountRef.current)
 
+    logTelegramDebug(`[telegram] processing ${newMessages.length} new messages, activeTurn: ${activeTurnRef.current ? 'active' : 'null'}`)
+
     for (const message of newMessages) {
+      logTelegramDebug(`[telegram] processing message: type=${message.type}, hasOrigin=!!${message.origin}, origin=${JSON.stringify(message.origin)}`)
+
       if (
         message.type === 'user' &&
         message.origin?.kind === 'channel' &&
@@ -53,15 +136,32 @@ export function useTelegramBridge({ messages, isLoading }: Props): void {
         if (inbound) {
           activeTurnRef.current = {
             chatId: inbound.chatId,
+            responseParts: [],
           }
+          logTelegramDebug(`[telegram] active turn started for chatId: ${inbound.chatId}`)
         }
         continue
       }
 
       if (message.type === 'assistant' && activeTurnRef.current) {
         const text = getContentText(message.message.content)
+        logTelegramDebug(`[telegram] assistant message, text length: ${text?.length || 0}, content type: ${typeof message.message.content}`)
+        if (text) {
+          activeTurnRef.current.responseParts.push(text)
+          logTelegramDebug(`[telegram] added to responseParts, total parts: ${activeTurnRef.current.responseParts.length}`)
+        }
+        continue
+      }
+
+      if (
+        message.type === 'system' &&
+        message.subtype === 'local_command' &&
+        activeTurnRef.current
+      ) {
+        const text = stripXmlTags(message.content)
+        logTelegramDebug(`[telegram] local_command, text length: ${text?.length || 0}`)
         if (text) {
-          activeTurnRef.current.lastAssistantText = text
+          activeTurnRef.current.responseParts.push(text)
         }
       }
     }
@@ -73,24 +173,33 @@ export function useTelegramBridge({ messages, isLoading }: Props): void {
     const wasLoading = previousLoadingRef.current
     previousLoadingRef.current = isLoading
 
+    logTelegramDebug(`[telegram] loading state changed: wasLoading=${wasLoading}, isLoading=${isLoading}, hasActiveTurn=!!${activeTurnRef.current}`)
+
     if (!wasLoading || isLoading || !activeTurnRef.current) {
       return
     }
 
-    const { chatId, lastAssistantText } = activeTurnRef.current
+    const { chatId, responseParts } = activeTurnRef.current
+    const messageToSend = responseParts.join('\n\n').trim() ||
+          '这一轮没有可回传的文本结果，请查看本地终端会话。'
+
+    logTelegramDebug(`[telegram] sending message to chatId: ${chatId}, parts count: ${responseParts.length}, total length: ${messageToSend.length}`)
+    logTelegramDebug(`[telegram] message content: ${JSON.stringify(messageToSend)}`)
+    logTelegramDebug(`[telegram] response parts: ${JSON.stringify(responseParts)}`)
+
     activeTurnRef.current = null
 
     void telegramService
       .sendMessage(
         chatId,
-        lastAssistantText ?? '这一轮没有可回传的文本结果，请查看本地终端会话。',
+        messageToSend,
       )
       .catch(error => {
-        logForDebugging(
+        logTelegramDebug(
           `[telegram] failed to send outbound reply: ${
             error instanceof Error ? error.message : String(error)
           }`,
-          { level: 'error' },
+          'error',
         )
       })
   }, [isLoading])

src/screens/REPL.tsx

@@ -4049,7 +4049,8 @@ export function REPL({
 
   useTelegramBridge({
     messages,
-    isLoading
+    isLoading,
+    store
   });
 
   // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)

src/services/api/copilotClient.ts

@@ -0,0 +1,1150 @@
+import { getGlobalConfig, saveGlobalConfig, type ConnectedProviderInfo } from '../../utils/config.js'
+
+const COPILOT_API_BASE = 'https://api.githubcopilot.com'
+const MODELS_DEV_URL = 'https://models.dev/api.json'
+
+export type CopilotModelInfo = {
+  id: string
+  label: string
+  description: string
+  supportedEndpoints?: string[]
+}
+
+type CopilotOutputTokenParam = 'max_tokens' | 'max_completion_tokens'
+type CopilotCompatibilityInfo = {
+  outputTokenParam?: CopilotOutputTokenParam
+  modelSupported?: boolean
+  chatCompletionsSupported?: boolean
+  updatedAt: number
+}
+
+const COPILOT_COMPATIBILITY_CACHE_TTL_MS = 24 * 60 * 60 * 1000
+const COPILOT_CHAT_COMPLETIONS_ENDPOINT = '/chat/completions'
+
+export function isCopilotModel(model: string): boolean {
+  return model.startsWith('copilot:')
+}
+
+export function getCopilotModelId(model: string): string {
+  return model.replace(/^copilot:/, '')
+}
+
+export function getCopilotProvider(): ConnectedProviderInfo | undefined {
+  const config = getGlobalConfig()
+  return config.connectedProviders?.['github-copilot']
+}
+
+export function isCopilotConnected(): boolean {
+  return !!getCopilotProvider()?.oauthToken
+}
+
+const FALLBACK_COPILOT_MODELS: CopilotModelInfo[] = [
+  { id: 'copilot:claude-sonnet-4.6', label: 'Claude Sonnet 4.6', description: 'Claude Sonnet 4.6 via Copilot' },
+  { id: 'copilot:claude-sonnet-4.5', label: 'Claude Sonnet 4.5', description: 'Claude Sonnet 4.5 via Copilot' },
+  { id: 'copilot:claude-sonnet-4', label: 'Claude Sonnet 4', description: 'Claude Sonnet 4 via Copilot' },
+  { id: 'copilot:claude-opus-4.6', label: 'Claude Opus 4.6', description: 'Claude Opus 4.6 via Copilot' },
+  { id: 'copilot:claude-opus-4.5', label: 'Claude Opus 4.5', description: 'Claude Opus 4.5 via Copilot' },
+  { id: 'copilot:claude-opus-41', label: 'Claude Opus 4.1', description: 'Claude Opus 4.1 via Copilot' },
+  { id: 'copilot:claude-haiku-4.5', label: 'Claude Haiku 4.5', description: 'Claude Haiku 4.5 via Copilot' },
+  { id: 'copilot:gpt-5.4', label: 'GPT-5.4', description: 'OpenAI GPT-5.4 via Copilot' },
+  { id: 'copilot:gpt-5.4-mini', label: 'GPT-5.4 mini', description: 'OpenAI GPT-5.4 mini via Copilot' },
+  { id: 'copilot:gpt-5.3-codex', label: 'GPT-5.3-Codex', description: 'OpenAI GPT-5.3-Codex via Copilot' },
+  { id: 'copilot:gpt-5.2-codex', label: 'GPT-5.2-Codex', description: 'OpenAI GPT-5.2-Codex via Copilot' },
+  { id: 'copilot:gpt-5.2', label: 'GPT-5.2', description: 'OpenAI GPT-5.2 via Copilot' },
+  { id: 'copilot:gpt-5.1', label: 'GPT-5.1', description: 'OpenAI GPT-5.1 via Copilot' },
+  { id: 'copilot:gpt-5.1-codex', label: 'GPT-5.1-Codex', description: 'OpenAI GPT-5.1-Codex via Copilot' },
+  { id: 'copilot:gpt-5.1-codex-mini', label: 'GPT-5.1-Codex-mini', description: 'OpenAI GPT-5.1-Codex-mini via Copilot' },
+  { id: 'copilot:gpt-5.1-codex-max', label: 'GPT-5.1-Codex-max', description: 'OpenAI GPT-5.1-Codex-max via Copilot' },
+  { id: 'copilot:gpt-5', label: 'GPT-5', description: 'OpenAI GPT-5 via Copilot' },
+  { id: 'copilot:gpt-5-mini', label: 'GPT-5-mini', description: 'OpenAI GPT-5-mini via Copilot' },
+  { id: 'copilot:gpt-4.1', label: 'GPT-4.1', description: 'OpenAI GPT-4.1 via Copilot' },
+  { id: 'copilot:gpt-4o', label: 'GPT-4o', description: 'OpenAI GPT-4o via Copilot' },
+  { id: 'copilot:gemini-3.1-pro-preview', label: 'Gemini 3.1 Pro Preview', description: 'Google Gemini 3.1 Pro via Copilot' },
+  { id: 'copilot:gemini-3-pro-preview', label: 'Gemini 3 Pro Preview', description: 'Google Gemini 3 Pro via Copilot' },
+  { id: 'copilot:gemini-3-flash-preview', label: 'Gemini 3 Flash', description: 'Google Gemini 3 Flash via Copilot' },
+  { id: 'copilot:gemini-2.5-pro', label: 'Gemini 2.5 Pro', description: 'Google Gemini 2.5 Pro via Copilot' },
+  { id: 'copilot:grok-code-fast-1', label: 'Grok Code Fast 1', description: 'xAI Grok Code Fast 1 via Copilot' },
+]
+
+let cachedModels: CopilotModelInfo[] | null = null
+let copilotModelsRefreshPromise: Promise<void> | null = null
+
+type CopilotApiModel = {
+  id: string
+  name?: string
+  model_picker_enabled?: boolean
+  policy?: { state?: string }
+  supported_endpoints?: string[]
+}
+
+function supportsCopilotChatCompletions(model: CopilotModelInfo): boolean {
+  return (
+    !model.supportedEndpoints ||
+    model.supportedEndpoints.includes(COPILOT_CHAT_COMPLETIONS_ENDPOINT)
+  )
+}
+
+export async function fetchCopilotModelsFromApi(): Promise<CopilotModelInfo[] | null> {
+  const provider = getCopilotProvider()
+  if (!provider?.oauthToken) return null
+
+  const response = await fetch(`${COPILOT_API_BASE}/models`, {
+    headers: {
+      Authorization: `Bearer ${provider.oauthToken}`,
+      'User-Agent': 'claude-code/2.1.88',
+      'Openai-Intent': 'conversation-edits',
+      'x-initiator': 'user',
+    },
+    signal: AbortSignal.timeout(10_000),
+  })
+  if (!response.ok) {
+    throw new Error(`Copilot models API failed (${response.status})`)
+  }
+
+  const data = await response.json() as {
+    data?: CopilotApiModel[]
+  }
+  if (!Array.isArray(data.data) || data.data.length === 0) {
+    return null
+  }
+
+  const models = data.data
+    .filter(model => model.model_picker_enabled !== false)
+    .filter(model => model.policy?.state !== 'disabled')
+    .map(
+      (model): CopilotModelInfo => ({
+        id: `copilot:${model.id}`,
+        label: model.name || model.id,
+        description: `${model.name || model.id} via Copilot`,
+        supportedEndpoints: model.supported_endpoints,
+      }),
+    )
+
+  return models.length > 0 ? models : null
+}
+
+export async function fetchCopilotModelsFromModelsDev(): Promise<CopilotModelInfo[]> {
+  try {
+    const response = await fetch(MODELS_DEV_URL, {
+      signal: AbortSignal.timeout(10_000),
+    })
+    if (!response.ok) return FALLBACK_COPILOT_MODELS
+
+    const data = await response.json() as Record<string, { models?: Record<string, { name?: string }> }>
+    const copilotProvider = data['github-copilot']
+    if (!copilotProvider?.models) return FALLBACK_COPILOT_MODELS
+
+    const models: CopilotModelInfo[] = Object.entries(copilotProvider.models).map(
+      ([modelId, info]) => ({
+        id: `copilot:${modelId}`,
+        label: info.name || modelId,
+        description: `${info.name || modelId} via Copilot`,
+      }),
+    )
+
+    return models.length > 0 ? models : FALLBACK_COPILOT_MODELS
+  } catch {
+    return FALLBACK_COPILOT_MODELS
+  }
+}
+
+export async function fetchCopilotModels(): Promise<CopilotModelInfo[]> {
+  try {
+    const apiModels = await fetchCopilotModelsFromApi()
+    if (apiModels && apiModels.length > 0) {
+      return apiModels
+    }
+  } catch {}
+
+  return fetchCopilotModelsFromModelsDev()
+}
+
+function hasCopilotEndpointMetadata(models: CopilotModelInfo[]): boolean {
+  return models.some(model => Array.isArray(model.supportedEndpoints))
+}
+
+function shouldUseCachedCopilotModels(cache: {
+  models: CopilotModelInfo[]
+  fetchedAt: number
+} | null | undefined): boolean {
+  if (!cache || cache.models.length === 0) return false
+  if (!hasCopilotEndpointMetadata(cache.models)) return false
+  return Date.now() - cache.fetchedAt < 3600_000
+}
+
+function refreshCopilotModelsCacheInBackground(): void {
+  if (copilotModelsRefreshPromise || !isCopilotConnected()) {
+    return
+  }
+  copilotModelsRefreshPromise = (async () => {
+    const models = await fetchCopilotModels()
+    cachedModels = models
+    saveGlobalConfig(current => ({
+      ...current,
+      copilotModelsCache: { models, fetchedAt: Date.now() },
+    }))
+  })()
+    .catch(() => {})
+    .finally(() => {
+      copilotModelsRefreshPromise = null
+    })
+}
+
+export async function getCopilotModels(): Promise<CopilotModelInfo[]> {
+  if (cachedModels) return filterUnavailableCopilotModels(cachedModels)
+
+  const config = getGlobalConfig()
+  const cached = config.copilotModelsCache
+  if (shouldUseCachedCopilotModels(cached)) {
+    cachedModels = cached.models
+    return filterUnavailableCopilotModels(cachedModels)
+  }
+
+  const models = await fetchCopilotModels()
+  cachedModels = models
+
+  saveGlobalConfig(current => ({
+    ...current,
+    copilotModelsCache: { models, fetchedAt: Date.now() },
+  }))
+
+  return filterUnavailableCopilotModels(models)
+}
+
+export function getCopilotModelsCached(): CopilotModelInfo[] {
+  if (cachedModels) {
+    if (!hasCopilotEndpointMetadata(cachedModels)) {
+      refreshCopilotModelsCacheInBackground()
+    }
+    return filterUnavailableCopilotModels(cachedModels)
+  }
+
+  const config = getGlobalConfig()
+  const cached = config.copilotModelsCache
+  if (cached && cached.models.length > 0) {
+    cachedModels = cached.models
+    if (!shouldUseCachedCopilotModels(cached)) {
+      refreshCopilotModelsCacheInBackground()
+    }
+    return filterUnavailableCopilotModels(cachedModels)
+  }
+
+  refreshCopilotModelsCacheInBackground()
+  return filterUnavailableCopilotModels(FALLBACK_COPILOT_MODELS)
+}
+
+export { FALLBACK_COPILOT_MODELS as COPILOT_MODELS }
+
+function getCachedCopilotCompatibility(
+  modelId: string,
+): CopilotCompatibilityInfo | undefined {
+  const compatibility = getGlobalConfig().copilotCompatibilityCache?.[modelId]
+  if (!compatibility) return undefined
+  if (Date.now() - compatibility.updatedAt > COPILOT_COMPATIBILITY_CACHE_TTL_MS) {
+    return undefined
+  }
+  return compatibility
+}
+
+function filterUnavailableCopilotModels(
+  models: CopilotModelInfo[],
+): CopilotModelInfo[] {
+  return models.filter(model => {
+    if (!supportsCopilotChatCompletions(model)) {
+      return false
+    }
+    const compatibility = getCachedCopilotCompatibility(
+      getCopilotModelId(model.id),
+    )
+    return (
+      compatibility?.modelSupported !== false &&
+      compatibility?.chatCompletionsSupported !== false
+    )
+  })
+}
+
+function saveCopilotCompatibility(
+  modelId: string,
+  updates: Partial<CopilotCompatibilityInfo>,
+): void {
+  saveGlobalConfig(current => {
+    const existing = current.copilotCompatibilityCache?.[modelId]
+    const next = {
+      ...existing,
+      ...updates,
+      updatedAt: Date.now(),
+    } satisfies CopilotCompatibilityInfo
+
+    if (
+      existing?.outputTokenParam === next.outputTokenParam &&
+      existing?.modelSupported === next.modelSupported &&
+      existing?.chatCompletionsSupported === next.chatCompletionsSupported
+    ) {
+      return current
+    }
+
+    return {
+      ...current,
+      copilotCompatibilityCache: {
+        ...current.copilotCompatibilityCache,
+        [modelId]: next,
+      },
+    }
+  })
+}
+
+function getPreferredCopilotOutputTokenParam(
+  modelId: string,
+): CopilotOutputTokenParam {
+  return (
+    getCachedCopilotCompatibility(modelId)?.outputTokenParam ??
+    'max_tokens'
+  )
+}
+
+function savePreferredCopilotOutputTokenParam(
+  modelId: string,
+  outputTokenParam: CopilotOutputTokenParam,
+): void {
+  saveCopilotCompatibility(modelId, { outputTokenParam })
+}
+
+function buildCopilotChatRequestBody(params: {
+  modelId: string
+  messages: OpenAIMessage[]
+  isStreaming: boolean
+  maxTokens?: number
+  tools?: OpenAITool[]
+  outputTokenParam: CopilotOutputTokenParam
+}): Record<string, unknown> {
+  const requestBody: Record<string, unknown> = {
+    model: params.modelId,
+    messages: params.messages,
+    stream: params.isStreaming,
+  }
+
+  if (params.maxTokens) {
+    requestBody[params.outputTokenParam] = params.maxTokens
+  }
+
+  if (params.tools && params.tools.length > 0) {
+    requestBody.tools = params.tools
+    requestBody.tool_choice = 'auto'
+  }
+
+  return requestBody
+}
+
+async function createCopilotErrorInfo(response: Response): Promise<{
+  message?: string
+  code?: string
+}> {
+  const text = await response
+    .clone()
+    .text()
+    .catch(() => '')
+  if (!text) return {}
+  try {
+    const parsed = JSON.parse(text) as {
+      error?: { message?: string; code?: string }
+    }
+    return {
+      message: parsed.error?.message,
+      code: parsed.error?.code,
+    }
+  } catch {
+    return {}
+  }
+}
+
+function createCachedCopilotErrorResponse(
+  message: string,
+  code: string,
+): Response {
+  return new Response(JSON.stringify({ error: { message, code } }), {
+    status: 400,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}
+
+function getSuggestedCopilotOutputTokenParam(
+  currentParam: CopilotOutputTokenParam,
+  errorMessage: string | undefined,
+): CopilotOutputTokenParam | undefined {
+  if (!errorMessage) return undefined
+  if (
+    currentParam === 'max_tokens' &&
+    errorMessage.includes("Use 'max_completion_tokens' instead")
+  ) {
+    return 'max_completion_tokens'
+  }
+  if (
+    currentParam === 'max_completion_tokens' &&
+    errorMessage.includes("Use 'max_tokens' instead")
+  ) {
+    return 'max_tokens'
+  }
+  return undefined
+}
+
+async function postCopilotChatCompletion(params: {
+  oauthToken: string
+  requestBody: Record<string, unknown>
+  signal?: AbortSignal
+}): Promise<Response> {
+  return fetch(`${COPILOT_API_BASE}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${params.oauthToken}`,
+      'User-Agent': 'claude-code/2.1.88',
+      'Openai-Intent': 'conversation-edits',
+      'x-initiator': 'user',
+    },
+    body: JSON.stringify(params.requestBody),
+    signal: params.signal,
+  })
+}
+
+function saveCopilotCompatibilityFromError(
+  modelId: string,
+  errorInfo: { code?: string },
+): void {
+  if (errorInfo.code === 'model_not_supported') {
+    saveCopilotCompatibility(modelId, {
+      modelSupported: false,
+      chatCompletionsSupported: false,
+    })
+  } else if (errorInfo.code === 'unsupported_api_for_model') {
+    saveCopilotCompatibility(modelId, {
+      chatCompletionsSupported: false,
+    })
+  }
+}
+
+async function sendCopilotChatCompletion(params: {
+  oauthToken: string
+  modelId: string
+  messages: OpenAIMessage[]
+  isStreaming: boolean
+  maxTokens?: number
+  tools?: OpenAITool[]
+  signal?: AbortSignal
+}): Promise<Response> {
+  const compatibility = getCachedCopilotCompatibility(params.modelId)
+  if (compatibility?.modelSupported === false) {
+    return createCachedCopilotErrorResponse(
+      `Copilot model "${params.modelId}" was previously rejected as unsupported.`,
+      'model_not_supported',
+    )
+  }
+  if (compatibility?.chatCompletionsSupported === false) {
+    return createCachedCopilotErrorResponse(
+      `Copilot model "${params.modelId}" does not support the /chat/completions endpoint.`,
+      'unsupported_api_for_model',
+    )
+  }
+
+  let outputTokenParam = getPreferredCopilotOutputTokenParam(params.modelId)
+  let requestBody = buildCopilotChatRequestBody({
+    modelId: params.modelId,
+    messages: params.messages,
+    isStreaming: params.isStreaming,
+    maxTokens: params.maxTokens,
+    tools: params.tools,
+    outputTokenParam,
+  })
+
+  let response = await postCopilotChatCompletion({
+    oauthToken: params.oauthToken,
+    requestBody,
+    signal: params.signal,
+  })
+  if (response.ok) {
+    saveCopilotCompatibility(params.modelId, {
+      modelSupported: true,
+      chatCompletionsSupported: true,
+      outputTokenParam,
+    })
+    return response
+  }
+
+  const errorInfo = await createCopilotErrorInfo(response)
+  if (!params.maxTokens) {
+    saveCopilotCompatibilityFromError(params.modelId, errorInfo)
+    return response
+  }
+  const suggestedParam = getSuggestedCopilotOutputTokenParam(
+    outputTokenParam,
+    errorInfo.message,
+  )
+  if (!suggestedParam) {
+    saveCopilotCompatibilityFromError(params.modelId, errorInfo)
+    return response
+  }
+
+  savePreferredCopilotOutputTokenParam(params.modelId, suggestedParam)
+  outputTokenParam = suggestedParam
+  requestBody = buildCopilotChatRequestBody({
+    modelId: params.modelId,
+    messages: params.messages,
+    isStreaming: params.isStreaming,
+    maxTokens: params.maxTokens,
+    tools: params.tools,
+    outputTokenParam,
+  })
+
+  response = await postCopilotChatCompletion({
+    oauthToken: params.oauthToken,
+    requestBody,
+    signal: params.signal,
+  })
+  if (response.ok) {
+    saveCopilotCompatibility(params.modelId, {
+      modelSupported: true,
+      chatCompletionsSupported: true,
+      outputTokenParam,
+    })
+    return response
+  }
+
+  saveCopilotCompatibilityFromError(
+    params.modelId,
+    await createCopilotErrorInfo(response),
+  )
+  return response
+}
+
+type OpenAIMessage = {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string | Array<{ type: string; text?: string; image_url?: { url: string } }>
+  tool_calls?: Array<{
+    id: string
+    type: 'function'
+    function: { name: string; arguments: string }
+  }>
+  tool_call_id?: string
+}
+
+type OpenAITool = {
+  type: 'function'
+  function: {
+    name: string
+    description: string
+    parameters: Record<string, unknown>
+  }
+}
+
+export type AnthropicContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+  | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
+  | { type: 'tool_result'; tool_use_id: string; content: string | Array<{ type: string; text?: string }> }
+  | { type: 'thinking'; thinking: string }
+  | Record<string, unknown>
+
+export type AnthropicMessage = {
+  role: 'user' | 'assistant'
+  content: string | AnthropicContentBlock[]
+}
+
+export function convertAnthropicMessagesToOpenAI(
+  messages: AnthropicMessage[],
+  systemPrompt?: string,
+): OpenAIMessage[] {
+  const result: OpenAIMessage[] = []
+
+  if (systemPrompt) {
+    result.push({ role: 'system', content: systemPrompt })
+  }
+
+  for (const msg of messages) {
+    if (typeof msg.content === 'string') {
+      result.push({ role: msg.role, content: msg.content })
+      continue
+    }
+
+    if (msg.role === 'user') {
+      const parts: Array<{ type: string; text?: string; image_url?: { url: string } }> = []
+      const toolResults: OpenAIMessage[] = []
+
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          parts.push({ type: 'text', text: (block as { type: 'text'; text: string }).text })
+        } else if (block.type === 'image') {
+          const imgBlock = block as { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+          parts.push({
+            type: 'image_url',
+            image_url: { url: `data:${imgBlock.source.media_type};base64,${imgBlock.source.data}` },
+          })
+        } else if (block.type === 'tool_result') {
+          const trBlock = block as { type: 'tool_result'; tool_use_id: string; content: string | Array<{ type: string; text?: string }> }
+          let content = ''
+          if (typeof trBlock.content === 'string') {
+            content = trBlock.content
+          } else if (Array.isArray(trBlock.content)) {
+            content = trBlock.content
+              .filter(c => c.type === 'text')
+              .map(c => c.text || '')
+              .join('\n')
+          }
+          toolResults.push({
+            role: 'tool',
+            content,
+            tool_call_id: trBlock.tool_use_id,
+          })
+        }
+      }
+
+      if (toolResults.length > 0) {
+        result.push(...toolResults)
+        if (parts.length > 0) {
+          result.push({ role: 'user', content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text! : parts })
+        }
+      } else if (parts.length > 0) {
+        result.push({ role: 'user', content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text! : parts })
+      }
+    } else if (msg.role === 'assistant') {
+      const textParts: string[] = []
+      const toolCalls: Array<{ id: string; type: 'function'; function: { name: string; arguments: string } }> = []
+
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          textParts.push((block as { type: 'text'; text: string }).text)
+        } else if (block.type === 'tool_use') {
+          const tuBlock = block as { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
+          toolCalls.push({
+            id: tuBlock.id,
+            type: 'function',
+            function: {
+              name: tuBlock.name,
+              arguments: JSON.stringify(tuBlock.input),
+            },
+          })
+        }
+      }
+
+      const assistantMsg: OpenAIMessage = {
+        role: 'assistant',
+        content: textParts.join('\n') || '',
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls
+      }
+      result.push(assistantMsg)
+    }
+  }
+
+  return result
+}
+
+export function convertAnthropicToolsToOpenAI(
+  tools: Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>,
+): OpenAITool[] {
+  return tools.map(tool => ({
+    type: 'function' as const,
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.input_schema || { type: 'object', properties: {} },
+    },
+  }))
+}
+
+export type CopilotStreamEvent =
+  | { type: 'message_start'; message: { id: string; type: 'message'; role: 'assistant'; model: string; content: []; usage: { input_tokens: number; output_tokens: number } } }
+  | { type: 'content_block_start'; index: number; content_block: { type: 'text'; text: string } }
+  | { type: 'content_block_delta'; index: number; delta: { type: 'text_delta'; text: string } }
+  | { type: 'content_block_stop'; index: number }
+  | { type: 'message_delta'; delta: { stop_reason: string }; usage: { output_tokens: number } }
+  | { type: 'message_stop' }
+
+export async function* streamCopilotRequest(
+  model: string,
+  messages: AnthropicMessage[],
+  systemPrompt: string | undefined,
+  tools: Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>,
+  signal: AbortSignal,
+): AsyncGenerator<CopilotStreamEvent> {
+  const provider = getCopilotProvider()
+  if (!provider?.oauthToken) {
+    throw new Error('GitHub Copilot is not connected. Use /connect to authenticate.')
+  }
+
+  const copilotModelId = getCopilotModelId(model)
+  const openaiMessages = convertAnthropicMessagesToOpenAI(messages, systemPrompt)
+  const openaiTools = tools.length > 0 ? convertAnthropicToolsToOpenAI(tools) : undefined
+  const response = await sendCopilotChatCompletion({
+    oauthToken: provider.oauthToken,
+    modelId: copilotModelId,
+    messages: openaiMessages,
+    isStreaming: true,
+    maxTokens: 16384,
+    tools: openaiTools,
+    signal,
+  })
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => 'unknown error')
+    throw new Error(`Copilot API error (${response.status}): ${errorText}`)
+  }
+
+  if (!response.body) {
+    throw new Error('No response body from Copilot API')
+  }
+
+  const messageId = `msg_copilot_${Date.now()}`
+  let contentIndex = 0
+  let hasStartedContent = false
+  let currentToolCallIndex = -1
+  const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map()
+  let totalOutputTokens = 0
+
+  yield {
+    type: 'message_start',
+    message: {
+      id: messageId,
+      type: 'message',
+      role: 'assistant',
+      model: copilotModelId,
+      content: [],
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  }
+
+  const reader = response.body.getReader()
+  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 === '[DONE]') {
+          if (hasStartedContent) {
+            yield { type: 'content_block_stop', index: contentIndex - 1 }
+          }
+          for (const [idx, tc] of toolCalls) {
+            yield {
+              type: 'content_block_stop',
+              index: contentIndex + idx,
+            }
+          }
+          yield {
+            type: 'message_delta',
+            delta: { stop_reason: toolCalls.size > 0 ? 'tool_use' : 'end_turn' },
+            usage: { output_tokens: totalOutputTokens },
+          }
+          yield { type: 'message_stop' }
+          return
+        }
+
+        let chunk: {
+          choices?: Array<{
+            delta?: {
+              content?: string | null
+              tool_calls?: Array<{
+                index: number
+                id?: string
+                function?: { name?: string; arguments?: string }
+              }>
+              role?: string
+            }
+            finish_reason?: string | null
+          }>
+          usage?: { completion_tokens?: number; prompt_tokens?: number; total_tokens?: number }
+        }
+
+        try {
+          chunk = JSON.parse(data)
+        } catch {
+          continue
+        }
+
+        if (chunk.usage?.completion_tokens) {
+          totalOutputTokens = chunk.usage.completion_tokens
+        }
+
+        const choice = chunk.choices?.[0]
+        if (!choice?.delta) continue
+
+        const delta = choice.delta
+
+        if (delta.content != null && delta.content !== '') {
+          if (!hasStartedContent) {
+            hasStartedContent = true
+            yield {
+              type: 'content_block_start',
+              index: contentIndex,
+              content_block: { type: 'text', text: '' },
+            }
+          }
+          yield {
+            type: 'content_block_delta',
+            index: contentIndex,
+            delta: { type: 'text_delta', text: delta.content },
+          }
+        }
+
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (tc.id) {
+              if (hasStartedContent && currentToolCallIndex === -1) {
+                yield { type: 'content_block_stop', index: contentIndex }
+                contentIndex++
+                hasStartedContent = false
+              }
+              currentToolCallIndex = tc.index
+              toolCalls.set(tc.index, {
+                id: tc.id,
+                name: tc.function?.name || '',
+                arguments: tc.function?.arguments || '',
+              })
+              const toolBlockIndex = hasStartedContent ? contentIndex + 1 + tc.index : contentIndex + tc.index
+              yield {
+                type: 'content_block_start' as const,
+                index: toolBlockIndex,
+                content_block: {
+                  type: 'text',
+                  text: '',
+                } as any,
+              }
+            } else if (tc.function?.arguments) {
+              const existing = toolCalls.get(tc.index)
+              if (existing) {
+                existing.arguments += tc.function.arguments
+              }
+            }
+          }
+        }
+
+        if (choice.finish_reason) {
+          if (hasStartedContent) {
+            yield { type: 'content_block_stop', index: contentIndex }
+          }
+          yield {
+            type: 'message_delta',
+            delta: { stop_reason: choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn' },
+            usage: { output_tokens: totalOutputTokens },
+          }
+          yield { type: 'message_stop' }
+          return
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+
+  yield {
+    type: 'message_delta',
+    delta: { stop_reason: 'end_turn' },
+    usage: { output_tokens: totalOutputTokens },
+  }
+  yield { type: 'message_stop' }
+}
+
+export function createCopilotFetchOverride(
+  model: string,
+): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
+  const provider = getCopilotProvider()
+  if (!provider?.oauthToken) {
+    throw new Error('GitHub Copilot is not connected')
+  }
+
+  const copilotModelId = getCopilotModelId(model)
+
+  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const url = input instanceof URL ? input.href : typeof input === 'string' ? input : input.url
+
+    if (!url.includes('/messages') && !url.includes('/v1/')) {
+      return fetch(input, init)
+    }
+
+    if (url.includes('/count_tokens') || url.includes('/models')) {
+      return new Response(JSON.stringify({ input_tokens: 0 }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    let anthropicBody: Record<string, unknown> = {}
+    if (init?.body) {
+      try {
+        anthropicBody = JSON.parse(typeof init.body === 'string' ? init.body : new TextDecoder().decode(init.body as ArrayBuffer))
+      } catch {
+        return fetch(input, init)
+      }
+    }
+
+    const systemBlocks = anthropicBody.system as Array<{ type: string; text: string }> | string | undefined
+    let systemPrompt = ''
+    if (typeof systemBlocks === 'string') {
+      systemPrompt = systemBlocks
+    } else if (Array.isArray(systemBlocks)) {
+      systemPrompt = systemBlocks
+        .filter(b => b.type === 'text')
+        .map(b => b.text)
+        .join('\n\n')
+    }
+
+    const anthropicMessages = (anthropicBody.messages || []) as AnthropicMessage[]
+    const openaiMessages = convertAnthropicMessagesToOpenAI(anthropicMessages, systemPrompt)
+
+    const anthropicTools = (anthropicBody.tools || []) as Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>
+    const openaiTools = anthropicTools.length > 0 ? convertAnthropicToolsToOpenAI(anthropicTools) : undefined
+
+    const isStreaming = anthropicBody.stream === true
+    const maxTokens =
+      typeof anthropicBody.max_tokens === 'number'
+        ? anthropicBody.max_tokens
+        : undefined
+
+    const copilotResponse = await sendCopilotChatCompletion({
+      oauthToken: provider.oauthToken,
+      modelId: copilotModelId,
+      messages: openaiMessages,
+      isStreaming,
+      maxTokens,
+      tools: openaiTools,
+      signal: init?.signal,
+    })
+
+    if (!copilotResponse.ok) {
+      return copilotResponse
+    }
+
+    if (!isStreaming) {
+      const data = await copilotResponse.json() as {
+        id: string
+        choices: Array<{
+          message: {
+            role: string
+            content: string | null
+            tool_calls?: Array<{
+              id: string
+              function: { name: string; arguments: string }
+            }>
+          }
+          finish_reason: string
+        }>
+        usage?: { prompt_tokens: number; completion_tokens: number }
+      }
+
+      const choice = data.choices[0]
+      const anthropicContent: Array<{
+        type: string
+        text?: string
+        id?: string
+        name?: string
+        input?: unknown
+      }> = []
+
+      if (choice?.message?.content) {
+        anthropicContent.push({ type: 'text', text: choice.message.content })
+      }
+
+      if (choice?.message?.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+          anthropicContent.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || '{}'),
+          })
+        }
+      }
+
+      const anthropicResponse = {
+        id: data.id || `msg_copilot_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        content: anthropicContent,
+        model: copilotModelId,
+        stop_reason: choice?.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn',
+        usage: {
+          input_tokens: data.usage?.prompt_tokens || 0,
+          output_tokens: data.usage?.completion_tokens || 0,
+        },
+      }
+
+      return new Response(JSON.stringify(anthropicResponse), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    const transformStream = convertOpenAIStreamToAnthropic(copilotResponse.body!, copilotModelId)
+
+    return new Response(transformStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+}
+
+export function convertOpenAIStreamToAnthropic(
+  openaiStream: ReadableStream,
+  model: string,
+): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder()
+  const decoder = new TextDecoder()
+
+  let messageId = `msg_${Date.now()}`
+  let contentIndex = 0
+  let hasStartedContent = false
+  let currentToolCallIndex = -1
+  const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map()
+  let totalOutputTokens = 0
+
+  return new ReadableStream({
+    async start(controller) {
+      const reader = openaiStream.getReader()
+      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 === '[DONE]') {
+              if (hasStartedContent) {
+                controller.enqueue(encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex - 1}}\n\n`))
+              }
+              for (const [idx, tc] of toolCalls) {
+                controller.enqueue(
+                  encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex + idx}}\n\n`),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: message_delta\ndata: {"delta":{"stop_reason":"${toolCalls.size > 0 ? 'tool_use' : 'end_turn'}"},"usage":{"output_tokens":${totalOutputTokens}}}\n\n`,
+                ),
+              )
+              controller.enqueue(encoder.encode('event: message_stop\ndata: {}\n\n'))
+              return
+            }
+
+            let chunk: {
+              choices?: Array<{
+                delta?: {
+                  content?: string | null
+                  tool_calls?: Array<{
+                    index: number
+                    id?: string
+                    function?: { name?: string; arguments?: string }
+                  }>
+                  role?: string
+                }
+                finish_reason?: string | null
+              }>
+              usage?: { completion_tokens?: number; prompt_tokens?: number; total_tokens?: number }
+            }
+
+            try {
+              chunk = JSON.parse(data)
+            } catch {
+              continue
+            }
+
+            if (chunk.usage?.completion_tokens) {
+              totalOutputTokens = chunk.usage.completion_tokens
+            }
+
+            const choice = chunk.choices?.[0]
+            if (!choice?.delta) continue
+
+            const delta = choice.delta
+
+            if (delta.content != null && delta.content !== '') {
+              if (!hasStartedContent) {
+                hasStartedContent = true
+                controller.enqueue(
+                  encoder.encode(
+                    `event: content_block_start\ndata: {"index":${contentIndex},"content_block":{"type":"text","text":""}}\n\n`,
+                  ),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: content_block_delta\ndata: {"index":${contentIndex},"delta":{"type":"text_delta","text":"${JSON.stringify(delta.content).slice(1, -1)}"}}\n\n`,
+                ),
+              )
+            }
+
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (tc.id) {
+                  if (hasStartedContent && currentToolCallIndex === -1) {
+                    controller.enqueue(
+                      encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex}}\n\n`),
+                    )
+                    contentIndex++
+                    hasStartedContent = false
+                  }
+                  currentToolCallIndex = tc.index
+                  toolCalls.set(tc.index, {
+                    id: tc.id,
+                    name: tc.function?.name || '',
+                    arguments: tc.function?.arguments || '',
+                  })
+                  const toolBlockIndex =
+                    hasStartedContent ? contentIndex + 1 + tc.index : contentIndex + tc.index
+                  controller.enqueue(
+                    encoder.encode(
+                      `event: content_block_start\ndata: {"index":${toolBlockIndex},"content_block":{"type":"text","text":""}}\n\n`,
+                    ),
+                  )
+                } else if (tc.function?.arguments) {
+                  const existing = toolCalls.get(tc.index)
+                  if (existing) {
+                    existing.arguments += tc.function.arguments
+                  }
+                }
+              }
+            }
+
+            if (choice.finish_reason) {
+              if (hasStartedContent) {
+                controller.enqueue(
+                  encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex}}\n\n`),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: message_delta\ndata: {"delta":{"stop_reason":"${choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn'}"},"usage":{"output_tokens":${totalOutputTokens}}}\n\n`,
+                ),
+              )
+              controller.enqueue(encoder.encode('event: message_stop\ndata: {}\n\n'))
+              return
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock()
+        controller.close()
+      }
+    },
+  })
+}

src/services/api/customOpenAIClient.ts

@@ -0,0 +1,308 @@
+import { getGlobalConfig, type ConnectedProviderInfo } from '../../utils/config.js'
+import {
+  convertAnthropicMessagesToOpenAI,
+  convertAnthropicToolsToOpenAI,
+  convertOpenAIStreamToAnthropic,
+  type AnthropicMessage,
+} from './copilotClient.js'
+
+const PREFIX = 'custom-openai:'
+
+export function isCustomOpenAIModel(model: string | undefined): boolean {
+  return !!model?.startsWith(PREFIX)
+}
+
+export function getCustomOpenAIModelId(model: string): string {
+  const rest = model.slice(PREFIX.length).trim()
+  if (rest) {
+    return rest
+  }
+  const p = getGlobalConfig().connectedProviders?.['custom-openai']
+  return p?.defaultModel || 'gpt-4o-mini'
+}
+
+export function getCustomOpenAIProvider(): ConnectedProviderInfo | undefined {
+  return getGlobalConfig().connectedProviders?.['custom-openai']
+}
+
+export function isCustomOpenAIConnected(): boolean {
+  const c = getGlobalConfig()
+  return c.activeProvider === 'custom-openai' && !!c.connectedProviders?.['custom-openai']?.baseUrl
+}
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/$/, '')
+}
+
+/** Supports `https://host` or `https://host/v1` style bases. */
+function chatCompletionsUrl(base: string): string {
+  const b = normalizeBaseUrl(base)
+  if (b.endsWith('/v1')) {
+    return `${b}/chat/completions`
+  }
+  return `${b}/v1/chat/completions`
+}
+
+/**
+ * OpenAI-compatible `/v1/chat/completions` bridge (same protocol as GitHub Copilot path).
+ */
+export function createCustomOpenAIFetchOverride(
+  model: string,
+): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
+  const provider = getCustomOpenAIProvider()
+  if (!provider?.baseUrl) {
+    throw new Error('Custom OpenAI-compatible API is not configured')
+  }
+
+  const openaiModelId = getCustomOpenAIModelId(model)
+  const endpoint = chatCompletionsUrl(provider.baseUrl)
+
+  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const url = input instanceof URL ? input.href : typeof input === 'string' ? input : input.url
+
+    if (!url.includes('/messages') && !url.includes('/v1/')) {
+      return fetch(input, init)
+    }
+
+    if (url.includes('/count_tokens') || url.includes('/models')) {
+      return new Response(JSON.stringify({ input_tokens: 0 }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    let anthropicBody: Record<string, unknown> = {}
+    if (init?.body) {
+      try {
+        anthropicBody = JSON.parse(
+          typeof init.body === 'string' ? init.body : new TextDecoder().decode(init.body as ArrayBuffer),
+        )
+      } catch {
+        return fetch(input, init)
+      }
+    }
+
+    const systemBlocks = anthropicBody.system as
+      | Array<{ type: string; text: string }>
+      | string
+      | undefined
+    let systemPrompt = ''
+    if (typeof systemBlocks === 'string') {
+      systemPrompt = systemBlocks
+    } else if (Array.isArray(systemBlocks)) {
+      systemPrompt = systemBlocks
+        .filter(b => b.type === 'text')
+        .map(b => b.text)
+        .join('\n\n')
+    }
+
+    const anthropicMessages = (anthropicBody.messages || []) as AnthropicMessage[]
+    const openaiMessages = convertAnthropicMessagesToOpenAI(anthropicMessages, systemPrompt)
+
+    const anthropicTools = (anthropicBody.tools || []) as Array<{
+      name: string
+      description?: string
+      input_schema?: Record<string, unknown>
+    }>
+    const openaiTools = anthropicTools.length > 0 ? convertAnthropicToolsToOpenAI(anthropicTools) : undefined
+
+    const isStreaming = anthropicBody.stream === true
+
+    const requestBody: Record<string, unknown> = {
+      model: openaiModelId,
+      messages: openaiMessages,
+      stream: isStreaming,
+    }
+
+    if (anthropicBody.max_tokens) {
+      requestBody.max_tokens = anthropicBody.max_tokens
+    }
+
+    if (openaiTools && openaiTools.length > 0) {
+      requestBody.tools = openaiTools
+      requestBody.tool_choice = 'auto'
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'claude-code/2.1.88',
+    }
+    if (provider.apiKey) {
+      headers.Authorization = `Bearer ${provider.apiKey}`
+    }
+
+    const openaiResponse = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody),
+      signal: init?.signal,
+    })
+
+    if (!openaiResponse.ok) {
+      return openaiResponse
+    }
+
+    if (!isStreaming) {
+      const data = (await openaiResponse.json()) as {
+        id: string
+        choices: Array<{
+          message: {
+            role: string
+            content: string | null
+            tool_calls?: Array<{
+              id: string
+              function: { name: string; arguments: string }
+            }>
+          }
+          finish_reason: string
+        }>
+        usage?: { prompt_tokens: number; completion_tokens: number }
+      }
+
+      const choice = data.choices[0]
+      const anthropicContent: Array<{
+        type: string
+        text?: string
+        id?: string
+        name?: string
+        input?: unknown
+      }> = []
+
+      if (choice?.message?.content) {
+        anthropicContent.push({ type: 'text', text: choice.message.content })
+      }
+
+      if (choice?.message?.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+          anthropicContent.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || '{}'),
+          })
+        }
+      }
+
+      const anthropicResponse = {
+        id: data.id || `msg_custom_openai_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        content: anthropicContent,
+        model: openaiModelId,
+        stop_reason: choice?.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn',
+        usage: {
+          input_tokens: data.usage?.prompt_tokens || 0,
+          output_tokens: data.usage?.completion_tokens || 0,
+        },
+      }
+
+      return new Response(JSON.stringify(anthropicResponse), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    if (!openaiResponse.body) {
+      return openaiResponse
+    }
+
+    const transformStream = convertOpenAIStreamToAnthropic(openaiResponse.body, openaiModelId)
+
+    return new Response(transformStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+}
+
+function modelsListUrlFromOpenAIBase(base: string): string {
+  const b = normalizeBaseUrl(base)
+  if (b.endsWith('/v1')) {
+    return `${b}/models`
+  }
+  return `${b}/v1/models`
+}
+
+function parseOpenAIStyleModelList(json: unknown): string[] {
+  if (!json || typeof json !== 'object') {
+    return []
+  }
+  const o = json as Record<string, unknown>
+  const data = o.data
+  if (Array.isArray(data)) {
+    const ids: string[] = []
+    for (const item of data) {
+      if (item && typeof item === 'object' && 'id' in item && typeof (item as { id: unknown }).id === 'string') {
+        ids.push((item as { id: string }).id)
+      }
+    }
+    return [...new Set(ids.filter(Boolean))]
+  }
+  const models = o.models
+  if (Array.isArray(models)) {
+    const ids: string[] = []
+    for (const item of models) {
+      if (typeof item === 'string') {
+        ids.push(item)
+      } else if (item && typeof item === 'object' && 'id' in item && typeof (item as { id: unknown }).id === 'string') {
+        ids.push((item as { id: string }).id)
+      }
+    }
+    return [...new Set(ids.filter(Boolean))]
+  }
+  return []
+}
+
+/**
+ * GET /v1/models (OpenAI-compatible).
+ */
+export async function fetchOpenAICompatibleModelIds(
+  baseUrl: string,
+  apiKey?: string,
+): Promise<string[]> {
+  const url = modelsListUrlFromOpenAIBase(baseUrl)
+  const headers: Record<string, string> = {}
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`
+  }
+  const res = await fetch(url, { headers, signal: AbortSignal.timeout(20_000) })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`OpenAI-compatible /v1/models failed (${res.status})${body ? `: ${body.slice(0, 200)}` : ''}`)
+  }
+  const json: unknown = await res.json()
+  const ids = parseOpenAIStyleModelList(json)
+  return ids
+}
+
+/**
+ * GET /v1/models (Anthropic API).
+ */
+export async function fetchAnthropicCompatibleModelIds(
+  baseUrl: string,
+  apiKey?: string,
+): Promise<string[]> {
+  let root = baseUrl.replace(/\/$/, '')
+  if (root.endsWith('/v1')) {
+    root = root.slice(0, -3)
+  }
+  const url = `${root}/v1/models`
+  const headers: Record<string, string> = {
+    'anthropic-version': '2023-06-01',
+  }
+  if (apiKey) {
+    headers['x-api-key'] = apiKey
+  }
+  const res = await fetch(url, { headers, signal: AbortSignal.timeout(20_000) })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`Anthropic /v1/models failed (${res.status})${body ? `: ${body.slice(0, 200)}` : ''}`)
+  }
+  const json: unknown = await res.json()
+  const ids = parseOpenAIStyleModelList(json)
+  return ids
+}

src/services/telegram/TelegramService.ts

@@ -1,22 +1,44 @@
-import { logForDebugging } from '../../utils/debug.js'
 import { getTelegramRuntimeConfig } from './telegramConfig.js'
 import type {
+  TelegramAnswerCallbackQueryResponse,
+  TelegramBotCommand,
+  TelegramCallbackEvent,
+  TelegramEditMessageResponse,
   TelegramGetMeResponse,
   TelegramGetUpdatesResponse,
   TelegramInboundEvent,
+  TelegramInlineKeyboardMarkup,
   TelegramRuntimeConfig,
   TelegramSendMessageResponse,
+  TelegramSetMyCommandsResponse,
   TelegramServiceState,
   TelegramUpdate,
 } from './telegramTypes.js'
 
+// 日志函数 - 只写入文件
+function logTelegramDebug(message: string, level: 'debug' | 'error' | 'info' = 'debug'): void {
+  try {
+    const fs = require('node:fs')
+    const path = require('node:path')
+    const LOG_FILE_PATH = path.join(process.cwd(), 'log.md')
+    const timestamp = new Date().toISOString()
+    const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`
+    fs.appendFileSync(LOG_FILE_PATH, logEntry, 'utf-8')
+  } catch (error) {
+    // 忽略文件写入错误
+  }
+}
+
 type Listener = () => void
 type InboundListener = (event: TelegramInboundEvent) => void
+type CallbackListener = (event: TelegramCallbackEvent) => void
 
 const TELEGRAM_API_BASE = 'https://api.telegram.org'
 const MAX_TELEGRAM_MESSAGE_LENGTH = 4000
 const POLL_TIMEOUT_SECONDS = 25
 const RETRY_DELAY_MS = 3000
+const MAX_TELEGRAM_MENU_COMMANDS = 100
+const TELEGRAM_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/
 
 function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms))
@@ -49,9 +71,39 @@ function hasSameConfig(
   )
 }
 
+function normalizeCommandDescription(description: string): string {
+  return description.replace(/\s+/g, ' ').trim().slice(0, 256)
+}
+
+async function getTelegramMenuCommands(): Promise<TelegramBotCommand[]> {
+  const { getCommands, getCommandName } = await import('../../commands.js')
+  const commands = await getCommands(process.cwd())
+  const results: TelegramBotCommand[] = []
+  const seen = new Set<string>()
+
+  for (const command of commands) {
+    const candidates = [getCommandName(command), ...(command.aliases ?? [])]
+    const name = candidates.find(candidate => TELEGRAM_COMMAND_NAME_RE.test(candidate))
+    if (!name || seen.has(name)) continue
+
+    results.push({
+      command: name,
+      description: normalizeCommandDescription(command.description),
+    })
+    seen.add(name)
+
+    if (results.length >= MAX_TELEGRAM_MENU_COMMANDS) {
+      break
+    }
+  }
+
+  return results
+}
+
 class TelegramService {
   private listeners = new Set<Listener>()
   private inboundListeners = new Set<InboundListener>()
+  private callbackListeners = new Set<CallbackListener>()
   private state: TelegramServiceState = { status: 'stopped' }
   private config?: TelegramRuntimeConfig
   private abortController: AbortController | null = null
@@ -72,6 +124,13 @@ class TelegramService {
     }
   }
 
+  subscribeToCallbacks = (listener: CallbackListener): (() => void) => {
+    this.callbackListeners.add(listener)
+    return () => {
+      this.callbackListeners.delete(listener)
+    }
+  }
+
   getStateSnapshot = (): TelegramServiceState => this.state
 
   async start(config: TelegramRuntimeConfig): Promise<void> {
@@ -107,6 +166,18 @@ class TelegramService {
 
       if (runId !== this.runId || abortController.signal.aborted) return
 
+      try {
+        await this.refreshTelegramMenu(config, abortController.signal)
+      } catch (error) {
+        if (!abortController.signal.aborted && runId === this.runId) {
+          const message = normalizeTelegramError(error)
+          logTelegramDebug(`[telegram] failed to refresh menu: ${message}`, 'error')
+          this.patchState({ lastError: message })
+        }
+      }
+
+      if (runId !== this.runId || abortController.signal.aborted) return
+
       this.setState({
         status: 'running',
         botUsername: response.result?.username,
@@ -115,7 +186,7 @@ class TelegramService {
         lastError: undefined,
       })
 
-      logForDebugging(
+      logTelegramDebug(
         `[telegram] connected as @${response.result?.username ?? 'unknown'}`,
       )
 
@@ -155,23 +226,79 @@ class TelegramService {
     }
   }
 
-  async sendMessage(chatId: string, text: string): Promise<void> {
+  async sendMessage(
+    chatId: string,
+    text: string,
+    replyMarkup?: TelegramInlineKeyboardMarkup,
+  ): Promise<number | undefined> {
     if (!this.config) {
       throw new Error('Telegram service is not running')
     }
 
+    const numericChatId = Number(chatId)
+    logTelegramDebug(`[telegram] sendMessage called: chatId=${chatId} (type: ${typeof chatId}), numericChatId=${numericChatId} (type: ${typeof numericChatId}), text length=${text.length}`)
+    logTelegramDebug(`[telegram] allowedUserIds: ${JSON.stringify(this.config.allowedUserIds)}`)
+
+    let lastMessageId: number | undefined
+
     for (const chunk of chunkTelegramMessage(text)) {
-      await this.callTelegram<TelegramSendMessageResponse>(
+      logTelegramDebug(`[telegram] sending chunk to chat_id: ${numericChatId}`)
+      const response = await this.callTelegram<TelegramSendMessageResponse>(
         this.config,
         'sendMessage',
         {
-          chat_id: Number(chatId),
+          chat_id: numericChatId,
           text: chunk,
+          ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
         },
       )
+      lastMessageId = response.result?.message_id
+      logTelegramDebug(`[telegram] sendMessage succeeded: messageId=${lastMessageId}`)
     }
+    return lastMessageId
   }
 
+  async editMessage(
+    chatId: string,
+    messageId: number,
+    text: string,
+    replyMarkup?: TelegramInlineKeyboardMarkup,
+  ): Promise<void> {
+    if (!this.config) {
+      throw new Error('Telegram service is not running')
+    }
+
+    await this.callTelegram<TelegramEditMessageResponse>(
+      this.config,
+      'editMessageText',
+      {
+        chat_id: Number(chatId),
+        message_id: messageId,
+        text,
+        ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
+      },
+    )
+  }
+
+  async answerCallbackQuery(
+    callbackQueryId: string,
+    text?: string,
+  ): Promise<void> {
+    if (!this.config) {
+      throw new Error('Telegram service is not running')
+    }
+
+    await this.callTelegram<TelegramAnswerCallbackQueryResponse>(
+      this.config,
+      'answerCallbackQuery',
+      {
+        callback_query_id: callbackQueryId,
+        ...(text ? { text } : {}),
+      },
+    )
+  }
+
+
   private setState(nextState: TelegramServiceState): void {
     this.state = nextState
     for (const listener of this.listeners) {
@@ -191,6 +318,12 @@ class TelegramService {
       listener(event)
     }
   }
+  
+  private emitCallback(event: TelegramCallbackEvent): void {
+    for (const listener of this.callbackListeners) {
+      listener(event)
+    }
+  }
 
   private async pollLoop(
     runId: number,
@@ -205,7 +338,7 @@ class TelegramService {
           {
             offset: this.nextUpdateOffset,
             timeout: POLL_TIMEOUT_SECONDS,
-            allowed_updates: ['message'],
+            allowed_updates: ['message', 'callback_query'],
           },
           signal,
         )
@@ -216,39 +349,103 @@ class TelegramService {
           this.patchState({ lastError: undefined })
         }
 
-        for (const update of response.result ?? []) {
+        const updates = response.result ?? []
+        logTelegramDebug(`[telegram] received ${updates.length} updates from Telegram`)
+
+        for (const update of updates) {
+          logTelegramDebug(`[telegram] processing update: update_id=${update.update_id}`)
           this.handleUpdate(update, config)
         }
       } catch (error) {
         if (signal.aborted || runId !== this.runId) return
 
         const message = normalizeTelegramError(error)
-        logForDebugging(`[telegram] polling failed: ${message}`, {
-          level: 'error',
-        })
+        logTelegramDebug(`[telegram] polling failed: ${message}`, 'error')
         this.patchState({ lastError: message })
         await sleep(RETRY_DELAY_MS)
       }
     }
   }
 
+  private async refreshTelegramMenu(
+    config: TelegramRuntimeConfig,
+    signal: AbortSignal,
+  ): Promise<void> {
+    const commands = await getTelegramMenuCommands()
+
+    await this.callTelegram<TelegramSetMyCommandsResponse>(
+      config,
+      'setMyCommands',
+      {
+        commands,
+      },
+      signal,
+    )
+
+    logTelegramDebug(`[telegram] refreshed menu commands: ${commands.length}`)
+  }
+
   private handleUpdate(
     update: TelegramUpdate,
     config: TelegramRuntimeConfig,
   ): void {
-    this.nextUpdateOffset = update.update_id + 1
+    try {
+      logTelegramDebug(`[telegram] handleUpdate called, update_id: ${update.update_id}`)
+      this.nextUpdateOffset = update.update_id + 1
+
+      const message = update.message
+      const callbackQuery = update.callback_query
+
+      logTelegramDebug(`[telegram] update structure: has_message=${!!message}, has_callback=${!!callbackQuery}`)
+
+      if (callbackQuery?.data) {
+      const chatId = callbackQuery.message?.chat?.id
+      const userId = callbackQuery.from?.id
+      const messageId = callbackQuery.message?.message_id
+      if (
+        chatId !== undefined &&
+        userId !== undefined &&
+        messageId !== undefined &&
+        !callbackQuery.from?.is_bot
+      ) {
+        if (!config.allowedUserIds.includes(String(userId))) {
+          return
+        }
+        this.emitCallback({
+          kind: 'callback-query',
+          callbackQueryId: callbackQuery.id,
+          chatId: String(chatId),
+          userId: String(userId),
+          messageId,
+          data: callbackQuery.data,
+        })
+      }
+      return
+    }
 
-    const message = update.message
     const chatId = message?.chat?.id
     const userId = message?.from?.id
 
-    if (!message || chatId === undefined || userId === undefined) return
-    if (message.from?.is_bot) return
-    if (message.chat?.type !== 'private') return
+    logTelegramDebug(`[telegram] message details: chatId=${chatId}, userId=${userId}, is_bot=${message?.from?.is_bot}, chat_type=${message?.chat?.type}`)
+
+    if (!message || chatId === undefined || userId === undefined) {
+      logTelegramDebug(`[telegram] message rejected: missing required fields`)
+      return
+    }
+    if (message.from?.is_bot) {
+      logTelegramDebug(`[telegram] message rejected: from bot`)
+      return
+    }
+    if (message.chat?.type !== 'private') {
+      logTelegramDebug(`[telegram] message rejected: not private chat`)
+      return
+    }
 
     const normalizedChatId = String(chatId)
     const normalizedUserId = String(userId)
 
+    logTelegramDebug(`[telegram] user validation: normalizedUserId=${normalizedUserId}, allowedUserIds=${JSON.stringify(config.allowedUserIds)}`)
+
     if (!config.allowedUserIds.includes(normalizedUserId)) {
       void this.sendMessage(
         normalizedChatId,
@@ -264,6 +461,8 @@ class TelegramService {
 
     const text = message.text?.trim()
 
+    logTelegramDebug(`[telegram] inbound message from chatId: ${normalizedChatId}, userId: ${normalizedUserId}, text: ${text?.slice(0, 50)}`)
+
     if (!text) {
       void this.sendMessage(
         normalizedChatId,
@@ -280,6 +479,7 @@ class TelegramService {
       return
     }
 
+    logTelegramDebug(`[telegram] emitting inbound event with chatId: ${normalizedChatId}`)
     this.emitInbound({
       kind: 'inbound-message',
       chatId: normalizedChatId,
@@ -288,6 +488,9 @@ class TelegramService {
       messageId: message.message_id,
       updateId: update.update_id,
     })
+    } catch (error) {
+      logTelegramDebug(`[telegram] handleUpdate error: ${error instanceof Error ? error.message : String(error)}`, 'error')
+    }
   }
 
   private async callTelegram<T>(
@@ -296,34 +499,68 @@ class TelegramService {
     payload: Record<string, unknown>,
     signal?: AbortSignal,
   ): Promise<T> {
-    const response = await fetch(
-      `${TELEGRAM_API_BASE}/bot${config.botToken}/${method}`,
-      {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify(payload),
-        signal,
-      },
-    )
+    logTelegramDebug(`[telegram] calling API: ${method}`)
 
-    if (!response.ok) {
-      throw new Error(`Telegram API ${method} failed with HTTP ${response.status}`)
-    }
+    // 创建超时信号（30秒超时）
+    const timeoutController = new AbortController()
+    const timeoutId = setTimeout(() => {
+      timeoutController.abort()
+    }, 30000)
 
-    const json = await response.json() as {
-      ok?: boolean
-      description?: string
-    }
+    // 合并外部信号和超时信号
+    const combinedSignal = signal
+      ? AbortSignal.any([signal, timeoutController.signal])
+      : timeoutController.signal
 
-    if (!json.ok) {
-      throw new Error(
-        `Telegram API ${method} failed: ${json.description ?? 'unknown error'}`,
+    try {
+      const response = await fetch(
+        `${TELEGRAM_API_BASE}/bot${config.botToken}/${method}`,
+        {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+          },
+          body: JSON.stringify(payload),
+          signal: combinedSignal,
+        },
       )
-    }
 
-    return json as T
+      clearTimeout(timeoutId)
+
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => 'unknown error')
+        logTelegramDebug(`[telegram] API error: ${method} failed with HTTP ${response.status}: ${errorText}`, 'error')
+        throw new Error(`Telegram API ${method} failed with HTTP ${response.status}: ${errorText}`)
+      }
+
+      const json = await response.json() as {
+        ok?: boolean
+        description?: string
+      }
+
+      if (!json.ok) {
+        logTelegramDebug(`[telegram] API error: ${method} failed: ${json.description ?? 'unknown error'}`, 'error')
+        throw new Error(
+          `Telegram API ${method} failed: ${json.description ?? 'unknown error'}`,
+        )
+      }
+
+      return json as T
+    } catch (error) {
+      clearTimeout(timeoutId)
+
+      if (error instanceof Error) {
+        if (error.name === 'AbortError') {
+          logTelegramDebug(`[telegram] API error: ${method} timed out or was aborted`, 'error')
+          throw new Error(`Telegram API ${method} timed out`)
+        }
+        logTelegramDebug(`[telegram] API error: ${method} failed: ${error.message}`, 'error')
+        throw new Error(`Telegram API ${method} failed: ${error.message}`)
+      }
+
+      logTelegramDebug(`[telegram] API error: ${method} failed with unknown error`, 'error')
+      throw new Error(`Telegram API ${method} failed with unknown error`)
+    }
   }
 }
 

src/services/telegram/interactiveCommands.ts

@@ -0,0 +1,653 @@
+import type { AppStateStore } from '../../state/AppState.js'
+import { saveGlobalConfig } from '../../utils/config.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { isBilledAsExtraUsage } from '../../utils/extraUsage.js'
+import {
+  clearFastModeCooldown,
+  isFastModeAvailable,
+  isFastModeEnabled,
+  isFastModeSupportedByModel,
+} from '../../utils/fastMode.js'
+import {
+  getDefaultMainLoopModelSetting,
+  isOpus1mMergeEnabled,
+  renderDefaultModelSetting,
+} from '../../utils/model/model.js'
+import {
+  getModelOptions,
+  type ModelOption,
+} from '../../utils/model/modelOptions.js'
+import { fetchCopilotModels } from '../api/copilotClient.js'
+import {
+  fetchAnthropicCompatibleModelIds,
+  fetchOpenAICompatibleModelIds,
+} from '../api/customOpenAIClient.js'
+import { telegramService } from './TelegramService.js'
+import type {
+  TelegramCallbackEvent,
+  TelegramInboundEvent,
+  TelegramInlineKeyboardButton,
+  TelegramInlineKeyboardMarkup,
+} from './telegramTypes.js'
+
+const COPILOT_CLIENT_ID = 'Ov23li8tweQw6odWQebz'
+const COPILOT_DEVICE_CODE_URL = 'https://github.com/login/device/code'
+const COPILOT_ACCESS_TOKEN_URL = 'https://github.com/login/oauth/access_token'
+const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000
+
+const MODEL_PREFIX = 'tg:model'
+const CONNECT_PREFIX = 'tg:connect'
+
+type ConnectPendingState =
+  | { kind: 'openrouter-api-key' }
+  | { kind: 'custom-openai-base' }
+  | { kind: 'custom-openai-key'; baseUrl: string }
+  | { kind: 'custom-anthropic-base' }
+  | { kind: 'custom-anthropic-key'; baseUrl: string }
+
+type ConnectModelSelectionState = {
+  providerId: 'custom-openai' | 'custom-anthropic'
+  baseUrl: string
+  apiKey?: string
+  models: string[]
+}
+
+const pendingConnectInputs = new Map<string, ConnectPendingState>()
+const pendingModelMenus = new Map<string, ModelOption[]>()
+const pendingConnectModelMenus = new Map<string, ConnectModelSelectionState>()
+
+function chunk<T>(items: T[], size: number): T[][] {
+  const rows: T[][] = []
+  for (let i = 0; i < items.length; i += size) {
+    rows.push(items.slice(i, i + size))
+  }
+  return rows
+}
+
+function createKeyboard(
+  rows: TelegramInlineKeyboardButton[][],
+): TelegramInlineKeyboardMarkup {
+  return { inline_keyboard: rows }
+}
+
+function buildModelKeyboard(options: ModelOption[]): TelegramInlineKeyboardMarkup {
+  return createKeyboard(
+    chunk(
+      options.map((option, index) => ({
+        text: option.label,
+        callback_data: `${MODEL_PREFIX}:select:${index}`,
+      })),
+      2,
+    ),
+  )
+}
+
+function buildConnectKeyboard(): TelegramInlineKeyboardMarkup {
+  return createKeyboard([
+    [
+      { text: 'GitHub Copilot', callback_data: `${CONNECT_PREFIX}:provider:github-copilot` },
+      { text: 'OpenRouter', callback_data: `${CONNECT_PREFIX}:provider:openrouter` },
+    ],
+    [
+      { text: 'Custom OpenAI', callback_data: `${CONNECT_PREFIX}:provider:custom-openai` },
+      { text: 'Custom Anthropic', callback_data: `${CONNECT_PREFIX}:provider:custom-anthropic` },
+    ],
+  ])
+}
+
+function buildSkipKeyKeyboard(providerId: 'custom-openai' | 'custom-anthropic') {
+  return createKeyboard([
+    [
+      {
+        text: '跳过 API Key',
+        callback_data: `${CONNECT_PREFIX}:skipkey:${providerId}`,
+      },
+    ],
+  ])
+}
+
+function buildModelSelectionKeyboard(
+  providerId: 'custom-openai' | 'custom-anthropic',
+  models: string[],
+): TelegramInlineKeyboardMarkup {
+  return createKeyboard(
+    chunk(
+      models.map((model, index) => ({
+        text: model,
+        callback_data: `${CONNECT_PREFIX}:model:${providerId}:${index}`,
+      })),
+      1,
+    ),
+  )
+}
+
+function renderModelSelectionText(store: AppStateStore, options: ModelOption[]): string {
+  const state = store.getState()
+  const current = state.mainLoopModel
+  const currentLabel = renderDefaultModelSetting(
+    current ?? getDefaultMainLoopModelSetting(),
+  )
+  const lines = [
+    `当前模型: ${currentLabel}${current === null ? ' (default)' : ''}`,
+    '',
+    '请选择要切换的模型：',
+  ]
+
+  options.forEach((option, index) => {
+    lines.push(`${index + 1}. ${option.label} - ${option.description}`)
+  })
+
+  return lines.join('\n')
+}
+
+function applyModelSelection(
+  store: AppStateStore,
+  model: ModelOption['value'],
+): string {
+  const state = store.getState()
+  let message = `已切换到模型 ${renderDefaultModelSetting(model ?? getDefaultMainLoopModelSetting())}${model === null ? ' (default)' : ''}`
+  let wasFastModeToggledOn: boolean | undefined
+
+  store.setState(prev => ({
+    ...prev,
+    mainLoopModel: model,
+    mainLoopModelForSession: null,
+  }))
+
+  if (isFastModeEnabled()) {
+    clearFastModeCooldown()
+    if (!isFastModeSupportedByModel(model) && state.fastMode) {
+      store.setState(prev => ({
+        ...prev,
+        fastMode: false,
+      }))
+      wasFastModeToggledOn = false
+    } else if (
+      isFastModeSupportedByModel(model) &&
+      isFastModeAvailable() &&
+      state.fastMode
+    ) {
+      message += ' · Fast mode ON'
+      wasFastModeToggledOn = true
+    }
+  }
+
+  if (isBilledAsExtraUsage(model, wasFastModeToggledOn === true, isOpus1mMergeEnabled())) {
+    message += ' · Billed as extra usage'
+  }
+
+  if (wasFastModeToggledOn === false) {
+    message += ' · Fast mode OFF'
+  }
+
+  return message
+}
+
+async function beginCopilotOAuth(chatId: string): Promise<void> {
+  const response = await fetch(COPILOT_DEVICE_CODE_URL, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      client_id: COPILOT_CLIENT_ID,
+      scope: 'read:user',
+    }),
+  })
+
+  if (!response.ok) {
+    throw new Error('无法发起 GitHub Copilot 设备授权')
+  }
+
+  const data = (await response.json()) as {
+    verification_uri: string
+    user_code: string
+    device_code: string
+    interval: number
+  }
+
+  await telegramService.sendMessage(
+    chatId,
+    [
+      'GitHub Copilot 连接已开始。',
+      `1. 打开: ${data.verification_uri}`,
+      `2. 输入代码: ${data.user_code}`,
+      '授权完成后，我会自动继续。',
+    ].join('\n'),
+  )
+
+  void pollCopilotOAuth(chatId, data)
+}
+
+async function pollCopilotOAuth(
+  chatId: string,
+  data: {
+    device_code: string
+    interval: number
+  },
+): Promise<void> {
+  let currentInterval = data.interval
+
+  while (true) {
+    await new Promise(resolve =>
+      setTimeout(resolve, currentInterval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS),
+    )
+
+    const response = await fetch(COPILOT_ACCESS_TOKEN_URL, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        client_id: COPILOT_CLIENT_ID,
+        device_code: data.device_code,
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      }),
+    })
+
+    if (!response.ok) {
+      throw new Error('获取 GitHub Copilot access token 失败')
+    }
+
+    const result = (await response.json()) as {
+      access_token?: string
+      error?: string
+      interval?: number
+    }
+
+    if (result.access_token) {
+      saveGlobalConfig(current => ({
+        ...current,
+        connectedProviders: {
+          ...(current.connectedProviders || {}),
+          'github-copilot': {
+            oauthToken: result.access_token,
+            connectedAt: new Date().toISOString(),
+          },
+        },
+        activeProvider: current.activeProvider || 'github-copilot',
+      }))
+
+      fetchCopilotModels()
+        .then(models => {
+          saveGlobalConfig(current => ({
+            ...current,
+            copilotModelsCache: { models, fetchedAt: Date.now() },
+          }))
+        })
+        .catch(() => {})
+
+      await telegramService.sendMessage(
+        chatId,
+        'GitHub Copilot 已连接成功。之后可用 /model 选择 Copilot 模型。',
+      )
+      return
+    }
+
+    if (result.error === 'authorization_pending') {
+      continue
+    }
+
+    if (result.error === 'slow_down') {
+      currentInterval = result.interval ?? currentInterval + 5
+      continue
+    }
+
+    if (result.error === 'expired_token') {
+      throw new Error('GitHub Copilot 授权已过期，请重新执行 /connect')
+    }
+
+    if (result.error === 'access_denied') {
+      throw new Error('GitHub Copilot 授权被拒绝')
+    }
+
+    if (result.error) {
+      throw new Error(`GitHub Copilot OAuth 错误: ${result.error}`)
+    }
+  }
+}
+
+async function handleConnectTextInput(
+  chatId: string,
+  text: string,
+): Promise<boolean> {
+  const pending = pendingConnectInputs.get(chatId)
+  if (!pending) return false
+
+  pendingConnectInputs.delete(chatId)
+
+  switch (pending.kind) {
+    case 'openrouter-api-key': {
+      if (!text.trim()) {
+        await telegramService.sendMessage(chatId, 'API Key 不能为空，请重新执行 /connect。')
+        return true
+      }
+      saveGlobalConfig(current => ({
+        ...current,
+        connectedProviders: {
+          ...(current.connectedProviders || {}),
+          openrouter: {
+            apiKey: text.trim(),
+            connectedAt: new Date().toISOString(),
+          },
+        },
+        activeProvider: current.activeProvider || 'openrouter',
+      }))
+      await telegramService.sendMessage(chatId, 'OpenRouter 已连接成功。')
+      return true
+    }
+    case 'custom-openai-base': {
+      const baseUrl = text.trim()
+      if (!baseUrl) {
+        await telegramService.sendMessage(chatId, 'Base URL 不能为空，请重新执行 /connect。')
+        return true
+      }
+      pendingConnectInputs.set(chatId, {
+        kind: 'custom-openai-key',
+        baseUrl,
+      })
+      await telegramService.sendMessage(
+        chatId,
+        '请输入 Custom OpenAI 的 API Key，或者点击下方按钮跳过。',
+        buildSkipKeyKeyboard('custom-openai'),
+      )
+      return true
+    }
+    case 'custom-anthropic-base': {
+      const baseUrl = text.trim()
+      if (!baseUrl) {
+        await telegramService.sendMessage(chatId, 'Base URL 不能为空，请重新执行 /connect。')
+        return true
+      }
+      pendingConnectInputs.set(chatId, {
+        kind: 'custom-anthropic-key',
+        baseUrl,
+      })
+      await telegramService.sendMessage(
+        chatId,
+        '请输入 Custom Anthropic 的 API Key，或者点击下方按钮跳过。',
+        buildSkipKeyKeyboard('custom-anthropic'),
+      )
+      return true
+    }
+    case 'custom-openai-key': {
+      await startCustomProviderModelFetch(
+        chatId,
+        'custom-openai',
+        pending.baseUrl,
+        text.trim() || undefined,
+      )
+      return true
+    }
+    case 'custom-anthropic-key': {
+      await startCustomProviderModelFetch(
+        chatId,
+        'custom-anthropic',
+        pending.baseUrl,
+        text.trim() || undefined,
+      )
+      return true
+    }
+  }
+}
+
+async function startCustomProviderModelFetch(
+  chatId: string,
+  providerId: 'custom-openai' | 'custom-anthropic',
+  baseUrl: string,
+  apiKey?: string,
+): Promise<void> {
+  const models =
+    providerId === 'custom-openai'
+      ? await fetchOpenAICompatibleModelIds(baseUrl, apiKey)
+      : await fetchAnthropicCompatibleModelIds(baseUrl, apiKey)
+
+  if (models.length === 0) {
+    await telegramService.sendMessage(
+      chatId,
+      '没有从 /v1/models 获取到可用模型，请检查 Base URL 或 API Key。',
+    )
+    return
+  }
+
+  pendingConnectModelMenus.set(chatId, {
+    providerId,
+    baseUrl,
+    apiKey,
+    models,
+  })
+
+  await telegramService.sendMessage(
+    chatId,
+    `请选择 ${providerId === 'custom-openai' ? 'Custom OpenAI' : 'Custom Anthropic'} 的默认模型：`,
+    buildModelSelectionKeyboard(providerId, models),
+  )
+}
+
+export async function maybeHandleTelegramInteractiveInput(
+  event: TelegramInboundEvent,
+  store: AppStateStore,
+): Promise<boolean> {
+  const text = event.text.trim()
+
+  if (await handleConnectTextInput(event.chatId, text)) {
+    return true
+  }
+
+  if (text === '/model') {
+    const options = getModelOptions(store.getState().fastMode).slice(0, 20)
+    pendingModelMenus.set(event.chatId, options)
+    await telegramService.sendMessage(
+      event.chatId,
+      renderModelSelectionText(store, options),
+      buildModelKeyboard(options),
+    )
+    return true
+  }
+
+  if (text === '/connect') {
+    await telegramService.sendMessage(
+      event.chatId,
+      '请选择要连接的 provider：',
+      buildConnectKeyboard(),
+    )
+    return true
+  }
+
+  return false
+}
+
+export async function handleTelegramCallback(
+  event: TelegramCallbackEvent,
+  store: AppStateStore,
+): Promise<boolean> {
+  if (event.data.startsWith(`${MODEL_PREFIX}:select:`)) {
+    const index = Number(event.data.split(':').at(-1))
+    const options = pendingModelMenus.get(event.chatId)
+    const option = Number.isFinite(index) ? options?.[index] : undefined
+
+    await telegramService.answerCallbackQuery(
+      event.callbackQueryId,
+      option ? `已选择 ${option.label}` : '模型选项已失效',
+    )
+
+    if (!option) {
+      return true
+    }
+
+    const message = applyModelSelection(store, option.value)
+    await telegramService.editMessage(event.chatId, event.messageId, message)
+    pendingModelMenus.delete(event.chatId)
+    return true
+  }
+
+  if (event.data.startsWith(`${CONNECT_PREFIX}:provider:`)) {
+    const providerId = event.data.split(':').at(-1)
+    await telegramService.answerCallbackQuery(event.callbackQueryId)
+
+    switch (providerId) {
+      case 'github-copilot':
+        await telegramService.editMessage(
+          event.chatId,
+          event.messageId,
+          'GitHub Copilot 正在发起设备授权，请稍候...',
+        )
+        await beginCopilotOAuth(event.chatId)
+        return true
+      case 'openrouter':
+        pendingConnectInputs.set(event.chatId, { kind: 'openrouter-api-key' })
+        await telegramService.editMessage(
+          event.chatId,
+          event.messageId,
+          '请直接发送 OpenRouter API Key。',
+        )
+        return true
+      case 'custom-openai':
+        pendingConnectInputs.set(event.chatId, { kind: 'custom-openai-base' })
+        await telegramService.editMessage(
+          event.chatId,
+          event.messageId,
+          '请直接发送 Custom OpenAI 的 Base URL。',
+        )
+        return true
+      case 'custom-anthropic':
+        pendingConnectInputs.set(event.chatId, { kind: 'custom-anthropic-base' })
+        await telegramService.editMessage(
+          event.chatId,
+          event.messageId,
+          '请直接发送 Custom Anthropic 的 Base URL。',
+        )
+        return true
+      default:
+        await telegramService.editMessage(
+          event.chatId,
+          event.messageId,
+          '暂不支持这个 provider。',
+        )
+        return true
+    }
+  }
+
+  if (event.data.startsWith(`${CONNECT_PREFIX}:skipkey:`)) {
+    const providerId = event.data.split(':').at(-1)
+    const pending = pendingConnectInputs.get(event.chatId)
+    await telegramService.answerCallbackQuery(event.callbackQueryId)
+
+    if (
+      providerId === 'custom-openai' &&
+      pending?.kind === 'custom-openai-key'
+    ) {
+      pendingConnectInputs.delete(event.chatId)
+      await telegramService.editMessage(
+        event.chatId,
+        event.messageId,
+        '正在获取 Custom OpenAI 模型列表...',
+      )
+      await startCustomProviderModelFetch(
+        event.chatId,
+        'custom-openai',
+        pending.baseUrl,
+      )
+      return true
+    }
+
+    if (
+      providerId === 'custom-anthropic' &&
+      pending?.kind === 'custom-anthropic-key'
+    ) {
+      pendingConnectInputs.delete(event.chatId)
+      await telegramService.editMessage(
+        event.chatId,
+        event.messageId,
+        '正在获取 Custom Anthropic 模型列表...',
+      )
+      await startCustomProviderModelFetch(
+        event.chatId,
+        'custom-anthropic',
+        pending.baseUrl,
+      )
+      return true
+    }
+
+    return true
+  }
+
+  if (event.data.startsWith(`${CONNECT_PREFIX}:model:`)) {
+    const [, , , providerId, indexRaw] = event.data.split(':')
+    const selection = pendingConnectModelMenus.get(event.chatId)
+    const index = Number(indexRaw)
+    const model = Number.isFinite(index) ? selection?.models[index] : undefined
+
+    await telegramService.answerCallbackQuery(
+      event.callbackQueryId,
+      model ? `已选择 ${model}` : '模型选项已失效',
+    )
+
+    if (
+      !selection ||
+      !model ||
+      (providerId !== 'custom-openai' && providerId !== 'custom-anthropic')
+    ) {
+      return true
+    }
+
+    if (providerId !== selection.providerId) {
+      return true
+    }
+
+    saveGlobalConfig(current => ({
+      ...current,
+      connectedProviders: {
+        ...(current.connectedProviders || {}),
+        [providerId]: {
+          baseUrl: selection.baseUrl,
+          defaultModel: model,
+          ...(selection.apiKey ? { apiKey: selection.apiKey } : {}),
+          connectedAt: new Date().toISOString(),
+        },
+      },
+      activeProvider: providerId,
+      ...(providerId === 'custom-openai'
+        ? {
+            openaiCustomModelsCache: selection.models.map(id => ({ id })),
+          }
+        : {
+            anthropicCustomModelsCache: selection.models.map(id => ({ id })),
+          }),
+    }))
+
+    pendingConnectModelMenus.delete(event.chatId)
+    await telegramService.editMessage(
+      event.chatId,
+      event.messageId,
+      `${providerId === 'custom-openai' ? 'Custom OpenAI' : 'Custom Anthropic'} 已连接成功，默认模型为 ${model}。`,
+    )
+    return true
+  }
+
+  return false
+}
+
+export function clearTelegramInteractiveState(chatId?: string): void {
+  if (chatId) {
+    pendingConnectInputs.delete(chatId)
+    pendingModelMenus.delete(chatId)
+    pendingConnectModelMenus.delete(chatId)
+    return
+  }
+
+  pendingConnectInputs.clear()
+  pendingModelMenus.clear()
+  pendingConnectModelMenus.clear()
+}
+
+export function logTelegramInteractiveError(error: unknown): void {
+  logForDebugging(
+    `[telegram] interactive handler failed: ${
+      error instanceof Error ? error.message : String(error)
+    }`,
+    { level: 'error' },
+  )
+}

src/services/telegram/telegramConfig.ts

@@ -12,6 +12,14 @@ export function getTelegramConfig(): TelegramConfig | undefined {
   return getGlobalConfig().telegram
 }
 
+export function hasTelegramRuntimeConfig(): boolean {
+  const telegram = getTelegramConfig()
+  return Boolean(
+    telegram?.botToken?.trim() &&
+      (telegram.allowedUserIds?.filter(Boolean).length ?? 0) > 0,
+  )
+}
+
 export function saveTelegramConfig(updates: TelegramConfigDraft): void {
   saveGlobalConfig(current => ({
     ...current,

src/services/telegram/telegramTypes.ts

@@ -42,6 +42,22 @@ export type TelegramUpdate = {
       is_bot?: boolean
     }
   }
+  callback_query?: {
+    id: string
+    data?: string
+    from?: {
+      id?: number
+      is_bot?: boolean
+    }
+    message?: {
+      message_id: number
+      chat?: {
+        id?: number
+        type?: string
+      }
+      text?: string
+    }
+  }
 }
 
 export type TelegramGetMeResponse = {
@@ -64,6 +80,47 @@ export type TelegramGetUpdatesResponse = {
 export type TelegramSendMessageResponse = {
   ok: boolean
   description?: string
+  result?: {
+    message_id: number
+  }
+}
+
+export type TelegramSetMyCommandsResponse = {
+  ok: boolean
+  description?: string
+}
+
+export type TelegramEditMessageResponse = {
+  ok: boolean
+  description?: string
+}
+
+export type TelegramAnswerCallbackQueryResponse = {
+  ok: boolean
+  description?: string
+}
+
+export type TelegramBotCommand = {
+  command: string
+  description: string
+}
+
+export type TelegramInlineKeyboardButton = {
+  text: string
+  callback_data: string
+}
+
+export type TelegramInlineKeyboardMarkup = {
+  inline_keyboard: TelegramInlineKeyboardButton[][]
+}
+
+export type TelegramCallbackEvent = {
+  kind: 'callback-query'
+  callbackQueryId: string
+  chatId: string
+  userId: string
+  messageId: number
+  data: string
 }
 
 export type TelegramConfigDraft = Partial<TelegramConfig>