@spaceflow/core 0.1.1

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

@@ -0,0 +1,215 @@
+import { vi, type Mock } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { OpenAIAdapter } from "./openai.adapter";
+import OpenAI from "openai";
+
+vi.mock("openai");
+
+describe("OpenAIAdapter", () => {
+  let adapter: OpenAIAdapter;
+  let mockOpenAIInstance: any;
+
+  const mockConfig = {
+    openai: {
+      apiKey: "test-key",
+      model: "gpt-4o",
+      baseUrl: "https://api.openai.com/v1",
+    },
+  };
+
+  beforeEach(async () => {
+    mockOpenAIInstance = {
+      chat: {
+        completions: {
+          create: vi.fn(),
+        },
+      },
+    };
+    (OpenAI as unknown as Mock).mockImplementation(function () {
+      return mockOpenAIInstance;
+    });
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [OpenAIAdapter, { provide: "LLM_PROXY_CONFIG", useValue: mockConfig }],
+    }).compile();
+
+    adapter = module.get<OpenAIAdapter>(OpenAIAdapter);
+  });
+
+  it("should be defined", () => {
+    expect(adapter).toBeDefined();
+    expect(adapter.name).toBe("openai");
+  });
+
+  describe("isConfigured", () => {
+    it("should return true if openai config exists", () => {
+      expect(adapter.isConfigured()).toBe(true);
+    });
+
+    it("should return false if openai config is missing", async () => {
+      const module: TestingModule = await Test.createTestingModule({
+        providers: [OpenAIAdapter, { provide: "LLM_PROXY_CONFIG", useValue: {} }],
+      }).compile();
+      const unconfiguredAdapter = module.get<OpenAIAdapter>(OpenAIAdapter);
+      expect(unconfiguredAdapter.isConfigured()).toBe(false);
+    });
+  });
+
+  describe("chat", () => {
+    it("should call openai.chat.completions.create with correct params", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const mockResponse = {
+        choices: [{ message: { content: "hi" } }],
+        model: "gpt-4o",
+        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+      };
+      mockOpenAIInstance.chat.completions.create.mockResolvedValue(mockResponse);
+
+      const result = await adapter.chat(messages);
+
+      expect(mockOpenAIInstance.chat.completions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: "gpt-4o",
+          messages: [{ role: "user", content: "hello" }],
+        }),
+      );
+      expect(result.content).toBe("hi");
+      expect(result.usage?.totalTokens).toBe(15);
+    });
+
+    it("should handle API error", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const apiError = new Error("API Error");
+      (apiError as any).status = 401;
+      Object.setPrototypeOf(apiError, OpenAI.APIError.prototype);
+      mockOpenAIInstance.chat.completions.create.mockRejectedValue(apiError);
+
+      await expect(adapter.chat(messages)).rejects.toThrow("API 错误 (401)");
+    });
+  });
+
+  describe("chatStream", () => {
+    it("should handle streaming response", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const mockStream = (async function* () {
+        yield { choices: [{ delta: { content: "h" } }] };
+        yield { choices: [{ delta: { content: "i" } }] };
+      })();
+      mockOpenAIInstance.chat.completions.create.mockResolvedValue(mockStream);
+
+      const stream = adapter.chatStream(messages);
+      const events: any[] = [];
+      for await (const event of stream) {
+        events.push(event);
+      }
+
+      expect(events).toContainEqual({ type: "text", content: "h" });
+      expect(events).toContainEqual({ type: "text", content: "i" });
+      expect(events).toContainEqual({ type: "result", response: { content: "hi" } });
+    });
+
+    it("should handle stream API error", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const apiError = new Error("Stream Error");
+      (apiError as any).status = 500;
+      Object.setPrototypeOf(apiError, OpenAI.APIError.prototype);
+      mockOpenAIInstance.chat.completions.create.mockRejectedValue(apiError);
+
+      const stream = adapter.chatStream(messages);
+      const events: any[] = [];
+      for await (const event of stream) {
+        events.push(event);
+      }
+
+      expect(events[0]).toMatchObject({
+        type: "error",
+        message: expect.stringContaining("API 错误 (500)"),
+      });
+    });
+
+    it("should throw non-API errors in chatStream", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      mockOpenAIInstance.chat.completions.create.mockRejectedValue(new Error("network"));
+
+      const stream = adapter.chatStream(messages);
+      await expect(async () => {
+        for await (const _ of stream) {
+          /* consume */
+        }
+      }).rejects.toThrow("network");
+    });
+
+    it("should handle chunk with empty delta", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      const mockStream = (async function* () {
+        yield { choices: [{ delta: {} }] };
+        yield { choices: [{ delta: { content: "ok" } }] };
+      })();
+      mockOpenAIInstance.chat.completions.create.mockResolvedValue(mockStream);
+
+      const events: any[] = [];
+      for await (const event of adapter.chatStream(messages)) {
+        events.push(event);
+      }
+      expect(events).toContainEqual({ type: "text", content: "ok" });
+      expect(events).toContainEqual({ type: "result", response: { content: "ok" } });
+    });
+
+    it("should yield error when openai not configured", async () => {
+      const module: TestingModule = await Test.createTestingModule({
+        providers: [OpenAIAdapter, { provide: "LLM_PROXY_CONFIG", useValue: {} }],
+      }).compile();
+      const unconfigured = module.get<OpenAIAdapter>(OpenAIAdapter);
+      const events: any[] = [];
+      for await (const event of unconfigured.chatStream([{ role: "user", content: "hi" }] as any)) {
+        events.push(event);
+      }
+      expect(events[0]).toMatchObject({ type: "error" });
+    });
+  });
+
+  describe("chat edge cases", () => {
+    it("should throw non-API errors in chat", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      mockOpenAIInstance.chat.completions.create.mockRejectedValue(new Error("timeout"));
+      await expect(adapter.chat(messages)).rejects.toThrow("timeout");
+    });
+
+    it("should throw when openai not configured for chat", async () => {
+      const module: TestingModule = await Test.createTestingModule({
+        providers: [OpenAIAdapter, { provide: "LLM_PROXY_CONFIG", useValue: {} }],
+      }).compile();
+      const unconfigured = module.get<OpenAIAdapter>(OpenAIAdapter);
+      await expect(unconfigured.chat([{ role: "user", content: "hi" }] as any)).rejects.toThrow(
+        "未配置 openai",
+      );
+    });
+
+    it("should return empty content when choices empty", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      mockOpenAIInstance.chat.completions.create.mockResolvedValue({
+        choices: [{ message: {} }],
+        model: "gpt-4o",
+      });
+      const result = await adapter.chat(messages);
+      expect(result.content).toBe("");
+      expect(result.usage).toBeUndefined();
+    });
+
+    it("should reuse cached client on second call", async () => {
+      const messages = [{ role: "user", content: "hello" }] as any;
+      mockOpenAIInstance.chat.completions.create.mockResolvedValue({
+        choices: [{ message: { content: "a" } }],
+        model: "gpt-4o",
+      });
+      (OpenAI as unknown as Mock).mockClear();
+      await adapter.chat(messages);
+      await adapter.chat(messages);
+      expect(OpenAI).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it("isSupportJsonSchema should return false", () => {
+    expect(adapter.isSupportJsonSchema()).toBe(false);
+  });
+});

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

