@goondan/openharness-base 0.0.1-alpha3 → 0.0.1-alpha5

package/src/__tests__/compaction-summarize.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi } from "vitest";
+import { CompactionSummarize } from "../extensions/compaction-summarize.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(),
+      },
+    },
+  };
+}
+
+const stubStepResult: StepResult = {
+  toolCalls: [],
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("CompactionSummarize", () => {
+  it("creates an Extension with name 'compaction-summarize'", () => {
+    const ext = CompactionSummarize({ threshold: 10 });
+    expect(ext.name).toBe("compaction-summarize");
+  });
+
+  it("registers step middleware via api.pipeline.register", () => {
+    const conversation = makeMockConversationState([]);
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = CompactionSummarize({ threshold: 10 });
+    ext.register(api);
+
+    expect(api.pipeline.register).toHaveBeenCalledOnce();
+    expect(registeredMiddleware[0].level).toBe("step");
+  });
+
+  it("does NOT compact when messages are below threshold", async () => {
+    const messages = makeMessages(5);
+    const conversation = makeMockConversationState(messages);
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = CompactionSummarize({ threshold: 10 });
+    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("compacts when messages exceed threshold", async () => {
+    const messages = makeMessages(12);
+    const conversation = makeMockConversationState(messages);
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = CompactionSummarize({ threshold: 10 });
+    ext.register(api);
+
+    const middleware = registeredMiddleware[0].handler;
+    const ctx = makeStepContext(conversation);
+    const next = vi.fn(async () => stubStepResult);
+
+    await middleware(ctx, next);
+
+    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
+
+    // keepCount = floor(10/2) = 5, removeCount = 12 - 5 = 7
+    // Should have 7 remove events + 1 append event
+    const removeEvents = emitted.filter((e) => e.type === "remove");
+    const appendEvents = emitted.filter((e) => e.type === "append");
+
+    expect(removeEvents).toHaveLength(7);
+    expect(appendEvents).toHaveLength(1);
+
+    // The appended message should be a system summary
+    const appendEvent = appendEvents[0];
+    if (appendEvent.type === "append") {
+      expect(appendEvent.message.data.role).toBe("system");
+      expect(appendEvent.message.data.content).toContain("[Summary of earlier conversation]:");
+      expect(appendEvent.message.metadata?.__createdBy).toBe("compaction-summarize");
+    }
+
+    expect(next).toHaveBeenCalledOnce();
+  });
+
+  it("removes the oldest messages (not the newest)", async () => {
+    const messages = makeMessages(12);
+    const conversation = makeMockConversationState(messages);
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = CompactionSummarize({ threshold: 10 });
+    ext.register(api);
+
+    const middleware = registeredMiddleware[0].handler;
+    const ctx = makeStepContext(conversation);
+    const next = vi.fn(async () => stubStepResult);
+
+    await middleware(ctx, next);
+
+    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
+    const removeEvents = emitted.filter(
+      (e): e is Extract<typeof e, { type: "remove" }> => e.type === "remove",
+    );
+
+    // Should remove msg-0 through msg-6 (the oldest 7)
+    const removedIds = removeEvents.map((e) => e.messageId);
+    expect(removedIds).toContain("msg-0");
+    expect(removedIds).toContain("msg-6");
+    expect(removedIds).not.toContain("msg-7");
+    expect(removedIds).not.toContain("msg-11");
+  });
+
+  it("summary content includes text from removed messages", async () => {
+    const messages = makeMessages(12);
+    const conversation = makeMockConversationState(messages);
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = CompactionSummarize({ threshold: 10 });
+    ext.register(api);
+
+    const middleware = registeredMiddleware[0].handler;
+    const ctx = makeStepContext(conversation);
+    const next = vi.fn(async () => stubStepResult);
+
+    await middleware(ctx, next);
+
+    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
+    const appendEvent = emitted.find((e) => e.type === "append");
+    if (appendEvent && appendEvent.type === "append") {
+      const content = appendEvent.message.data.content as string;
+      // Should include text from the removed messages
+      expect(content).toContain("Message 0");
+    }
+  });
+});

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

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi } from "vitest";
+import { ContextMessage } from "../extensions/context-message.js";
+import type {
+  ExtensionApi,
+  TurnMiddleware,
+  TurnContext,
+  TurnResult,
+  ConversationState,
+  Message,
+  MessageEvent,
+} from "@goondan/openharness-types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMockConversationState(): ConversationState & { emitted: MessageEvent[] } {
+  const emitted: MessageEvent[] = [];
+  const messages: Message[] = [];
+  return {
+    messages,
+    events: [],
+    emitted,
+    emit: vi.fn((event: MessageEvent) => {
+      emitted.push(event);
+      if (event.type === "append") {
+        messages.push(event.message);
+      }
+    }),
+    restore: vi.fn(),
+  };
+}
+
+function makeMockApi(conversation: ConversationState): {
+  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(() => []),
+    },
+    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(),
+      },
+    },
+  };
+}
+
+const stubTurnResult: TurnResult = {
+  turnId: "turn-1",
+  agentName: "test-agent",
+  conversationId: "conv-1",
+  status: "completed",
+  steps: [],
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("ContextMessage", () => {
+  // Test 1: creates Extension with correct name
+  it("creates an Extension with name 'context-message'", () => {
+    const ext = ContextMessage("You are a helpful assistant.");
+    expect(ext.name).toBe("context-message");
+  });
+
+  // Test 2: register() adds turn middleware via api.pipeline.register
+  it("register() calls api.pipeline.register with level 'turn'", () => {
+    const conversation = makeMockConversationState();
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = ContextMessage("Hello");
+    ext.register(api);
+
+    expect(api.pipeline.register).toHaveBeenCalledOnce();
+    expect(registeredMiddleware).toHaveLength(1);
+    expect(registeredMiddleware[0].level).toBe("turn");
+    expect(typeof registeredMiddleware[0].handler).toBe("function");
+  });
+
+  // Test 3: middleware is registered with HIGH priority (low number)
+  it("registers turn middleware with priority 10 (high priority)", () => {
+    const conversation = makeMockConversationState();
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = ContextMessage("Hello");
+    ext.register(api);
+
+    expect(registeredMiddleware[0].options?.priority).toBe(10);
+  });
+
+  // Test 4: middleware prepends system message to conversation and text matches
+  it("middleware emits append event with system message matching the text argument", async () => {
+    const conversation = makeMockConversationState();
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+    const systemText = "You are a helpful assistant.";
+
+    const ext = ContextMessage(systemText);
+    ext.register(api);
+
+    const middleware = registeredMiddleware[0].handler;
+    const ctx = makeTurnContext(conversation);
+    const next = vi.fn(async () => stubTurnResult);
+
+    await middleware(ctx, next);
+
+    expect(conversation.emit).toHaveBeenCalledOnce();
+    const emitted = conversation.emitted[0];
+    expect(emitted.type).toBe("append");
+    if (emitted.type === "append") {
+      expect(emitted.message.data.role).toBe("system");
+      expect(emitted.message.data.content).toBe(systemText);
+      expect(emitted.message.metadata?.__createdBy).toBe("context-message");
+      expect(typeof emitted.message.id).toBe("string");
+    }
+  });
+
+  // Test 5: middleware calls next() after emitting
+  it("middleware calls next() after emitting the system message", async () => {
+    const conversation = makeMockConversationState();
+    const { api, registeredMiddleware } = makeMockApi(conversation);
+
+    const ext = ContextMessage("Some context");
+    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);
+  });
+
+  // Test 6: multiple ContextMessage extensions → multiple system messages
+  it("multiple ContextMessage extensions each prepend their own system message", async () => {
+    const conversation = makeMockConversationState();
+    const { api: api1, registeredMiddleware: rm1 } = makeMockApi(conversation);
+    const { api: api2, registeredMiddleware: rm2 } = makeMockApi(conversation);
+
+    const ext1 = ContextMessage("First context");
+    const ext2 = ContextMessage("Second context");
+
+    ext1.register(api1);
+    ext2.register(api2);
+
+    const ctx = makeTurnContext(conversation);
+    const next = vi.fn(async () => stubTurnResult);
+
+    await rm1[0].handler(ctx, next);
+    await rm2[0].handler(ctx, next);
+
+    expect(conversation.emitted).toHaveLength(2);
+
+    const texts = conversation.emitted
+      .filter((e): e is Extract<typeof e, { type: "append" }> => e.type === "append")
+      .map((e) => e.message.data.content);
+
+    expect(texts).toContain("First context");
+    expect(texts).toContain("Second context");
+  });
+});

package/src/__tests__/logging.test.ts

@@ -0,0 +1,200 @@
+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();
+  });
+});