@goondan/openharness-base 0.1.8 → 0.1.9

package/src/__tests__/message-window.test.ts

@@ -1,194 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { MessageWindow } from "../extensions/message-window.js";
-import type {
-  ExtensionApi,
-  StepMiddleware,
-  StepContext,
-  StepResult,
-  ConversationState,
-  Message,
-  MessageEvent,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMessages(count: number): Message[] {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `msg-${i}`,
-    data: {
-      role: "user" as const,
-      content: `Message ${i}`,
-    },
-  }));
-}
-
-function makeMockConversationState(
-  messages: Message[],
-): ConversationState & { emitted: MessageEvent[] } {
-  const emitted: MessageEvent[] = [];
-  return {
-    messages,
-    events: [],
-    emitted,
-    emit: vi.fn((event: MessageEvent) => {
-      emitted.push(event);
-    }),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(conversation: ConversationState): {
-  api: ExtensionApi;
-  registeredMiddleware: Array<{
-    level: string;
-    handler: StepMiddleware;
-    options?: { priority?: number };
-  }>;
-} {
-  const registeredMiddleware: Array<{
-    level: string;
-    handler: StepMiddleware;
-    options?: { priority?: number };
-  }> = [];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn(
-        (level: string, handler: StepMiddleware, options?: { priority?: number }) => {
-          registeredMiddleware.push({ level, handler, options });
-        },
-      ) as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => []),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredMiddleware };
-}
-
-function makeStepContext(conversation: ConversationState): StepContext {
-  return {
-    turnId: "turn-1",
-    agentName: "test-agent",
-    conversationId: "conv-1",
-    conversation,
-    stepNumber: 1,
-    abortSignal: new AbortController().signal,
-    input: {
-      name: "test-event",
-      content: [{ type: "text", text: "hello" }],
-      properties: {},
-      source: {
-        connector: "test-connector",
-        connectionName: "test",
-        receivedAt: new Date().toISOString(),
-      },
-    },
-    llm: { chat: vi.fn().mockResolvedValue({ text: "mock" }) },
-  };
-}
-
-const stubStepResult: StepResult = {
-  toolCalls: [],
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("MessageWindow", () => {
-  it("creates an Extension with name 'message-window'", () => {
-    const ext = MessageWindow({ maxMessages: 5 });
-    expect(ext.name).toBe("message-window");
-  });
-
-  it("registers step middleware via api.pipeline.register", () => {
-    const conversation = makeMockConversationState([]);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = MessageWindow({ maxMessages: 5 });
-    ext.register(api);
-
-    expect(api.pipeline.register).toHaveBeenCalledOnce();
-    expect(registeredMiddleware[0].level).toBe("step");
-  });
-
-  it("does NOT emit truncate when messages are within maxMessages", async () => {
-    const messages = makeMessages(3);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = MessageWindow({ maxMessages: 5 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    expect(conversation.emit).not.toHaveBeenCalled();
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("emits truncate when messages exceed maxMessages", async () => {
-    const messages = makeMessages(8);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = MessageWindow({ maxMessages: 5 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    expect(conversation.emit).toHaveBeenCalledOnce();
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted[0];
-    expect(emitted.type).toBe("truncate");
-    if (emitted.type === "truncate") {
-      expect(emitted.keepLast).toBe(5);
-    }
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("emits truncate with exact maxMessages count", async () => {
-    const messages = makeMessages(6);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = MessageWindow({ maxMessages: 5 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    expect(conversation.emit).toHaveBeenCalledOnce();
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted[0];
-    if (emitted.type === "truncate") {
-      expect(emitted.keepLast).toBe(5);
-    }
-  });
-});

package/src/__tests__/required-tools-guard.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { RequiredToolsGuard } from "../extensions/required-tools-guard.js";
-import type {
-  ExtensionApi,
-  TurnMiddleware,
-  TurnContext,
-  TurnResult,
-  ConversationState,
-  ToolDefinition,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState {
-  return {
-    messages: [],
-    events: [],
-    emit: vi.fn(),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(
-  conversation: ConversationState,
-  availableTools: ToolDefinition[] = [],
-): {
-  api: ExtensionApi;
-  registeredMiddleware: Array<{
-    level: string;
-    handler: TurnMiddleware;
-    options?: { priority?: number };
-  }>;
-} {
-  const registeredMiddleware: Array<{
-    level: string;
-    handler: TurnMiddleware;
-    options?: { priority?: number };
-  }> = [];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn(
-        (level: string, handler: TurnMiddleware, options?: { priority?: number }) => {
-          registeredMiddleware.push({ level, handler, options });
-        },
-      ) as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => availableTools as readonly ToolDefinition[]),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredMiddleware };
-}
-
-function makeTurnContext(conversation: ConversationState): TurnContext {
-  return {
-    turnId: "turn-1",
-    agentName: "test-agent",
-    conversationId: "conv-1",
-    conversation,
-    abortSignal: new AbortController().signal,
-    input: {
-      name: "test-event",
-      content: [{ type: "text", text: "hello" }],
-      properties: {},
-      source: {
-        connector: "test-connector",
-        connectionName: "test",
-        receivedAt: new Date().toISOString(),
-      },
-    },
-    llm: { chat: vi.fn().mockResolvedValue({ text: "mock" }) },
-  };
-}
-
-function makeDummyTool(name: string): ToolDefinition {
-  return {
-    name,
-    description: `Tool ${name}`,
-    parameters: { type: "object", properties: {} },
-    handler: async () => ({ type: "text", text: "ok" }),
-  };
-}
-
-const stubTurnResult: TurnResult = {
-  turnId: "turn-1",
-  agentName: "test-agent",
-  conversationId: "conv-1",
-  status: "completed",
-  steps: [],
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("RequiredToolsGuard", () => {
-  it("creates an Extension with name 'required-tools-guard'", () => {
-    const ext = RequiredToolsGuard({ tools: ["my_tool"] });
-    expect(ext.name).toBe("required-tools-guard");
-  });
-
-  it("registers turn middleware via api.pipeline.register", () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = RequiredToolsGuard({ tools: ["my_tool"] });
-    ext.register(api);
-
-    expect(api.pipeline.register).toHaveBeenCalledOnce();
-    expect(registeredMiddleware[0].level).toBe("turn");
-  });
-
-  it("calls next() when all required tools are present", async () => {
-    const conversation = makeMockConversationState();
-    const tools = [makeDummyTool("tool_a"), makeDummyTool("tool_b")];
-    const { api, registeredMiddleware } = makeMockApi(conversation, tools);
-
-    const ext = RequiredToolsGuard({ tools: ["tool_a", "tool_b"] });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    const result = await middleware(ctx, next);
-
-    expect(next).toHaveBeenCalledOnce();
-    expect(result).toBe(stubTurnResult);
-  });
-
-  it("throws error when required tools are missing", async () => {
-    const conversation = makeMockConversationState();
-    const tools = [makeDummyTool("tool_a")];
-    const { api, registeredMiddleware } = makeMockApi(conversation, tools);
-
-    const ext = RequiredToolsGuard({ tools: ["tool_a", "tool_b"] });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    await expect(middleware(ctx, next)).rejects.toThrow("tool_b");
-    expect(next).not.toHaveBeenCalled();
-  });
-
-  it("throws when no tools are registered at all", async () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation, []);
-
-    const ext = RequiredToolsGuard({ tools: ["required_tool"] });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    await expect(middleware(ctx, next)).rejects.toThrow("required_tool");
-  });
-
-  it("passes when no tools are required", async () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation, []);
-
-    const ext = RequiredToolsGuard({ tools: [] });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    await expect(middleware(ctx, next)).resolves.toBe(stubTurnResult);
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("error message lists all missing tools", async () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation, []);
-
-    const ext = RequiredToolsGuard({ tools: ["tool_x", "tool_y", "tool_z"] });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    await expect(middleware(ctx, next)).rejects.toThrow(/tool_x.*tool_y.*tool_z/);
-  });
-});

package/src/__tests__/tool-search.test.ts

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ToolSearch } from "../extensions/tool-search.js";
-import type {
-  ExtensionApi,
-  ConversationState,
-  ToolDefinition,
-  ToolContext,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState {
-  return {
-    messages: [],
-    events: [],
-    emit: vi.fn(),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(
-  conversation: ConversationState,
-  availableTools: ToolDefinition[] = [],
-): {
-  api: ExtensionApi;
-  registeredTools: ToolDefinition[];
-} {
-  const registeredTools: ToolDefinition[] = [...availableTools];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn() as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn((tool: ToolDefinition) => {
-        registeredTools.push(tool);
-      }),
-      remove: vi.fn(),
-      list: vi.fn(() => registeredTools as readonly ToolDefinition[]),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredTools };
-}
-
-function makeDummyTool(name: string, description: string): ToolDefinition {
-  return {
-    name,
-    description,
-    parameters: { type: "object", properties: {} },
-    handler: async () => ({ type: "text", text: "ok" }),
-  };
-}
-
-function makeToolContext(): ToolContext {
-  return {
-    conversationId: "conv-1",
-    agentName: "test-agent",
-    abortSignal: new AbortController().signal,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("ToolSearch", () => {
-  it("creates an Extension with name 'tool-search'", () => {
-    const ext = ToolSearch();
-    expect(ext.name).toBe("tool-search");
-  });
-
-  it("registers a meta-tool named 'search_tools'", () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredTools } = makeMockApi(conversation);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    expect(api.tools.register).toHaveBeenCalledOnce();
-    const searchTool = registeredTools.find((t) => t.name === "search_tools");
-    expect(searchTool).toBeDefined();
-  });
-
-  it("search_tools returns tools matching keyword in name", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [
-      makeDummyTool("weather_get", "Get current weather"),
-      makeDummyTool("calendar_add", "Add a calendar event"),
-      makeDummyTool("weather_forecast", "Get weather forecast"),
-    ];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "weather" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(2);
-      expect(data.map((t) => t.name)).toContain("weather_get");
-      expect(data.map((t) => t.name)).toContain("weather_forecast");
-    }
-  });
-
-  it("search_tools returns tools matching keyword in description", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [
-      makeDummyTool("tool_a", "Send an email to a recipient"),
-      makeDummyTool("tool_b", "Read a file from disk"),
-    ];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "email" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(1);
-      expect(data[0].name).toBe("tool_a");
-    }
-  });
-
-  it("search_tools returns empty array when no match", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [makeDummyTool("calculator", "Perform math operations")];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "nonexistent" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toEqual([]);
-    }
-  });
-
-  it("search is case-insensitive", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [makeDummyTool("WeatherTool", "Get Weather Data")];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "weather" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(1);
-    }
-  });
-});