@goondan/openharness-base 0.1.7 → 0.1.9

package/src/__tests__/logging.test.ts

@@ -1,200 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { Logging } from "../extensions/logging.js";
-import type { ExtensionApi, ConversationState } from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState {
-  return {
-    messages: [],
-    events: [],
-    emit: vi.fn(),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(conversation: ConversationState): {
-  api: ExtensionApi;
-  eventListeners: Map<string, Array<(payload: unknown) => void>>;
-} {
-  const eventListeners = new Map<string, Array<(payload: unknown) => void>>();
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn() as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => []),
-    },
-    on: vi.fn((event: string, listener: (payload: unknown) => void) => {
-      if (!eventListeners.has(event)) {
-        eventListeners.set(event, []);
-      }
-      eventListeners.get(event)!.push(listener);
-    }),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, eventListeners };
-}
-
-function emit(
-  eventListeners: Map<string, Array<(payload: unknown) => void>>,
-  event: string,
-  payload: unknown,
-) {
-  eventListeners.get(event)?.forEach((l) => l(payload));
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Logging", () => {
-  it("creates an Extension with name 'logging'", () => {
-    const ext = Logging();
-    expect(ext.name).toBe("logging");
-  });
-
-  it("subscribes to all core events on register", () => {
-    const conversation = makeMockConversationState();
-    const { api } = makeMockApi(conversation);
-
-    const ext = Logging();
-    ext.register(api);
-
-    expect(api.on).toHaveBeenCalledWith("turn.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("turn.done", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("turn.error", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("step.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("step.done", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("tool.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("tool.done", expect.any(Function));
-  });
-
-  it("logs turn.start event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.start", { turnId: "t1" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.start");
-  });
-
-  it("logs turn.done event", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.done", { turnId: "t1", status: "completed" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.done");
-  });
-
-  it("logs turn.error event", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.error", { error: "oops" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.error");
-  });
-
-  it("uses console.log as default logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-
-    const ext = Logging();
-    ext.register(api);
-
-    emit(eventListeners, "turn.start", { turnId: "t1" });
-
-    expect(consoleSpy).toHaveBeenCalledOnce();
-    consoleSpy.mockRestore();
-  });
-
-  it("logs step.start event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "step.start", { stepIndex: 0 });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("step.start");
-    expect(logger.mock.calls[0][0]).toContain("stepIndex");
-  });
-
-  it("logs step.done event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "step.done", { stepIndex: 0, toolCallCount: 2 });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("step.done");
-  });
-
-  it("logs tool.start and tool.done events with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "tool.start", { toolName: "bash", toolCallId: "tc-1" });
-    emit(eventListeners, "tool.done", { toolName: "bash", toolCallId: "tc-1", result: { type: "text", text: "ok" } });
-
-    expect(logger).toHaveBeenCalledTimes(2);
-    expect(logger.mock.calls[0][0]).toContain("tool.start");
-    expect(logger.mock.calls[0][0]).toContain("bash");
-    expect(logger.mock.calls[1][0]).toContain("tool.done");
-  });
-
-  it("does NOT call pipeline.register (event-based, no middleware)", () => {
-    const conversation = makeMockConversationState();
-    const { api } = makeMockApi(conversation);
-
-    const ext = Logging();
-    ext.register(api);
-
-    expect(api.pipeline.register).not.toHaveBeenCalled();
-  });
-});

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/);
-  });
-});