@spaceflow/core 0.1.1

package/src/shared/llm-proxy/adapters/claude-code.adapter.spec.ts

@@ -0,0 +1,131 @@
+import { vi, type Mocked, type Mock } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { ClaudeCodeAdapter } from "./claude-code.adapter";
+import { ClaudeSetupService } from "../../claude-setup";
+import { LlmStreamEvent } from "../interfaces";
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: vi.fn(),
+}));
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+describe("ClaudeAdapter", () => {
+  let adapter: ClaudeCodeAdapter;
+  let claudeSetupService: Mocked<ClaudeSetupService>;
+
+  const mockConfig = {
+    claudeCode: {
+      model: "claude-3-5-sonnet",
+      baseUrl: "https://api.anthropic.com",
+    },
+  };
+
+  beforeEach(async () => {
+    const mockSetup = {
+      configure: vi.fn().mockResolvedValue(undefined),
+      backup: vi.fn().mockResolvedValue(undefined),
+      restore: vi.fn().mockResolvedValue(undefined),
+      withTemporaryConfig: vi.fn(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ClaudeCodeAdapter,
+        { provide: "LLM_PROXY_CONFIG", useValue: mockConfig },
+        { provide: ClaudeSetupService, useValue: mockSetup },
+      ],
+    }).compile();
+
+    adapter = module.get<ClaudeCodeAdapter>(ClaudeCodeAdapter);
+    claudeSetupService = module.get(ClaudeSetupService);
+  });
+
+  it("should be defined", () => {
+    expect(adapter).toBeDefined();
+    expect(adapter.name).toBe("claude-code");
+  });
+
+  describe("isConfigured", () => {
+    it("should return true if claude config exists", () => {
+      expect(adapter.isConfigured()).toBe(true);
+    });
+
+    it("should return false if claude config is missing", async () => {
+      const module: TestingModule = await Test.createTestingModule({
+        providers: [
+          ClaudeCodeAdapter,
+          { provide: "LLM_PROXY_CONFIG", useValue: {} },
+          { provide: ClaudeSetupService, useValue: { configure: vi.fn() } },
+        ],
+      }).compile();
+      const unconfiguredAdapter = module.get<ClaudeCodeAdapter>(ClaudeCodeAdapter);
+      expect(unconfiguredAdapter.isConfigured()).toBe(false);
+    });
+  });
+
+  describe("chatStream", () => {
+    it("should call claudeSetupService.configure and query with correct params", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const mockQueryResponse = (async function* () {
+        yield { type: "assistant", message: { content: "hi" } };
+        yield { type: "result", subtype: "success", response: { content: "hi" } };
+      })();
+      (query as Mock).mockReturnValue(mockQueryResponse);
+
+      const stream = adapter.chatStream(messages);
+      const events: LlmStreamEvent[] = [];
+      for await (const event of stream) {
+        events.push(event);
+      }
+
+      expect(claudeSetupService.configure).toHaveBeenCalled();
+      expect(query).toHaveBeenCalledWith(
+        expect.objectContaining({
+          prompt: "hello",
+          options: expect.objectContaining({
+            model: "claude-3-5-sonnet",
+          }),
+        }),
+      );
+      expect(events).toContainEqual({ type: "text", content: "hi" });
+    });
+
+    it("should handle EPIPE error during stream", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const epipeError = new Error("EPIPE: broken pipe");
+      (epipeError as any).code = "EPIPE";
+
+      (query as Mock).mockImplementation(() => {
+        throw epipeError;
+      });
+
+      const stream = adapter.chatStream(messages);
+      const events: LlmStreamEvent[] = [];
+      for await (const event of stream) {
+        events.push(event);
+      }
+
+      expect(events[0]).toMatchObject({
+        type: "error",
+        message: expect.stringContaining("连接中断 (EPIPE)"),
+      });
+    });
+
+    it("should throw other errors during stream", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const unexpectedError = new Error("Unexpected error");
+
+      (query as Mock).mockImplementation(() => {
+        throw unexpectedError;
+      });
+
+      const stream = adapter.chatStream(messages);
+      await expect(async () => {
+        for await (const _ of stream) {
+          // ignore
+        }
+      }).rejects.toThrow("Unexpected error");
+    });
+  });
+});

package/src/shared/llm-proxy/adapters/claude-code.adapter.ts

