feat(feishu): auto-select model to unblock pending runs (#25)

* feat(feishu): auto-select pending models

* fix(feishu): share strict timeout parsing

Author: Doctor-wu

packages/feishu/src/__tests__/config.test.ts

@@ -22,10 +22,31 @@ describe('readFeishuConfig', () => {
     expect(config.feishuAppId).toBe('cli_test_app_id');
     expect(config.feishuAppSecret).toBe('test-secret');
     expect(config.feishuBaseUrl).toBe('https://example.invalid');
+    expect(config.feishuModelSelectionTimeoutMs).toBe(10_000);
     expect('feishuPort' in config).toBe(false);
     expect(config.agentTimeoutMs).toBeGreaterThan(0);
   });
 
+  it('allows overriding the model auto-selection timeout', () => {
+    const config = readFeishuConfig({
+      ...process.env,
+      FEISHU_APP_ID: 'cli_test_app_id',
+      FEISHU_APP_SECRET: 'test-secret',
+      FEISHU_MODEL_SELECTION_TIMEOUT_MS: '2500',
+    });
+
+    expect(config.feishuModelSelectionTimeoutMs).toBe(2_500);
+  });
+
+  it('rejects dirty model auto-selection timeout input', () => {
+    expect(() => readFeishuConfig({
+      ...process.env,
+      FEISHU_APP_ID: 'cli_test_app_id',
+      FEISHU_APP_SECRET: 'test-secret',
+      FEISHU_MODEL_SELECTION_TIMEOUT_MS: '10s',
+    })).toThrow('Invalid numeric environment variable: FEISHU_MODEL_SELECTION_TIMEOUT_MS');
+  });
+
   it('throws when required Feishu environment variables are missing', () => {
     expect(() => readFeishuConfig({
       ...process.env,
@@ -47,6 +68,8 @@ describe('readFeishuConfig', () => {
       artifactMaxSizeBytes: 123_456,
       claudeBin: '/tmp/bin/claude',
       codexBin: '/tmp/bin/codex',
+      opencodeBin: '/tmp/bin/opencode',
+      feishuModelSelectionTimeoutMs: 2_345,
       feishuAppId: 'test-app-id',
       feishuAppSecret: 'test-secret',
       feishuBaseUrl: 'https://open.feishu.cn',
@@ -62,6 +85,8 @@ describe('readFeishuConfig', () => {
     expect(process.env['CLAUDE_CWD']).toBe('/tmp/feishu-workspace');
     expect(process.env['CLAUDE_BIN']).toBe('/tmp/bin/claude');
     expect(process.env['CODEX_BIN']).toBe('/tmp/bin/codex');
+    expect(process.env['OPENCODE_BIN']).toBe('/tmp/bin/opencode');
+    expect(process.env['FEISHU_MODEL_SELECTION_TIMEOUT_MS']).toBe('2345');
   });
 });
 
@@ -76,6 +101,8 @@ describe('startup entry', () => {
       artifactMaxSizeBytes: 8 * 1024 * 1024,
       claudeBin: '/opt/homebrew/bin/claude',
       codexBin: '/opt/homebrew/bin/codex',
+      opencodeBin: '/opt/homebrew/bin/opencode',
+      feishuModelSelectionTimeoutMs: 10_000,
       feishuAppId: 'test-app-id',
       feishuAppSecret: 'test-secret',
       feishuBaseUrl: 'https://open.feishu.cn',
@@ -104,6 +131,8 @@ describe('startup entry', () => {
       artifactMaxSizeBytes: 8 * 1024 * 1024,
       claudeBin: '/opt/homebrew/bin/claude',
       codexBin: '/opt/homebrew/bin/codex',
+      opencodeBin: '/opt/homebrew/bin/opencode',
+      feishuModelSelectionTimeoutMs: 10_000,
       feishuAppId: 'test-app-id',
       feishuAppSecret: 'test-secret',
       feishuBaseUrl: 'https://open.feishu.cn',

packages/feishu/src/__tests__/runtime.test.ts

@@ -59,6 +59,7 @@ import {
 } from '../runtime.js';
 
 afterEach(() => {
+  vi.useRealTimers();
   resetFeishuRuntimeForTests();
 });
 
@@ -328,6 +329,78 @@ describe('Feishu runtime', () => {
     expect(buttonTexts).toEqual(['Sonnet']);
   });
 
+  it('auto-selects the first available model after timeout and resumes the pending run', async () => {
+    vi.useFakeTimers();
+    coreMocks.applySessionControlCommand.mockImplementation(({ conversationId, type, value }: any) => {
+      if (type !== 'model') {
+        throw new Error(`Unexpected control command: ${type}`);
+      }
+
+      conversationModels.set(conversationId, String(value));
+      return {
+        kind: 'model',
+        conversationId,
+        value: String(value),
+        stateChanged: true,
+        persist: true,
+        clearContinuation: false,
+        requiresConfirmation: false,
+        summaryKey: 'model.updated',
+      };
+    });
+    coreMocks.evaluateConversationRunRequest.mockReturnValueOnce({
+      kind: 'ready',
+      conversationId: 'conv-model-timeout',
+      backend: 'claude',
+    });
+    coreMocks.getAvailableBackendCapabilities.mockResolvedValueOnce([
+      {
+        name: 'claude',
+        models: [
+          { id: 'sonnet', label: 'Sonnet' },
+          { id: 'opus', label: 'Opus' },
+        ],
+      },
+      {
+        name: 'opencode',
+        models: [],
+      },
+    ]);
+    conversationBackend.set('conv-model-timeout', 'claude');
+
+    const transport = {
+      sendText: vi.fn(async () => undefined),
+      sendCard: vi.fn(async () => undefined),
+      updateCard: vi.fn(async () => undefined),
+      uploadFile: vi.fn(async () => undefined),
+    };
+
+    await expect(runFeishuConversation({
+      conversationId: 'conv-model-timeout',
+      target: {
+        chatId: 'chat-1',
+      },
+      prompt: 'ship it',
+      mode: 'code',
+      transport,
+      defaultCwd: process.cwd(),
+      modelSelectionTimeoutMs: 10_000,
+    })).resolves.toEqual({ kind: 'blocked' });
+
+    expect(coreMocks.runPlatformConversation).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(coreMocks.runPlatformConversation).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(conversationModels.get('conv-model-timeout')).toBe('sonnet');
+    expect(coreMocks.runPlatformConversation).toHaveBeenCalledWith(expect.objectContaining({
+      conversationId: 'conv-model-timeout',
+      backend: 'claude',
+      prompt: 'ship it',
+    }));
+  });
+
   it('does not re-block legacy OpenCode models that can be normalized to provider/modelKey', async () => {
     coreMocks.evaluateConversationRunRequest.mockReturnValueOnce({
       kind: 'ready',

packages/feishu/src/config.ts

@@ -16,6 +16,20 @@ function optionalEnv(env: NodeJS.ProcessEnv, key: string): string | undefined {
   return env[key]?.trim() || undefined;
 }
 
+function numberEnv(env: NodeJS.ProcessEnv, key: string, fallback: number): number {
+  const raw = env[key]?.trim();
+  if (!raw) {
+    return fallback;
+  }
+
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid numeric environment variable: ${key}`);
+  }
+
+  return parsed;
+}
+
 function setOptionalEnv(key: string, value: string | undefined): void {
   if (value) {
     process.env[key] = value;
@@ -31,12 +45,19 @@ export interface FeishuConfig extends CoreConfig {
   feishuEncryptKey?: string;
   feishuVerificationToken?: string;
   feishuBaseUrl: string;
+  feishuModelSelectionTimeoutMs: number;
 }
 
 export function resolveFeishuSessionChatStateFile(stateFile: string): string {
   return join(dirname(stateFile), 'feishu-session-chats.json');
 }
 
+export function resolveFeishuModelSelectionTimeoutMs(
+  env: NodeJS.ProcessEnv = process.env,
+): number {
+  return numberEnv(env, 'FEISHU_MODEL_SELECTION_TIMEOUT_MS', 10_000);
+}
+
 export function readFeishuConfig(env: NodeJS.ProcessEnv = process.env): FeishuConfig {
   return {
     ...readCoreConfig(env),
@@ -45,6 +66,7 @@ export function readFeishuConfig(env: NodeJS.ProcessEnv = process.env): FeishuCo
     feishuEncryptKey: optionalEnv(env, 'FEISHU_ENCRYPT_KEY'),
     feishuVerificationToken: optionalEnv(env, 'FEISHU_VERIFICATION_TOKEN'),
     feishuBaseUrl: optionalEnv(env, 'FEISHU_BASE_URL') || 'https://open.feishu.cn',
+    feishuModelSelectionTimeoutMs: resolveFeishuModelSelectionTimeoutMs(env),
   };
 }
 
@@ -55,4 +77,5 @@ export function applyFeishuConfigEnvironment(config: FeishuConfig): void {
   setOptionalEnv('FEISHU_ENCRYPT_KEY', config.feishuEncryptKey);
   setOptionalEnv('FEISHU_VERIFICATION_TOKEN', config.feishuVerificationToken);
   process.env['FEISHU_BASE_URL'] = config.feishuBaseUrl;
+  process.env['FEISHU_MODEL_SELECTION_TIMEOUT_MS'] = String(config.feishuModelSelectionTimeoutMs);
 }