@poncho-ai/harness 0.2.0

package/test/mcp.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { WebSocketServer } from "ws";
+import { LocalMcpBridge } from "../src/mcp.js";
+
+describe("mcp bridge protocol transports", () => {
+  it("discovers and calls tools over websocket json-rpc", async () => {
+    const wss = new WebSocketServer({ port: 0 });
+    await new Promise<void>((resolveOpen) => {
+      wss.once("listening", () => resolveOpen());
+    });
+
+    wss.on("connection", (socket) => {
+      socket.on("message", (data) => {
+        const msg = JSON.parse(String(data)) as {
+          id: number;
+          method: string;
+          params?: { arguments?: { value?: string } };
+        };
+        if (msg.method === "tools/list") {
+          socket.send(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: msg.id,
+              result: {
+                tools: [
+                  {
+                    name: "remotePing",
+                    description: "Remote ping",
+                    inputSchema: {
+                      type: "object",
+                      properties: { value: { type: "string" } },
+                    },
+                  },
+                ],
+              },
+            }),
+          );
+        } else if (msg.method === "tools/call") {
+          socket.send(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: msg.id,
+              result: {
+                result: { echoed: msg.params?.arguments?.value ?? "" },
+              },
+            }),
+          );
+        }
+      });
+    });
+
+    const address = wss.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Unexpected websocket address");
+    }
+
+    const bridge = new LocalMcpBridge({
+      mcp: [{ name: "remote", url: `ws://127.0.0.1:${address.port}` }],
+    });
+
+    await bridge.startLocalServers();
+    const tools = await bridge.loadTools();
+    const tool = tools.find((entry) => entry.name === "remote:remotePing");
+    expect(tool).toBeDefined();
+    const output = await tool?.handler(
+      { value: "ws" },
+      {
+        agentId: "agent",
+        runId: "run",
+        step: 1,
+        workingDir: process.cwd(),
+        parameters: {},
+      },
+    );
+    expect(output).toEqual({ echoed: "ws" });
+
+    await bridge.stopLocalServers();
+    await new Promise<void>((resolveClose) => {
+      wss.close(() => resolveClose());
+    });
+  });
+});

package/test/memory.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { createMemoryStore, createMemoryTools } from "../src/memory.js";
+
+describe("memory store factory", () => {
+  it("uses memory provider by default", async () => {
+    const store = createMemoryStore("agent-test");
+    const updated = await store.updateMainMemory({
+      mode: "replace",
+      content: "Cesar prefers short bullet points.",
+    });
+    expect(updated.content).toContain("short bullet points");
+    const fetched = await store.getMainMemory();
+    expect(fetched.content).toContain("short bullet points");
+  });
+
+  it("supports append updates", async () => {
+    const store = createMemoryStore("agent-append");
+    await store.updateMainMemory({
+      mode: "replace",
+      content: "Initial memory.",
+    });
+    const result = await store.updateMainMemory({
+      mode: "append",
+      content: "Appended line.",
+    });
+    expect(result.content).toContain("Initial memory.");
+    expect(result.content).toContain("Appended line.");
+  });
+
+  it("falls back gracefully when upstash is not configured", async () => {
+    const store = createMemoryStore("agent-fallback", { provider: "upstash" });
+    const updated = await store.updateMainMemory({
+      mode: "replace",
+      content: "Fallback path still stores memory",
+    });
+    expect(updated.content).toContain("Fallback path");
+  });
+});
+
+describe("memory tools", () => {
+  it("creates tool definitions", async () => {
+    const store = createMemoryStore("agent-tools");
+    const tools = createMemoryTools(store);
+    expect(tools.map((tool) => tool.name)).toEqual([
+      "memory_main_get",
+      "memory_main_update",
+      "conversation_recall",
+    ]);
+  });
+});

package/test/model-factory.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { createModelClient } from "../src/model-factory.js";
+import { AnthropicModelClient } from "../src/anthropic-client.js";
+import { OpenAiModelClient } from "../src/openai-client.js";
+
+describe("model factory", () => {
+  it("creates OpenAI model client for openai provider", () => {
+    const client = createModelClient("openai");
+    expect(client).toBeInstanceOf(OpenAiModelClient);
+  });
+
+  it("defaults to Anthropic model client", () => {
+    const client = createModelClient(undefined);
+    expect(client).toBeInstanceOf(AnthropicModelClient);
+  });
+});

package/test/state.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { createConversationStore, createStateStore } from "../src/state.js";
+
+describe("state store factory", () => {
+  it("uses memory provider when explicitly requested", async () => {
+    const store = createStateStore({ provider: "memory", ttl: 60 });
+    await store.set({
+      runId: "run_memory",
+      messages: [{ role: "user", content: "hello" }],
+      updatedAt: Date.now(),
+    });
+    const value = await store.get("run_memory");
+    expect(value?.runId).toBe("run_memory");
+  });
+
+  it("falls back gracefully when external provider is not configured", async () => {
+    const store = createStateStore({ provider: "upstash", ttl: 60 });
+    await store.set({
+      runId: "run_fallback",
+      messages: [{ role: "user", content: "hello" }],
+      updatedAt: Date.now(),
+    });
+    const value = await store.get("run_fallback");
+    expect(value?.runId).toBe("run_fallback");
+  });
+});
+
+describe("conversation store factory", () => {
+  it("uses memory provider by default", async () => {
+    const store = createConversationStore();
+    const created = await store.create("owner-a", "hello");
+    expect(created.title).toBe("hello");
+    const listed = await store.list("owner-a");
+    expect(listed[0]?.conversationId).toBe(created.conversationId);
+  });
+
+  it("falls back gracefully when upstash is not configured", async () => {
+    const store = createConversationStore({ provider: "upstash" });
+    const created = await store.create("owner-b", "fallback");
+    const found = await store.get(created.conversationId);
+    expect(found?.title).toBe("fallback");
+  });
+});

package/test/telemetry.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from "vitest";
+import { TelemetryEmitter } from "../src/telemetry.js";
+
+describe("telemetry emitter", () => {
+  it("delegates to custom handler when configured", async () => {
+    const handler = vi.fn();
+    const emitter = new TelemetryEmitter({ handler });
+    await emitter.emit({ type: "step:started", step: 1 });
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not throw when exporters fail", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockRejectedValue(new Error("network down"));
+
+    const emitter = new TelemetryEmitter({
+      otlp: "https://otel.example.com/v1/logs",
+      latitude: { apiKey: "lat_test" },
+    });
+
+    await expect(
+      emitter.emit({ type: "step:completed", step: 1, duration: 1 }),
+    ).resolves.toBeUndefined();
+
+    global.fetch = originalFetch;
+  });
+
+  it("includes latitude projectId and documentPath when configured", async () => {
+    const originalFetch = global.fetch;
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true });
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const emitter = new TelemetryEmitter({
+      latitude: {
+        apiKey: "lat_test",
+        projectId: "proj_123",
+        documentPath: "agents/support-agent/AGENT.md",
+      },
+    });
+
+    await emitter.emit({ type: "step:started", step: 2 });
+
+    expect(fetchMock).toHaveBeenCalled();
+    const [, request] = fetchMock.mock.calls[0] as [
+      string,
+      { body?: string; headers?: Record<string, string> },
+    ];
+    const payload = JSON.parse(request.body ?? "{}") as {
+      projectId?: string;
+      documentPath?: string;
+    };
+    expect(payload.projectId).toBe("proj_123");
+    expect(payload.documentPath).toBe("agents/support-agent/AGENT.md");
+
+    global.fetch = originalFetch;
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}