@@ -0,0 +1,208 @@
+import { Injectable, Inject } from "@nestjs/common";
+import { query, type SpawnOptions } from "@anthropic-ai/claude-agent-sdk";
+import { spawn } from "child_process";
+import type { LlmAdapter } from "./llm-adapter.interface";
+import type {
+  LlmMessage,
+  LlmRequestOptions,
+  LlmResponse,
+  LlmStreamEvent,
+  LlmProxyConfig,
+} from "../interfaces";
+import { ClaudeSetupService } from "../../claude-setup";
+import { shouldLog } from "../../verbose";
+
+@Injectable()
+export class ClaudeCodeAdapter implements LlmAdapter {
+  readonly name = "claude-code";
+
+  constructor(
+    @Inject("LLM_PROXY_CONFIG") private readonly config: LlmProxyConfig,
+    private readonly claudeSetupService: ClaudeSetupService,
+  ) {}
+
+  isConfigured(): boolean {
+    return !!this.config.claudeCode;
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmRequestOptions): Promise<LlmResponse> {
+    let result: LlmResponse = { content: "" };
+
+    for await (const event of this.chatStream(messages, options)) {
+      if (event.type === "result") {
+        result = event.response;
+      } else if (event.type === "error") {
+        throw new Error(event.message);
+      }
+    }
+
+    return result;
+  }
+
+  async *chatStream(
+    messages: LlmMessage[],
+    options?: LlmRequestOptions,
+  ): AsyncIterable<LlmStreamEvent> {
+    // 备份原有配置
+    await this.claudeSetupService.backup();
+
+    try {
+      // 应用临时配置
+      await this.claudeSetupService.configure(options?.verbose);
+
+      const claudeConf = this.config.claudeCode;
+
+      if (!claudeConf) {
+        yield {
+          type: "error",
+          message: "[LLMProxy.ClaudeCodeAdapter.chatStream] 未配置 claude 设置",
+        };
+        return;
+      }
+
+      const model = options?.model || claudeConf.model || "claude-sonnet-4-5";
+      const systemPrompt = this.extractSystemPrompt(messages);
+      const userPrompt = this.extractUserPrompt(messages);
+
+      if (shouldLog(options?.verbose, 1)) {
+        console.log(
+          `[LLMProxy.ClaudeCodeAdapter.chatStream] 配置: Model=${model}, BaseURL=${claudeConf.baseUrl || "(默认)"}`,
+        );
+      }
+
+      const handleUncaughtError = (err: Error) => {
+        if ((err as any).code === "EPIPE") {
+          console.error(
+            "[LLMProxy.ClaudeCodeAdapter.chatStream] EPIPE 错误: Claude CLI 子进程意外退出",
+          );
+          throw err;
+        }
+      };
+      process.on("uncaughtException", handleUncaughtError);
+
+      try {
+        const spawnEnv = { ...process.env };
+        if (claudeConf.baseUrl) spawnEnv.ANTHROPIC_BASE_URL = claudeConf.baseUrl;
+        if (claudeConf.authToken) spawnEnv.ANTHROPIC_AUTH_TOKEN = claudeConf.authToken;
+
+        const spawnClaudeCodeProcess = (spawnOptions: SpawnOptions) => {
+          if (shouldLog(options?.verbose, 2)) {
+            console.log(
+              `[LLMProxy.ClaudeCodeAdapter.chatStream] Spawning: ${spawnOptions.command} ${spawnOptions.args?.join(" ")}`,
+            );
+          }
+          const child = spawn(spawnOptions.command, spawnOptions.args || [], {
+            ...spawnOptions,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: spawnEnv,
+          });
+
+          child.stderr?.on("data", (data) => {
+            console.error(`[LLMProxy.ClaudeCodeAdapter.chatStream] CLI stderr: ${data.toString()}`);
+          });
+
+          return child;
+        };
+
+        const queryOptions: Parameters<typeof query>[0]["options"] = {
+          model,
+          systemPrompt,
+          permissionMode: "default",
+          spawnClaudeCodeProcess,
+        };
+
+        if (options?.allowedTools?.length) {
+          queryOptions.allowedTools = options.allowedTools as any;
+        }
+
+        if (options?.jsonSchema) {
+          queryOptions.outputFormat = {
+            type: "json_schema",
+            schema: options.jsonSchema.getSchema(),
+          };
+        }
+
+        const response = query({
+          prompt: userPrompt,
+          options: queryOptions,
+        });
+
+        let finalContent = "";
+        let structuredOutput: unknown = undefined;
+
+        for await (const message of response) {
+          if (message.type === "assistant") {
+            const content = message.message.content;
+            if (typeof content === "string") {
+              yield { type: "text", content };
+              finalContent += content;
+            } else if (Array.isArray(content)) {
+              for (const block of content) {
+                if (block.type === "text") {
+                  yield { type: "text", content: block.text };
+                  finalContent += block.text;
+                } else if (block.type === "tool_use") {
+                  yield { type: "tool_use", name: block.name, input: block.input };
+                } else if (block.type === ("thought" as any)) {
+                  yield { type: "thought", content: (block as any).thought };
+                }
+              }
+            }
+          }
+
+          if (message.type === "result") {
+            if (message.subtype === "success") {
+              if (message.structured_output) {
+                structuredOutput = message.structured_output;
+              }
+              yield {
+                type: "result",
+                response: {
+                  content: finalContent,
+                  structuredOutput,
+                },
+              };
+            } else {
+              yield {
+                type: "error",
+                message: `[LLMProxy.ClaudeCodeAdapter.chatStream] ${message.errors?.join(", ") || "未知错误"}`,
+              };
+            }
+          }
+        }
+      } catch (error: any) {
+        if (error?.code === "EPIPE" || error?.message?.includes("EPIPE")) {
+          yield {
+            type: "error",
+            message:
+              "[LLMProxy.ClaudeCodeAdapter.chatStream] 连接中断 (EPIPE)。请检查：\n" +
+              "1. ANTHROPIC_AUTH_TOKEN 环境变量是否正确设置\n" +
+              "2. ANTHROPIC_BASE_URL 是否与 Claude Agent SDK 兼容\n" +
+              "3. Claude CLI 是否已正确安装",
+          };
+        } else {
+          throw error;
+        }
+      } finally {
+        process.removeListener("uncaughtException", handleUncaughtError);
+      }
+    } finally {
+      // 恢复原有配置
+      await this.claudeSetupService.restore();
+    }
+  }
+
+  private extractSystemPrompt(messages: LlmMessage[]): string {
+    const systemMessage = messages.find((m) => m.role === "system");
+    return systemMessage?.content || "";
+  }
+
+  private extractUserPrompt(messages: LlmMessage[]): string {
+    const userMessages = messages.filter((m) => m.role === "user");
+    return userMessages.map((m) => m.content).join("\n\n");
+  }
+
+  isSupportJsonSchema(): boolean {
+    return true;
+  }
+}

