fix typecheck failed

Author: phantom5099

packages/codingcode/src/client/http.ts

@@ -4,7 +4,13 @@ import { createHttpClients } from './http/index.js';
 
 export type { AgentClient, StreamChunk } from './types.js';
 export { createHttpClients } from './http/index.js';
-export type { HttpClients, AgentRuntimeClient, SessionClient, ModelClient, SettingsClient } from './http/index.js';
+export type {
+  HttpClients,
+  AgentRuntimeClient,
+  SessionClient,
+  ModelClient,
+  SettingsClient,
+} from './http/index.js';
 
 export async function createHttpClient(serverUrl: string): Promise<AgentClient> {
   let currentSessionId: string | undefined;

packages/codingcode/src/memory/storage.ts

@@ -69,7 +69,7 @@ export function enforceMaxBytes(content: string, maxBytes: number): string {
   }
 
   const sections = content.split(/^### /m).filter(Boolean);
-    const namedSections = sections.map((s) => {
+  const namedSections = sections.map((s) => {
     const lines = s.split('\n');
     const name = lines[0]!;
     const body = lines.slice(1).join('\n');

packages/codingcode/test/agent/agent-concurrent.test.ts

@@ -127,18 +127,18 @@ describe('runReActLoop 锟?concurrent tool execution', () => {
           toolCalls,
           (tc: any) =>
             mockExecutor.execute(tc.name, tc.arguments ?? {}).pipe(
-              Effect.matchEffect({
-                onSuccess: (output) =>
+              (Effect.matchEffect as any)({
+                onSuccess: (output: any) =>
                   Effect.succeed({ type: 'ok' as const, id: tc.id, name: tc.name, output }),
-                onFailure: (err) =>
+                onFailure: (err: any) =>
                   Effect.succeed({
                     type: 'error' as const,
                     id: tc.id,
                     name: tc.name,
                     output: String(err),
                   }),
               }),
-              Effect.catchAllDefect((defect) =>
+              (Effect.catchAllDefect as any)((defect: any) =>
                 Effect.succeed({
                   type: 'error' as const,
                   id: tc.id,
@@ -196,18 +196,18 @@ describe('runReActLoop 锟?concurrent tool execution', () => {
           toolCalls,
           (tc: any) =>
             mockExecutor.execute(tc.name, tc.arguments ?? {}).pipe(
-              Effect.matchEffect({
-                onSuccess: (output) =>
+              (Effect.matchEffect as any)({
+                onSuccess: (output: any) =>
                   Effect.succeed({ type: 'ok' as const, id: tc.id, name: tc.name, output }),
-                onFailure: (err) =>
+                onFailure: (err: any) =>
                   Effect.succeed({
                     type: 'error' as const,
                     id: tc.id,
                     name: tc.name,
                     output: String(err),
                   }),
               }),
-              Effect.catchAllDefect((defect) =>
+              (Effect.catchAllDefect as any)((defect: any) =>
                 Effect.succeed({
                   type: 'error' as const,
                   id: tc.id,

packages/codingcode/test/context/context.test.ts

@@ -24,15 +24,27 @@ const mockState = {
 };
 
 const mockLlm = {
-  modelInfo: { maxTokens: 1000, model: 'test-model' },
-  complete: () => Promise.resolve(Result.ok({ content: 'Hello world', finishReason: 'stop' })),
+  modelInfo: {
+    provider: 'mock',
+    model: 'test-model',
+    maxTokens: 1000,
+    supportsToolCalling: true,
+    supportsStreaming: true,
+  },
+  complete: () =>
+    Promise.resolve(Result.ok({ content: 'Hello world', finishReason: 'stop' as const })),
   completeStream: (_params: any) => {
     const stream = (async function* () {
       yield 'Hello';
       yield ' ';
       yield 'world';
     })();
-    return { stream, response: Promise.resolve(Result.ok({ content: 'Hello world', finishReason: 'stop' })) };
+    return {
+      stream,
+      response: Promise.resolve(
+        Result.ok({ content: 'Hello world', finishReason: 'stop' as const })
+      ),
+    };
   },
 };
 
@@ -122,9 +134,9 @@ function makeMockSessionLayer(state: any) {
       getSessionId: () => state.sessionId,
       getMessageCount: () => 0,
       incrementTurn: () => 0,
-    findSessionIndex: () => Effect.succeed(null),
-  } as any)
-);
+      findSessionIndex: () => Effect.succeed(null),
+    } as any)
+  );
 }
 
 describe('ContextService', () => {

packages/codingcode/test/context/organizer.test.ts

@@ -267,7 +267,7 @@ describe('pruneByTokens', () => {
     ];
     const result = pruneByTokens(events, baseConfig, 100);
     // Summary should remain
-    expect(result[0].type).toBe('summary');
+    expect(result[0]!.type).toBe('summary');
     expect((result[0] as any).summaryText).toBe('Summary text');
     // Oldest tool results cleared
     expect((result[3] as ToolResultEvent).output).toBe('[Old tool result content cleared]');

packages/codingcode/test/hooks/config.test.ts

@@ -44,9 +44,9 @@ describe('writeHookConfigs', () => {
     ]);
     const result = loadHookConfigs(testDir);
     expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('test-hook');
-    expect(result[0].point).toBe('session.save.before');
-    expect(result[0].type).toBe('observer');
+    expect(result[0]!.name).toBe('test-hook');
+    expect(result[0]!.point).toBe('session.save.before');
+    expect(result[0]!.type).toBe('observer');
   });
 
   it('should overwrite existing hooks', () => {
@@ -58,8 +58,8 @@ describe('writeHookConfigs', () => {
     ]);
     const result = loadHookConfigs(testDir);
     expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('new');
-    expect(result[0].enabled).toBe(false);
+    expect(result[0]!.name).toBe('new');
+    expect(result[0]!.enabled).toBe(false);
   });
 
   it('should preserve other top-level keys', () => {

packages/codingcode/test/mcp/config.test.ts

@@ -37,9 +37,9 @@ describe('loadMcpConfig', () => {
 
     const configs = loadMcpConfig(join(__dirname, '..', '..', '..'));
     expect(configs).toHaveLength(1);
-    expect(configs[0].name).toBe('test-stdio');
-    expect(configs[0].command).toBe('npx');
-    expect(configs[0].args).toEqual(['-y', 'test-server']);
+    expect(configs[0]!.name).toBe('test-stdio');
+    expect(configs[0]!.command).toBe('npx');
+    expect(configs[0]!.args).toEqual(['-y', 'test-server']);
   });
 
   it('should load SSE server config from mcp.yaml', () => {
@@ -56,9 +56,9 @@ describe('loadMcpConfig', () => {
 
     const configs = loadMcpConfig(join(__dirname, '..', '..', '..'));
     expect(configs).toHaveLength(1);
-    expect(configs[0].name).toBe('test-sse');
-    expect(configs[0].url).toBe('https://mcp.example.com/sse');
-    expect(configs[0].concurrency).toBe(5);
+    expect(configs[0]!.name).toBe('test-sse');
+    expect(configs[0]!.url).toBe('https://mcp.example.com/sse');
+    expect(configs[0]!.concurrency).toBe(5);
   });
 
   it('should resolve ${ENV_VAR} placeholders', () => {
@@ -74,7 +74,7 @@ describe('loadMcpConfig', () => {
     );
 
     const configs = loadMcpConfig(join(__dirname, '..', '..', '..'));
-    expect(configs[0].headers!.Authorization).toBe('Bearer resolved-token');
+    expect(configs[0]!.headers!.Authorization).toBe('Bearer resolved-token');
 
     delete process.env.TEST_TOKEN;
   });
@@ -91,7 +91,7 @@ describe('loadMcpConfig', () => {
     );
 
     const configs = loadMcpConfig(join(__dirname, '..', '..', '..'));
-    expect(configs[0].headers!.Authorization).toBeUndefined();
+    expect(configs[0]!.headers!.Authorization).toBeUndefined();
   });
 });
 
@@ -113,8 +113,8 @@ describe('writeMcpConfig', () => {
     writeMcpConfig(projectRoot, servers);
     const result = loadMcpConfig(projectRoot);
     expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('test-server');
-    expect(result[0].concurrency).toBe(5);
+    expect(result[0]!.name).toBe('test-server');
+    expect(result[0]!.concurrency).toBe(5);
   });
 
   it('should overwrite existing servers list', () => {
@@ -123,7 +123,7 @@ describe('writeMcpConfig', () => {
     writeMcpConfig(projectRoot, [{ name: 'new', command: 'ls' }]);
     const result = loadMcpConfig(projectRoot);
     expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('new');
+    expect(result[0]!.name).toBe('new');
   });
 
   it('should preserve other top-level keys in the yaml', () => {

packages/codingcode/test/memory/config.test.ts

@@ -101,7 +101,7 @@ describe('Memory Config', () => {
 
       const types = getEffectiveTypes(cfg);
       expect(types).toHaveLength(1);
-      expect(types[0].name).toBe('reference');
+      expect(types[0]!.name).toBe('reference');
     });
 
     it('filters disabled extra types', () => {

packages/codingcode/test/memory/extractor.test.ts

@@ -5,15 +5,28 @@ import type { MemoryTypeConfig } from '@codingcode/infra';
 
 describe('Memory Extractor', () => {
   const createMockLlm = (response: string) => ({
+    complete: vi.fn(() =>
+      Promise.resolve({
+        ok: true as const,
+        value: { content: response, finishReason: 'stop' as const },
+      })
+    ),
     completeStream: vi.fn(() => ({
       stream: (async function* () {
         yield response;
       })(),
       response: Promise.resolve({
-        ok: true,
-        value: { content: response },
+        ok: true as const,
+        value: { content: response, finishReason: 'stop' as const },
       }),
     })),
+    modelInfo: {
+      provider: 'mock',
+      model: 'mock',
+      maxTokens: 4096,
+      supportsToolCalling: true,
+      supportsStreaming: true,
+    },
   });
 
   const defaultTypes: MemoryTypeConfig[] = [
@@ -83,6 +96,12 @@ describe('Memory Extractor', () => {
 
   it('handles LLM call failure gracefully', async () => {
     const llm = {
+      complete: vi.fn(() =>
+        Promise.resolve({
+          ok: false,
+          value: { content: '' },
+        } as any)
+      ),
       completeStream: vi.fn(() => ({
         stream: (async function* () {
           throw new Error('Stream error');
@@ -92,6 +111,13 @@ describe('Memory Extractor', () => {
           value: { content: '' },
         } as any),
       })),
+      modelInfo: {
+        provider: 'mock',
+        model: 'mock',
+        maxTokens: 4096,
+        supportsToolCalling: true,
+        supportsStreaming: true,
+      },
     };
 
     const transcript: StructuredTranscript = {
@@ -129,7 +155,7 @@ describe('Memory Extractor', () => {
       llm: mockLlm,
     });
 
-    const callArgs = mockLlm.completeStream.mock.calls[0][0];
+    const callArgs = (mockLlm.completeStream.mock.calls as any)[0][0] as any;
     expect(callArgs.messages[0].content).toContain('已有记忆');
     expect(callArgs.messages[0].content).toContain('Old info');
   });
@@ -150,7 +176,7 @@ describe('Memory Extractor', () => {
       llm: mockLlm,
     });
 
-    const callArgs = mockLlm.completeStream.mock.calls[0][0];
+    const callArgs = (mockLlm.completeStream.mock.calls as any)[0][0] as any;
     expect(callArgs.messages[0].content).toContain('[user]');
     expect(callArgs.messages[0].content).toContain('[user+assistant]');
     expect(callArgs.messages[0].content).toContain('[user+tool]');
@@ -173,7 +199,7 @@ describe('Memory Extractor', () => {
       llm: mockLlm,
     });
 
-    const callArgs = mockLlm.completeStream.mock.calls[0][0];
+    const callArgs = (mockLlm.completeStream.mock.calls as any)[0][0] as any;
     // Should not mention reference guidance
     expect(callArgs.system).not.toContain('reference');
   });
@@ -194,7 +220,7 @@ describe('Memory Extractor', () => {
       llm: mockLlm,
     });
 
-    const callArgs = mockLlm.completeStream.mock.calls[0][0];
+    const callArgs = (mockLlm.completeStream.mock.calls as any)[0][0] as any;
     expect(callArgs.messages).toHaveLength(1);
     expect(callArgs.messages[0].role).toBe('user');
     expect(callArgs.messages[0].content).toBeTruthy();
@@ -216,7 +242,7 @@ describe('Memory Extractor', () => {
       llm: mockLlm,
     });
 
-    const callArgs = mockLlm.completeStream.mock.calls[0][0];
+    const callArgs = (mockLlm.completeStream.mock.calls as any)[0][0] as any;
     // system contains instructions, not transcript data
     expect(callArgs.system).toContain('规则');
     expect(callArgs.system).toContain('记忆类型');

packages/codingcode/test/memory/llm-resolver.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { resolveMemoryLLM } from '../../src/memory/llm-resolver.js';
+import type { LLMClient } from '../../src/llm/client.js';
 import type { MemoryConfig } from '@codingcode/infra';
 
 vi.mock('../../src/llm/factory.js', () => ({
@@ -20,13 +21,21 @@ vi.mock('../../src/llm/factory.js', () => ({
       },
     ],
   })),
-  createClient: vi.fn(async (modelInfo: any) => ({
+  createClient: vi.fn(async (_modelInfo: any) => ({
     ok: true,
     value: {
+      complete: () => Promise.resolve({ ok: true, value: { content: '' } }),
       completeStream: () => ({
         stream: async function* () {},
         response: Promise.resolve({ ok: true, value: { content: '' } }),
       }),
+      modelInfo: {
+        provider: 'mock',
+        model: 'mock',
+        maxTokens: 4096,
+        supportsToolCalling: true,
+        supportsStreaming: true,
+      },
     } as any,
   })),
 }));
@@ -49,7 +58,7 @@ describe('Memory LLM Resolver', () => {
 
   it('returns fallback when model is empty', async () => {
     const cfg = createCfg('');
-    const fallback = {} as LLMStreamAdapter;
+    const fallback = {} as LLMClient;
     const result = await resolveMemoryLLM(cfg, fallback);
     expect(result).toBe(fallback);
   });
@@ -59,14 +68,14 @@ describe('Memory LLM Resolver', () => {
     vi.mocked(listModels).mockReturnValue({ ok: false, error: 'error' } as any);
 
     const cfg = createCfg('claude-opus-4-7');
-    const fallback = {} as LLMStreamAdapter;
+    const fallback = {} as LLMClient;
     const result = await resolveMemoryLLM(cfg, fallback);
     expect(result).toBe(fallback);
   });
 
   it('returns fallback when model not found', async () => {
     const cfg = createCfg('nonexistent-model');
-    const fallback = {} as LLMStreamAdapter;
+    const fallback = {} as LLMClient;
     const result = await resolveMemoryLLM(cfg, fallback);
     expect(result).toBe(fallback);
   });
@@ -91,14 +100,14 @@ describe('Memory LLM Resolver', () => {
 
   it('creates and returns client when model matches by id', async () => {
     const cfg = createCfg('claude-opus-4-7');
-    const fallback = {} as any;
+    const fallback = {} as LLMClient;
     const result = await resolveMemoryLLM(cfg, fallback);
     expect(result).not.toBe(fallback);
   });
 
   it('creates and returns client when model matches by bare id', async () => {
     const cfg = createCfg('deepseek-chat');
-    const fallback = {} as any;
+    const fallback = {} as LLMClient;
     const result = await resolveMemoryLLM(cfg, fallback);
     expect(result).not.toBe(fallback);
   });