@app-vitals/agent-runtime 0.0.1 → 0.1.0

package/http-chat-service-client.unit.test.ts

@@ -0,0 +1,500 @@
+/**
+ * agent/src/runtime/http-chat-service-client.unit.test.ts
+ *
+ * Unit tests for HttpChatServiceClient.
+ * Uses injected fake fetch doubles — no global.fetch override, no mock.module().
+ */
+
+import { describe, expect, it } from "bun:test";
+import {
+  ChatServiceClientError,
+  HttpChatServiceClient,
+} from "./http-chat-service-client.ts";
+
+// ─── Constants ─────────────────────────────────────────────────────────────────
+
+const BASE_URL = "https://chat.test.shipwright.dev";
+const TOKEN = "chat-service-token-123";
+const THREAD_ID = "thread-abc";
+const MESSAGE_ID = "msg-xyz";
+
+// ─── Fake fetch helpers ────────────────────────────────────────────────────────
+
+type FetchFn = (
+  url: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+type CapturedCall = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: unknown;
+};
+
+function fakeFetch(statusCode: number, body: unknown): FetchFn {
+  return async () => {
+    return new Response(JSON.stringify(body), {
+      status: statusCode,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+}
+
+function capturingFetch(
+  statusCode: number,
+  body: unknown,
+): { fn: FetchFn; calls: CapturedCall[] } {
+  const calls: CapturedCall[] = [];
+  return {
+    fn: async (urlInput, init) => {
+      const url = urlInput instanceof Request ? urlInput.url : String(urlInput);
+      const method =
+        urlInput instanceof Request ? urlInput.method : (init?.method ?? "GET");
+      const headers: Record<string, string> = {};
+      const rawHeaders =
+        urlInput instanceof Request
+          ? urlInput.headers
+          : new Headers(init?.headers);
+      rawHeaders.forEach((value, key) => {
+        headers[key] = value;
+      });
+      let parsedBody: unknown;
+      if (init?.body) {
+        try {
+          parsedBody = JSON.parse(init.body as string);
+        } catch {
+          parsedBody = init.body;
+        }
+      }
+      calls.push({ url, method, headers, body: parsedBody });
+      return new Response(JSON.stringify(body), {
+        status: statusCode,
+        headers: { "Content-Type": "application/json" },
+      });
+    },
+    calls,
+  };
+}
+
+// ─── Sample data ───────────────────────────────────────────────────────────────
+
+const SAMPLE_THREADS = {
+  threads: [
+    {
+      id: THREAD_ID,
+      agentId: "agent-1",
+      memberId: "member-1",
+      title: "Test Thread",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    },
+  ],
+  total: 1,
+  limit: 50,
+  offset: 0,
+};
+
+const SAMPLE_MESSAGE = {
+  id: MESSAGE_ID,
+  threadId: THREAD_ID,
+  role: "user",
+  body: "Hello!",
+  claimedBy: "agent-1",
+  claimedAt: new Date().toISOString(),
+  heartbeatAt: null,
+  cancelRequestedAt: null,
+  repliedAt: null,
+  tokens: null,
+  costUsd: null,
+  attachmentFilename: null,
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+};
+
+const SAMPLE_REPLY_RESULT = {
+  userMessage: SAMPLE_MESSAGE,
+  assistantMessage: {
+    ...SAMPLE_MESSAGE,
+    id: "msg-assist-1",
+    role: "assistant",
+    body: "Hi there!",
+    claimedBy: null,
+    claimedAt: null,
+  },
+};
+
+// ─── listThreads ───────────────────────────────────────────────────────────────
+
+describe("HttpChatServiceClient.listThreads", () => {
+  it("returns threads list on 200", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(200, SAMPLE_THREADS),
+    });
+
+    const result = await client.listThreads({});
+    expect(result.threads).toHaveLength(1);
+    expect(result.threads[0].id).toBe(THREAD_ID);
+    expect(result.total).toBe(1);
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_THREADS);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.listThreads({});
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].headers.authorization).toBe(`Bearer ${TOKEN}`);
+  });
+
+  it("calls GET /threads with agentId query param", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_THREADS);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.listThreads({ agentId: "agent-1", limit: 10, offset: 5 });
+
+    expect(calls[0].method).toBe("GET");
+    const url = new URL(calls[0].url);
+    expect(url.pathname).toBe("/threads");
+    expect(url.searchParams.get("agentId")).toBe("agent-1");
+    expect(url.searchParams.get("limit")).toBe("10");
+    expect(url.searchParams.get("offset")).toBe("5");
+  });
+
+  it("throws ChatServiceClientError on non-2xx", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(500, { error: "Internal server error" }),
+    });
+
+    const err = await client.listThreads({}).catch((e) => e);
+    expect(err).toBeInstanceOf(ChatServiceClientError);
+    expect(err.statusCode).toBe(500);
+  });
+
+  it("throws ChatServiceClientError on 401", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(401, { error: "Unauthorized" }),
+    });
+
+    const err = await client.listThreads({}).catch((e) => e);
+    expect(err).toBeInstanceOf(ChatServiceClientError);
+    expect(err.statusCode).toBe(401);
+  });
+
+  it("omits query params when not provided", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_THREADS);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.listThreads({});
+
+    const url = new URL(calls[0].url);
+    expect(url.searchParams.has("agentId")).toBe(false);
+    expect(url.searchParams.has("limit")).toBe(false);
+    expect(url.searchParams.has("offset")).toBe(false);
+  });
+});
+
+// ─── claimMessage ──────────────────────────────────────────────────────────────
+
+describe("HttpChatServiceClient.claimMessage", () => {
+  it("returns claimed message on 200", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(200, SAMPLE_MESSAGE),
+    });
+
+    const result = await client.claimMessage(THREAD_ID);
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe(MESSAGE_ID);
+    expect(result?.role).toBe("user");
+  });
+
+  it("returns null on 404 (no unclaimed messages)", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(404, { error: "no unclaimed messages in thread" }),
+    });
+
+    const result = await client.claimMessage(THREAD_ID);
+    expect(result).toBeNull();
+  });
+
+  it("calls POST /threads/:threadId/messages/claim", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_MESSAGE);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.claimMessage(THREAD_ID);
+
+    expect(calls[0].method).toBe("POST");
+    const url = new URL(calls[0].url);
+    expect(url.pathname).toBe(`/threads/${THREAD_ID}/messages/claim`);
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_MESSAGE);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.claimMessage(THREAD_ID);
+
+    expect(calls[0].headers.authorization).toBe(`Bearer ${TOKEN}`);
+  });
+
+  it("throws ChatServiceClientError on 500", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(500, { error: "Internal server error" }),
+    });
+
+    const err = await client.claimMessage(THREAD_ID).catch((e) => e);
+    expect(err).toBeInstanceOf(ChatServiceClientError);
+    expect(err.statusCode).toBe(500);
+  });
+});
+
+// ─── heartbeat ──────────────────────────────────────────────────────────────────
+
+describe("HttpChatServiceClient.heartbeat", () => {
+  it("resolves to { cancelRequested: false } when the message has no cancel request", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(200, {
+        ...SAMPLE_MESSAGE,
+        cancelRequestedAt: null,
+      }),
+    });
+
+    const result = await client.heartbeat(THREAD_ID, MESSAGE_ID);
+    expect(result.cancelRequested).toBe(false);
+  });
+
+  it("derives cancelRequested=true from a non-null cancelRequestedAt", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(200, {
+        ...SAMPLE_MESSAGE,
+        cancelRequestedAt: new Date().toISOString(),
+      }),
+    });
+
+    const result = await client.heartbeat(THREAD_ID, MESSAGE_ID);
+    expect(result.cancelRequested).toBe(true);
+  });
+
+  it("calls POST /threads/:threadId/messages/:messageId/heartbeat", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_MESSAGE);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.heartbeat(THREAD_ID, MESSAGE_ID);
+
+    expect(calls[0].method).toBe("POST");
+    const url = new URL(calls[0].url);
+    expect(url.pathname).toBe(
+      `/threads/${THREAD_ID}/messages/${MESSAGE_ID}/heartbeat`,
+    );
+  });
+
+  it("throws ChatServiceClientError on non-2xx", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(404, { error: "message not found" }),
+    });
+
+    const err = await client.heartbeat(THREAD_ID, MESSAGE_ID).catch((e) => e);
+    expect(err).toBeInstanceOf(ChatServiceClientError);
+    expect(err.statusCode).toBe(404);
+  });
+});
+
+// ─── replyToMessage ────────────────────────────────────────────────────────────
+
+describe("HttpChatServiceClient.replyToMessage", () => {
+  it("returns reply result on 201", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(201, SAMPLE_REPLY_RESULT),
+    });
+
+    const result = await client.replyToMessage(THREAD_ID, MESSAGE_ID, {
+      body: "Hi there!",
+    });
+    expect(result.assistantMessage.body).toBe("Hi there!");
+    expect(result.userMessage.id).toBe(MESSAGE_ID);
+  });
+
+  it("calls POST /threads/:threadId/messages/:messageId/reply", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, { body: "Hi!" });
+
+    expect(calls[0].method).toBe("POST");
+    const url = new URL(calls[0].url);
+    expect(url.pathname).toBe(
+      `/threads/${THREAD_ID}/messages/${MESSAGE_ID}/reply`,
+    );
+  });
+
+  it("sends body, tokens, and costUsd in request body", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    const tokens = { input_tokens: 100, output_tokens: 50 };
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, {
+      body: "reply text",
+      tokens,
+      costUsd: 0.001,
+    });
+
+    expect(calls[0].body).toEqual({
+      body: "reply text",
+      tokens,
+      costUsd: 0.001,
+    });
+  });
+
+  it("sends errorKind in the request body when provided", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, {
+      body: "Cancelled.",
+      errorKind: "cancelled",
+    });
+
+    expect(calls[0].body).toEqual({
+      body: "Cancelled.",
+      errorKind: "cancelled",
+    });
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, { body: "reply" });
+
+    expect(calls[0].headers.authorization).toBe(`Bearer ${TOKEN}`);
+  });
+
+  it("throws ChatServiceClientError on non-2xx", async () => {
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fakeFetch(400, { error: "bad request" }),
+    });
+
+    const err = await client
+      .replyToMessage(THREAD_ID, MESSAGE_ID, { body: "reply" })
+      .catch((e) => e);
+    expect(err).toBeInstanceOf(ChatServiceClientError);
+    expect(err.statusCode).toBe(400);
+  });
+
+  it("base64-encodes attachmentBytes and sends attachmentFilename/attachmentSize", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    const attachmentBytes = new Uint8Array([1, 2, 3, 4]);
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, {
+      body: "Here you go",
+      attachmentFilename: "response.wav",
+      attachmentSize: attachmentBytes.length,
+      attachmentBytes,
+    });
+
+    expect(calls[0].body).toEqual({
+      body: "Here you go",
+      attachmentFilename: "response.wav",
+      attachmentSize: 4,
+      attachmentBytes: Buffer.from(attachmentBytes).toString("base64"),
+    });
+  });
+
+  it("omits attachment fields entirely when not provided", async () => {
+    const { fn, calls } = capturingFetch(201, SAMPLE_REPLY_RESULT);
+    const client = new HttpChatServiceClient({
+      baseUrl: BASE_URL,
+      token: TOKEN,
+      fetchFn: fn,
+    });
+
+    await client.replyToMessage(THREAD_ID, MESSAGE_ID, {
+      body: "no attachment",
+    });
+
+    const body = calls[0].body as Record<string, unknown>;
+    expect(body.attachmentFilename).toBeUndefined();
+    expect(body.attachmentSize).toBeUndefined();
+    expect(body.attachmentBytes).toBeUndefined();
+  });
+});
+
+// ─── ChatServiceClientError ────────────────────────────────────────────────────
+
+describe("ChatServiceClientError", () => {
+  it("has correct name and statusCode", () => {
+    const err = new ChatServiceClientError(503, "Service unavailable");
+    expect(err.name).toBe("ChatServiceClientError");
+    expect(err.statusCode).toBe(503);
+    expect(err.message).toBe("Service unavailable");
+    expect(err).toBeInstanceOf(Error);
+  });
+});