@@ -0,0 +1,153 @@
+import { Injectable, Inject } from "@nestjs/common";
+import OpenAI from "openai";
+import type { LlmAdapter } from "./llm-adapter.interface";
+import type {
+  LlmMessage,
+  LlmRequestOptions,
+  LlmResponse,
+  LlmStreamEvent,
+  LlmProxyConfig,
+} from "../interfaces";
+import { shouldLog } from "../../verbose";
+
+@Injectable()
+export class OpenAIAdapter implements LlmAdapter {
+  readonly name = "openai";
+
+  private client: OpenAI | null = null;
+
+  constructor(@Inject("LLM_PROXY_CONFIG") private readonly config: LlmProxyConfig) {}
+
+  isConfigured(): boolean {
+    return !!this.config.openai;
+  }
+
+  private getClient(): OpenAI {
+    if (this.client) {
+      return this.client;
+    }
+
+    const openaiConf = this.config.openai;
+
+    if (!openaiConf) {
+      throw new Error("[LLMProxy.OpenAIAdapter.getClient] 未配置 openai 设置");
+    }
+
+    this.client = new OpenAI({
+      apiKey: openaiConf.apiKey,
+      baseURL: openaiConf.baseUrl || undefined,
+    });
+
+    return this.client;
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmRequestOptions): Promise<LlmResponse> {
+    const openaiConf = this.config.openai;
+
+    if (!openaiConf) {
+      throw new Error("[LLMProxy.OpenAIAdapter.chat] 未配置 openai 设置");
+    }
+
+    const client = this.getClient();
+    const model = options?.model || openaiConf.model;
+
+    if (shouldLog(options?.verbose, 1)) {
+      console.log(
+        `[LLMProxy.OpenAIAdapter.chat] 配置: Model=${model}, BaseURL=${openaiConf.baseUrl || "(默认)"}`,
+      );
+    }
+
+    try {
+      const response = await client.chat.completions.create({
+        model,
+        messages: messages,
+      });
+
+      const content = response.choices[0]?.message?.content || "";
+
+      if (shouldLog(options?.verbose, 1)) {
+        console.log(
+          `[LLMProxy.OpenAIAdapter.chat] 响应: Model=${response.model}, Usage=${response.usage?.total_tokens} tokens`,
+        );
+      }
+
+      return {
+        content,
+        usage: response.usage
+          ? {
+              promptTokens: response.usage.prompt_tokens,
+              completionTokens: response.usage.completion_tokens,
+              totalTokens: response.usage.total_tokens,
+            }
+          : undefined,
+      };
+    } catch (error: any) {
+      if (error instanceof OpenAI.APIError) {
+        throw new Error(
+          `[LLMProxy.OpenAIAdapter.chat] API 错误 (${error.status}): ${error.message}\n` +
+            `请检查：\n` +
+            `1. API Key 是否正确\n` +
+            `2. Base URL 是否正确\n` +
+            `3. 模型名称是否有效`,
+        );
+      }
+      throw error;
+    }
+  }
+
+  async *chatStream(
+    messages: LlmMessage[],
+    options?: LlmRequestOptions,
+  ): AsyncIterable<LlmStreamEvent> {
+    const openaiConf = this.config.openai;
+
+    if (!openaiConf) {
+      yield { type: "error", message: "[LLMProxy.OpenAIAdapter.chatStream] 未配置 openai 设置" };
+      return;
+    }
+
+    const client = this.getClient();
+    const model = options?.model || openaiConf.model;
+
+    if (shouldLog(options?.verbose, 1)) {
+      console.log(`[LLMProxy.OpenAIAdapter.chatStream] 配置: Model=${model}`);
+    }
+    try {
+      const stream = await client.chat.completions.create({
+        model,
+        messages: messages,
+        stream: true,
+      });
+
+      let fullContent = "";
+
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta) {
+          yield { type: "text", content: delta };
+          fullContent += delta;
+        }
+      }
+
+      yield {
+        type: "result",
+        response: {
+          content: fullContent,
+        },
+      };
+    } catch (error: any) {
+      if (error instanceof OpenAI.APIError) {
+        yield {
+          type: "error",
+          message: `[LLMProxy.OpenAIAdapter.chatStream] API 错误 (${error.status}): ${error.message}`,
+        };
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  isSupportJsonSchema(): boolean {
+    return false;
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from "./interfaces";
+export * from "./adapters";
+export * from "./llm-session";
+export * from "./llm-proxy.service";
+export * from "./llm-proxy.module";
+export * from "./stream-logger";

package/src/shared/llm-proxy/interfaces/config.interface.ts

@@ -0,0 +1,32 @@
+export interface ClaudeAdapterConfig {
+  model?: string;
+  baseUrl?: string;
+  authToken?: string;
+}
+
+export interface OpenAIAdapterConfig {
+  model: string;
+  baseUrl?: string;
+  apiKey: string;
+}
+
+export interface OpenCodeAdapterConfig {
+  model?: string;
+  /** OpenCode 服务地址，默认 http://localhost:4096 */
+  serverUrl?: string;
+  /** 云厂商 API 地址（会动态写入 opencode.json 配置） */
+  baseUrl?: string;
+  apiKey?: string;
+  providerID?: string;
+}
+
+export type LLMMode = "claude-code" | "openai" | "gemini" | "open-code";
+
+export interface LlmProxyConfig {
+  defaultAdapter?: LLMMode;
+  claudeCode?: ClaudeAdapterConfig;
+  openai?: OpenAIAdapterConfig;
+  openCode?: OpenCodeAdapterConfig;
+}
+
+export const LLM_PROXY_CONFIG = Symbol("LLM_PROXY_CONFIG");

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

@@ -0,0 +1,4 @@
+export * from "./message.interface";
+export * from "./session.interface";
+export * from "./config.interface";
+export type { VerboseLevel } from "../../verbose";

package/src/shared/llm-proxy/interfaces/message.interface.ts

@@ -0,0 +1,48 @@
+import type { LlmJsonPut } from "../../llm-jsonput";
+import type { VerboseLevel } from "../../verbose";
+
+export type LlmRole = "system" | "user" | "assistant";
+
+export interface LlmMessage {
+  role: LlmRole;
+  content: string;
+}
+
+export interface LlmRequestOptions {
+  model?: string;
+  jsonSchema?: LlmJsonPut;
+  stream?: boolean;
+  verbose?: VerboseLevel;
+  allowedTools?: string[];
+}
+
+export interface LlmUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export interface LlmResponse {
+  content: string;
+  structuredOutput?: unknown;
+  usage?: LlmUsage;
+}
+
+export type LlmStreamEvent =
+  | { type: "text"; content: string }
+  | {
+      type: "tool_use";
+      name: string;
+      input: unknown;
+      status?: string;
+      output?: string;
+      title?: string;
+    }
+  | { type: "thought"; content: string }
+  | { type: "result"; response: LlmResponse }
+  | { type: "error"; message: string }
+  | { type: "agent"; name: string; source?: string }
+  | { type: "subtask"; agent: string; prompt: string; description: string }
+  | { type: "step_start"; snapshot?: string }
+  | { type: "step_finish"; reason: string; tokens?: unknown; cost?: number }
+  | { type: "reasoning"; content: string };

package/src/shared/llm-proxy/interfaces/session.interface.ts

@@ -0,0 +1,28 @@
+import type {
+  LlmMessage,
+  LlmRequestOptions,
+  LlmResponse,
+  LlmStreamEvent,
+} from "./message.interface";
+import type { VerboseLevel } from "../../verbose";
+
+export interface SessionOptions {
+  systemPrompt?: string;
+  model?: string;
+  verbose?: VerboseLevel;
+}
+
+export interface LlmSession {
+  readonly id: string;
+  readonly adapterName: string;
+
+  send(content: string, options?: LlmRequestOptions): Promise<LlmResponse>;
+
+  sendStream(content: string, options?: LlmRequestOptions): AsyncIterable<LlmStreamEvent>;
+
+  getHistory(): LlmMessage[];
+
+  clearHistory(): void;
+
+  setSystemPrompt(prompt: string): void;
+}

package/src/shared/llm-proxy/llm-proxy.module.ts

@@ -0,0 +1,140 @@
+import { Module, DynamicModule, Provider, Type } from "@nestjs/common";
+import { LlmProxyService } from "./llm-proxy.service";
+import { ClaudeCodeAdapter } from "./adapters/claude-code.adapter";
+import { OpenAIAdapter } from "./adapters/openai.adapter";
+import { ClaudeSetupModule } from "../claude-setup";
+import type { LlmProxyConfig } from "./interfaces";
+import { OpenCodeAdapter } from "./adapters";
+
+export interface LlmProxyModuleOptions extends LlmProxyConfig {}
+
+export interface LlmProxyModuleAsyncOptions {
+  imports?: any[];
+  useFactory?: (...args: any[]) => Promise<LlmProxyConfig> | LlmProxyConfig;
+  inject?: any[];
+  useClass?: Type<LlmProxyOptionsFactory>;
+  useExisting?: Type<LlmProxyOptionsFactory>;
+}
+
+export interface LlmProxyOptionsFactory {
+  createLlmProxyOptions(): Promise<LlmProxyConfig> | LlmProxyConfig;
+}
+
+@Module({})
+export class LlmProxyModule {
+  static forRoot(options: LlmProxyModuleOptions): DynamicModule {
+    const resolvedOptions = this.resolveOpenCodeConfig(options);
+    return {
+      module: LlmProxyModule,
+      imports: [ClaudeSetupModule],
+      providers: [
+        {
+          provide: "LLM_PROXY_CONFIG",
+          useValue: resolvedOptions,
+        },
+        ClaudeCodeAdapter,
+        OpenAIAdapter,
+        OpenCodeAdapter,
+        LlmProxyService,
+      ],
+      exports: [LlmProxyService, ClaudeCodeAdapter, OpenCodeAdapter, OpenAIAdapter],
+    };
+  }
+
+  static forRootAsync(options: LlmProxyModuleAsyncOptions): DynamicModule {
+    const asyncProviders = this.createAsyncProviders(options);
+
+    return {
+      module: LlmProxyModule,
+      imports: [...(options.imports || []), ClaudeSetupModule],
+      providers: [
+        ...asyncProviders,
+        ClaudeCodeAdapter,
+        OpenAIAdapter,
+        OpenCodeAdapter,
+        LlmProxyService,
+      ],
+      exports: [LlmProxyService, ClaudeCodeAdapter, OpenCodeAdapter, OpenAIAdapter],
+    };
+  }
+
+  private static createAsyncProviders(options: LlmProxyModuleAsyncOptions): Provider[] {
+    if (options.useFactory) {
+      const originalFactory = options.useFactory;
+      return [
+        {
+          provide: "LLM_PROXY_CONFIG",
+          useFactory: async (...args: any[]) => {
+            const config = await originalFactory(...args);
+            return this.resolveOpenCodeConfig(config);
+          },
+          inject: options.inject || [],
+        },
+      ];
+    }
+
+    if (options.useClass) {
+      return [
+        {
+          provide: "LLM_PROXY_CONFIG",
+          useFactory: async (optionsFactory: LlmProxyOptionsFactory) =>
+            optionsFactory.createLlmProxyOptions(),
+          inject: [options.useClass],
+        },
+        {
+          provide: options.useClass,
+          useClass: options.useClass,
+        },
+      ];
+    }
+
+    if (options.useExisting) {
+      return [
+        {
+          provide: "LLM_PROXY_CONFIG",
+          useFactory: async (optionsFactory: LlmProxyOptionsFactory) =>
+            optionsFactory.createLlmProxyOptions(),
+          inject: [options.useExisting],
+        },
+      ];
+    }
+
+    return [];
+  }
+
+  private static resolveOpenCodeConfig(config: LlmProxyConfig): LlmProxyConfig {
+    if (!config.openCode) {
+      return config;
+    }
+
+    const providerID = config.openCode.providerID || "openai";
+    let apiKey = config.openCode.apiKey;
+    let baseUrl = config.openCode.baseUrl;
+    let model = config.openCode.model;
+
+    // 根据 providerID 从对应的 adapter 配置中读取缺失的值
+    if (providerID === "openai" && config.openai) {
+      if (!apiKey) apiKey = config.openai.apiKey;
+      if (!baseUrl) baseUrl = config.openai.baseUrl;
+      if (!model) model = config.openai.model;
+    } else if (providerID === "anthropic" && config.claudeCode) {
+      if (!apiKey) apiKey = config.claudeCode.authToken;
+      if (!baseUrl) baseUrl = config.claudeCode.baseUrl;
+      if (!model) model = config.claudeCode.model;
+    }
+
+    // 如果有任何值需要更新
+    if (
+      apiKey !== config.openCode.apiKey ||
+      baseUrl !== config.openCode.baseUrl ||
+      model !== config.openCode.model
+    ) {
+      return {
+        ...config,
+        openCode: { ...config.openCode, apiKey, baseUrl, model },
+      };
+    }
+
+    return config;
+  }
+}