package/src/shared/llm-proxy/adapters/index.ts

@@ -0,0 +1,4 @@
+export * from "./llm-adapter.interface";
+export * from "./claude-code.adapter";
+export * from "./openai.adapter";
+export * from "./open-code.adapter";

package/src/shared/llm-proxy/adapters/llm-adapter.interface.ts

@@ -0,0 +1,23 @@
+import type { LlmMessage, LlmRequestOptions, LlmResponse, LlmStreamEvent } from "../interfaces";
+import type { VerboseLevel } from "../../verbose";
+
+export interface LlmAdapterConfig {
+  model?: string;
+  baseUrl?: string;
+  apiKey?: string;
+  verbose?: VerboseLevel;
+}
+
+export interface LlmAdapter {
+  readonly name: string;
+
+  chat(messages: LlmMessage[], options?: LlmRequestOptions): Promise<LlmResponse>;
+
+  chatStream(messages: LlmMessage[], options?: LlmRequestOptions): AsyncIterable<LlmStreamEvent>;
+
+  isConfigured(): boolean;
+
+  isSupportJsonSchema(): boolean;
+}
+
+export const LLM_ADAPTER = Symbol("LLM_ADAPTER");

package/src/shared/llm-proxy/adapters/open-code.adapter.ts

@@ -0,0 +1,342 @@
+import { Injectable, Inject } from "@nestjs/common";
+import { createOpencode } from "@opencode-ai/sdk";
+import type { LlmAdapter } from "./llm-adapter.interface";
+import type {
+  LlmMessage,
+  LlmRequestOptions,
+  LlmResponse,
+  LlmStreamEvent,
+  LlmProxyConfig,
+  OpenCodeAdapterConfig,
+} from "../interfaces";
+import { shouldLog } from "../../verbose";
+
+@Injectable()
+export class OpenCodeAdapter implements LlmAdapter {
+  readonly name = "open-code";
+
+  constructor(@Inject("LLM_PROXY_CONFIG") private readonly config: LlmProxyConfig) {}
+
+  isConfigured(): boolean {
+    return !!this.config.openCode;
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmRequestOptions): Promise<LlmResponse> {
+    let result: LlmResponse = { content: "" };
+
+    for await (const event of this.chatStream(messages, options)) {
+      if (event.type === "result") {
+        result = event.response;
+      } else if (event.type === "error") {
+        throw new Error(event.message);
+      }
+    }
+
+    return result;
+  }
+
+  async *chatStream(
+    messages: LlmMessage[],
+    options?: LlmRequestOptions,
+  ): AsyncIterable<LlmStreamEvent> {
+    const openCodeConf = this.config.openCode;
+
+    if (!openCodeConf) {
+      yield {
+        type: "error",
+        message: "[LLMProxy.OpenCodeAdapter.chatStream] 未配置 openCode 设置",
+      };
+      return;
+    }
+
+    const providerID = openCodeConf.providerID || "openai";
+    const configModel = options?.model || openCodeConf.model || "gpt-4o";
+    const model = configModel.includes("/") ? configModel : `${providerID}/${configModel}`;
+
+    if (shouldLog(options?.verbose, 1)) {
+      console.log(
+        `[LLMProxy.OpenCodeAdapter.chatStream] 配置: Model=${model}, ProviderID=${providerID}, BaseURL=${openCodeConf.baseUrl || "默认"}`,
+      );
+    }
+
+    // 创建 OpenCode 实例（自动启动服务器，使用动态端口避免冲突）
+    let opencode: Awaited<ReturnType<typeof createOpencode>> | null = null;
+    const port = 4096 + Math.floor(Math.random() * 1000);
+
+    // 确保进程退出时关闭服务器
+    const cleanup = () => {
+      if (opencode?.server) {
+        opencode.server.close();
+        opencode = null;
+      }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+
+    try {
+      opencode = await createOpencode({
+        port,
+        config: this.buildOpenCodeConfig(openCodeConf, model),
+      });
+
+      const { client } = opencode;
+
+      // 设置 provider 认证（使用自定义 provider ID）
+      const customProviderID = "custom-openai";
+      if (openCodeConf.apiKey) {
+        await client.auth.set({
+          path: { id: customProviderID },
+          body: { type: "api", key: openCodeConf.apiKey },
+        });
+      }
+
+      const session = await client.session.create({
+        body: { title: `spaceflow-${Date.now()}` },
+      });
+
+      if (!session.data?.id) {
+        yield {
+          type: "error",
+          message: "[LLMProxy.OpenCodeAdapter.chatStream] 创建 session 失败",
+        };
+        return;
+      }
+
+      const sessionId = session.data.id;
+      const systemPrompt = this.extractSystemPrompt(messages);
+      const userPrompt = this.extractUserPrompt(messages);
+
+      if (systemPrompt) {
+        await client.session.prompt({
+          path: { id: sessionId },
+          body: {
+            noReply: true,
+            parts: [{ type: "text", text: systemPrompt }],
+          },
+        });
+      }
+
+      // 从原始 model 中提取 modelID，但使用自定义 provider ID
+      const [, modelID] = model.includes("/") ? model.split("/", 2) : [customProviderID, model];
+
+      if (shouldLog(options?.verbose, 2)) {
+        console.log(
+          `[LLMProxy.OpenCodeAdapter.chatStream] 发送 prompt: model=${customProviderID}/${modelID}, userPrompt长度=${userPrompt.length}`,
+        );
+      }
+
+      const result = await client.session.prompt({
+        path: { id: sessionId },
+        body: {
+          model: { providerID: customProviderID, modelID },
+          parts: [{ type: "text", text: userPrompt }],
+        },
+      });
+
+      if (shouldLog(options?.verbose, 2)) {
+        console.log(
+          `[LLMProxy.OpenCodeAdapter.chatStream] 完整响应对象:\n${JSON.stringify(result, null, 2)}`,
+        );
+        console.log(
+          `[LLMProxy.OpenCodeAdapter.chatStream] result.data:\n${JSON.stringify(result.data, null, 2)}`,
+        );
+      }
+
+      let finalContent = "";
+
+      if (result.data?.parts) {
+        for (const part of result.data.parts) {
+          const partType = part.type;
+
+          switch (partType) {
+            case "text": {
+              const text = (part as any).text || "";
+              yield { type: "text", content: text };
+              finalContent += text;
+              break;
+            }
+
+            case "tool": {
+              // 工具调用（ToolPart）
+              const toolPart = part as any;
+              const state = toolPart.state || {};
+              yield {
+                type: "tool_use",
+                name: toolPart.tool || "unknown",
+                input: state.input || {},
+                status: state.status,
+                output: state.output,
+                title: state.title,
+              };
+              break;
+            }
+
+            case "agent": {
+              // 子代理调用（AgentPart）
+              const agentPart = part as any;
+              yield {
+                type: "agent",
+                name: agentPart.name || "unknown",
+                source: agentPart.source?.value,
+              };
+              break;
+            }
+
+            case "subtask": {
+              // 子任务
+              const subtaskPart = part as any;
+              yield {
+                type: "subtask",
+                agent: subtaskPart.agent,
+                prompt: subtaskPart.prompt,
+                description: subtaskPart.description,
+              };
+              break;
+            }
+
+            case "step-start": {
+              yield {
+                type: "step_start",
+                snapshot: (part as any).snapshot,
+              };
+              break;
+            }
+
+            case "step-finish": {
+              const stepPart = part as any;
+              yield {
+                type: "step_finish",
+                reason: stepPart.reason,
+                tokens: stepPart.tokens,
+                cost: stepPart.cost,
+              };
+              break;
+            }
+
+            case "reasoning": {
+              const reasoningPart = part as any;
+              yield {
+                type: "reasoning",
+                content: reasoningPart.text || "",
+              };
+              break;
+            }
+
+            default:
+              // 其他类型（file, snapshot, patch, retry, compaction 等）暂不处理
+              if (shouldLog(options?.verbose, 2)) {
+                console.log(
+                  `[LLMProxy.OpenCodeAdapter.chatStream] 未处理的 part 类型: ${partType}`,
+                );
+              }
+              break;
+          }
+        }
+      }
+
+      if (shouldLog(options?.verbose, 1) && !finalContent) {
+        console.warn(
+          `[LLMProxy.OpenCodeAdapter.chatStream] 警告: 响应内容为空，parts=${JSON.stringify(result.data?.parts)}`,
+        );
+      }
+
+      yield {
+        type: "result",
+        response: {
+          content: finalContent,
+        },
+      };
+
+      try {
+        await client.session.delete({ path: { id: sessionId } });
+      } catch {
+        // ignore cleanup errors
+      }
+    } catch (error: any) {
+      yield {
+        type: "error",
+        message:
+          `[LLMProxy.OpenCodeAdapter.chatStream] 错误: ${error.message}\n` +
+          `请检查：\n` +
+          `1. baseUrl 配置是否正确\n` +
+          `2. apiKey 是否有效\n` +
+          `3. 模型配置是否有效`,
+      };
+    } finally {
+      // 移除事件监听器
+      process.removeListener("exit", cleanup);
+      process.removeListener("SIGINT", cleanup);
+      process.removeListener("SIGTERM", cleanup);
+      // 关闭服务器
+      cleanup();
+    }
+  }
+
+  /**
+   * 构建 OpenCode 配置
+   */
+  private buildOpenCodeConfig(
+    openCodeConf: OpenCodeAdapterConfig,
+    model: string,
+  ): Record<string, any> {
+    // 使用自定义 provider ID（如 custom-openai）而不是 openai
+    // 因为 OpenCode 会根据 providerID 决定使用哪个 SDK 方法
+    // openai provider 会调用 sdk.responses()，而自定义 provider 使用 @ai-sdk/openai-compatible
+    const customProviderID = "custom-openai";
+    const [, modelID] = model.includes("/") ? model.split("/", 2) : [customProviderID, model];
+
+    // 使用 @ai-sdk/openai-compatible，使用 Chat Completions API (/chat/completions)
+    const config: Record<string, any> = {
+      model: `${customProviderID}/${modelID}`,
+      provider: {
+        [customProviderID]: {
+          npm: "@ai-sdk/openai-compatible",
+          name: "Custom OpenAI Compatible",
+        },
+      },
+    };
+
+    // 配置 provider baseURL
+    if (openCodeConf.baseUrl) {
+      config.provider[customProviderID].options = {
+        baseURL: openCodeConf.baseUrl,
+      };
+    }
+
+    // 注册自定义模型
+    config.provider[customProviderID].models = {
+      [modelID]: {
+        name: modelID,
+        attachment: true,
+        reasoning: false,
+        temperature: true,
+        tool_call: true,
+        cost: {
+          input: 0,
+          output: 0,
+        },
+        limit: {
+          context: 128000,
+          output: 16000,
+        },
+      },
+    };
+
+    return config;
+  }
+
+  private extractSystemPrompt(messages: LlmMessage[]): string {
+    const systemMessage = messages.find((m) => m.role === "system");
+    return systemMessage?.content || "";
+  }
+
+  private extractUserPrompt(messages: LlmMessage[]): string {
+    const userMessages = messages.filter((m) => m.role === "user");
+    return userMessages.map((m) => m.content).join("\n\n");
+  }
+
+  isSupportJsonSchema(): boolean {
+    return false;
+  }
+}