package/log-prefix.ts

@@ -0,0 +1,12 @@
+// Builds a console log prefix, tagging lines with the agent ID (when set) so
+// they're attributable in an aggregated multi-agent log view.
+export function buildLogPrefix(
+  agentId: string | undefined,
+  timestamp: string,
+): string {
+  const timestampPart = `[${timestamp}]`;
+  if (!agentId) {
+    return timestampPart;
+  }
+  return `${timestampPart} [agent:${agentId}]`;
+}

package/log-prefix.unit.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { buildLogPrefix } from "./log-prefix.ts";
+
+describe("buildLogPrefix", () => {
+  test("returns timestamp only when agentId is undefined, with no 'undefined' literal", () => {
+    const timestamp = "2026-07-09T09:00:00.000Z";
+    const prefix = buildLogPrefix(undefined, timestamp);
+    expect(prefix).toBe(`[${timestamp}]`);
+    expect(prefix).not.toContain("undefined");
+  });
+
+  test("returns timestamp only when agentId is empty string", () => {
+    const timestamp = "2026-07-09T09:00:00.000Z";
+    const prefix = buildLogPrefix("", timestamp);
+    expect(prefix).toBe(`[${timestamp}]`);
+  });
+
+  test("appends [agent:ID] after the timestamp when agentId is set", () => {
+    const timestamp = "2026-07-09T09:00:00.123Z";
+    const agentId = "shipwright-prod-us-east-1";
+    const prefix = buildLogPrefix(agentId, timestamp);
+    expect(prefix).toBe(`[${timestamp}] [agent:${agentId}]`);
+  });
+});