@posthog/agent 2.1.5 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.5",
+  "version": "2.1.8",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

package/src/agent.ts

@@ -32,24 +32,11 @@ export class Agent {
       this.posthogAPI = new PostHogAPIClient(config.posthog);
     }
 
-    if (!config.skipLogPersistence) {
-      if (config.otelTransport) {
-        // OTEL pipeline: use OtelLogWriter only (no S3 writer)
-        this.sessionLogWriter = new SessionLogWriter({
-          otelConfig: {
-            posthogHost: config.otelTransport.host,
-            apiKey: config.otelTransport.apiKey,
-            logsPath: config.otelTransport.logsPath,
-          },
-          logger: this.logger.child("SessionLogWriter"),
-        });
-      } else if (config.posthog) {
-        // Legacy: use S3 writer via PostHog API
-        this.sessionLogWriter = new SessionLogWriter({
-          posthogAPI: this.posthogAPI,
-          logger: this.logger.child("SessionLogWriter"),
-        });
-      }
+    if (config.posthog && !config.skipLogPersistence) {
+      this.sessionLogWriter = new SessionLogWriter({
+        posthogAPI: this.posthogAPI,
+        logger: this.logger.child("SessionLogWriter"),
+      });
     }
   }
 

package/src/server/agent-server.ts

@@ -464,18 +464,14 @@ export class AgentServer {
       logger: new Logger({ debug: true, prefix: "[TreeTracker]" }),
     });
 
-    const _posthogAPI = new PostHogAPIClient({
+    const posthogAPI = new PostHogAPIClient({
       apiUrl: this.config.apiUrl,
       projectId: this.config.projectId,
       getApiKey: () => this.config.apiKey,
     });
 
     const logWriter = new SessionLogWriter({
-      otelConfig: {
-        posthogHost: this.config.apiUrl,
-        apiKey: this.config.apiKey,
-        logsPath: "/i/v1/agent-logs",
-      },
+      posthogAPI,
       logger: new Logger({ debug: true, prefix: "[SessionLogWriter]" }),
     });
 

package/src/session-log-writer.test.ts

@@ -1,39 +1,31 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { OtelLogWriter } from "./otel-log-writer.js";
+import type { PostHogAPIClient } from "./posthog-api.js";
 import { SessionLogWriter } from "./session-log-writer.js";
-
-// Mock the OtelLogWriter
-vi.mock("./otel-log-writer.js", () => ({
-  OtelLogWriter: vi.fn(),
-}));
+import type { StoredNotification } from "./types.js";
+
+function makeSessionUpdate(
+  sessionUpdate: string,
+  extra: Record<string, unknown> = {},
+): string {
+  return JSON.stringify({
+    jsonrpc: "2.0",
+    method: "session/update",
+    params: { update: { sessionUpdate, ...extra } },
+  });
+}
 
 describe("SessionLogWriter", () => {
   let logWriter: SessionLogWriter;
-  let mockEmit: ReturnType<typeof vi.fn>;
-  let mockFlush: ReturnType<typeof vi.fn>;
-  let mockShutdown: ReturnType<typeof vi.fn>;
+  let mockAppendLog: ReturnType<typeof vi.fn>;
+  let mockPosthogAPI: PostHogAPIClient;
 
   beforeEach(() => {
-    mockEmit = vi.fn();
-    mockFlush = vi.fn().mockResolvedValue(undefined);
-    mockShutdown = vi.fn().mockResolvedValue(undefined);
-
-    vi.mocked(OtelLogWriter).mockImplementation(
-      () =>
-        ({
-          emit: mockEmit,
-          flush: mockFlush,
-          shutdown: mockShutdown,
-        }) as unknown as OtelLogWriter,
-    );
-
-    logWriter = new SessionLogWriter({
-      otelConfig: {
-        posthogHost: "http://localhost:8000",
-        apiKey: "test-api-key",
-        logsPath: "/i/v1/agent-logs",
-      },
-    });
+    mockAppendLog = vi.fn().mockResolvedValue(undefined);
+    mockPosthogAPI = {
+      appendTaskRunLog: mockAppendLog,
+    } as unknown as PostHogAPIClient;
+
+    logWriter = new SessionLogWriter({ posthogAPI: mockPosthogAPI });
   });
 
   afterEach(() => {
@@ -41,100 +33,79 @@ describe("SessionLogWriter", () => {
   });
 
   describe("appendRawLine", () => {
-    it("emits entries immediately via OtelLogWriter", () => {
-      const sessionId = "test-session";
-      logWriter.register(sessionId, { taskId: "task-1", runId: sessionId });
+    it("queues entries for flush", async () => {
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
 
-      logWriter.appendRawLine(
-        sessionId,
-        JSON.stringify({ method: "test", params: {} }),
-      );
-      logWriter.appendRawLine(
-        sessionId,
-        JSON.stringify({ method: "test2", params: {} }),
-      );
+      logWriter.appendRawLine(sessionId, JSON.stringify({ method: "test" }));
+      logWriter.appendRawLine(sessionId, JSON.stringify({ method: "test2" }));
 
-      expect(mockEmit).toHaveBeenCalledTimes(2);
-    });
+      await logWriter.flush(sessionId);
 
-    it("wraps raw messages in StoredNotification format", () => {
-      const sessionId = "test-session";
-      logWriter.register(sessionId, { taskId: "task-1", runId: sessionId });
-
-      const message = {
-        jsonrpc: "2.0",
-        method: "session/update",
-        params: { foo: "bar" },
-      };
-      logWriter.appendRawLine(sessionId, JSON.stringify(message));
-
-      expect(mockEmit).toHaveBeenCalledTimes(1);
-      const emitArg = mockEmit.mock.calls[0][0];
-      expect(emitArg.notification.type).toBe("notification");
-      expect(emitArg.notification.timestamp).toBeDefined();
-      expect(emitArg.notification.notification).toEqual(message);
+      expect(mockAppendLog).toHaveBeenCalledTimes(1);
+      const entries: StoredNotification[] = mockAppendLog.mock.calls[0][2];
+      expect(entries).toHaveLength(2);
     });
 
-    it("ignores unregistered sessions", () => {
-      logWriter.appendRawLine(
-        "unknown-session",
-        JSON.stringify({ method: "test" }),
-      );
-
-      expect(mockEmit).not.toHaveBeenCalled();
+    it("ignores unregistered sessions", async () => {
+      logWriter.appendRawLine("unknown", JSON.stringify({ method: "test" }));
+      await logWriter.flush("unknown");
+      expect(mockAppendLog).not.toHaveBeenCalled();
     });
 
-    it("ignores invalid JSON", () => {
-      const sessionId = "test-session";
-      logWriter.register(sessionId, { taskId: "task-1", runId: sessionId });
+    it("ignores invalid JSON", async () => {
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
 
       logWriter.appendRawLine(sessionId, "not valid json {{{");
-
-      expect(mockEmit).not.toHaveBeenCalled();
+      await logWriter.flush(sessionId);
+      expect(mockAppendLog).not.toHaveBeenCalled();
     });
   });
 
-  describe("flush", () => {
-    it("calls flush on OtelLogWriter", async () => {
-      const sessionId = "test-session";
-      logWriter.register(sessionId, { taskId: "task-1", runId: sessionId });
+  describe("agent_message_chunk coalescing", () => {
+    it("coalesces consecutive chunks into a single agent_message", async () => {
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
 
-      logWriter.appendRawLine(sessionId, JSON.stringify({ method: "test" }));
-      await logWriter.flush(sessionId);
+      logWriter.appendRawLine(
+        sessionId,
+        makeSessionUpdate("agent_message_chunk", {
+          content: { type: "text", text: "Hello " },
+        }),
+      );
+      logWriter.appendRawLine(
+        sessionId,
+        makeSessionUpdate("agent_message_chunk", {
+          content: { type: "text", text: "world" },
+        }),
+      );
+      // Non-chunk event triggers flush of chunks
+      logWriter.appendRawLine(
+        sessionId,
+        makeSessionUpdate("tool_call", { toolCallId: "tc1" }),
+      );
 
-      expect(mockFlush).toHaveBeenCalledTimes(1);
-    });
+      await logWriter.flush(sessionId);
 
-    it("does nothing for unregistered sessions", async () => {
-      await logWriter.flush("unknown-session");
+      const entries: StoredNotification[] = mockAppendLog.mock.calls[0][2];
+      expect(entries).toHaveLength(2); // coalesced message + tool_call
 
-      expect(mockFlush).not.toHaveBeenCalled();
+      const coalesced = entries[0].notification;
+      expect(coalesced.params?.update).toEqual({
+        sessionUpdate: "agent_message",
+        content: { type: "text", text: "Hello world" },
+      });
     });
   });
 
   describe("register", () => {
-    it("creates OtelLogWriter with session context", () => {
-      const sessionId = "test-session";
-      const context = { taskId: "task-1", runId: sessionId };
-
-      logWriter.register(sessionId, context);
-
-      expect(OtelLogWriter).toHaveBeenCalledWith(
-        expect.objectContaining({
-          posthogHost: "http://localhost:8000",
-          apiKey: "test-api-key",
-        }),
-        context,
-        expect.anything(),
-      );
-    });
-
     it("does not re-register existing sessions", () => {
-      const sessionId = "test-session";
-      logWriter.register(sessionId, { taskId: "task-1", runId: sessionId });
-      logWriter.register(sessionId, { taskId: "task-2", runId: sessionId });
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
+      logWriter.register(sessionId, { taskId: "t2", runId: sessionId });
 
-      expect(OtelLogWriter).toHaveBeenCalledTimes(1);
+      expect(logWriter.isRegistered(sessionId)).toBe(true);
     });
   });
 });

package/src/session-log-writer.ts

@@ -1,16 +1,10 @@
-import {
-  type OtelLogConfig,
-  OtelLogWriter,
-  type SessionContext,
-} from "./otel-log-writer.js";
+import type { SessionContext } from "./otel-log-writer.js";
 import type { PostHogAPIClient } from "./posthog-api.js";
 import type { StoredNotification } from "./types.js";
 import { Logger } from "./utils/logger.js";
 
 export interface SessionLogWriterOptions {
-  /** OTEL config for creating writers per session */
-  otelConfig?: OtelLogConfig;
-  /** PostHog API client for S3 log persistence */
+  /** PostHog API client for log persistence */
   posthogAPI?: PostHogAPIClient;
   /** Logger instance */
   logger?: Logger;
@@ -23,13 +17,11 @@ interface ChunkBuffer {
 
 interface SessionState {
   context: SessionContext;
-  otelWriter?: OtelLogWriter;
   chunkBuffer?: ChunkBuffer;
 }
 
 export class SessionLogWriter {
   private posthogAPI?: PostHogAPIClient;
-  private otelConfig?: OtelLogConfig;
   private pendingEntries: Map<string, StoredNotification[]> = new Map();
   private flushTimeouts: Map<string, NodeJS.Timeout> = new Map();
   private sessions: Map<string, SessionState> = new Map();
@@ -37,7 +29,6 @@ export class SessionLogWriter {
 
   constructor(options: SessionLogWriterOptions = {}) {
     this.posthogAPI = options.posthogAPI;
-    this.otelConfig = options.otelConfig;
     this.logger =
       options.logger ??
       new Logger({ debug: false, prefix: "[SessionLogWriter]" });
@@ -56,17 +47,7 @@ export class SessionLogWriter {
       return;
     }
 
-    let otelWriter: OtelLogWriter | undefined;
-    if (this.otelConfig) {
-      // Create a dedicated OtelLogWriter for this session with resource attributes
-      otelWriter = new OtelLogWriter(
-        this.otelConfig,
-        context,
-        this.logger.child(`OtelWriter:${sessionId}`),
-      );
-    }
-
-    this.sessions.set(sessionId, { context, otelWriter });
+    this.sessions.set(sessionId, { context });
   }
 
   isRegistered(sessionId: string): boolean {
@@ -106,10 +87,6 @@ export class SessionLogWriter {
         notification: message,
       };
 
-      if (session.otelWriter) {
-        session.otelWriter.emit({ notification: entry });
-      }
-
       if (this.posthogAPI) {
         const pending = this.pendingEntries.get(sessionId) ?? [];
         pending.push(entry);
@@ -131,10 +108,6 @@ export class SessionLogWriter {
     // Emit any buffered chunks before flushing
     this.emitCoalescedMessage(sessionId, session);
 
-    if (session.otelWriter) {
-      await session.otelWriter.flush();
-    }
-
     const pending = this.pendingEntries.get(sessionId);
     if (!this.posthogAPI || !pending?.length) return;
 
@@ -196,10 +169,6 @@ export class SessionLogWriter {
       },
     };
 
-    if (session.otelWriter) {
-      session.otelWriter.emit({ notification: entry });
-    }
-
     if (this.posthogAPI) {
       const pending = this.pendingEntries.get(sessionId) ?? [];
       pending.push(entry);