@posthog/agent 2.1.71 → 2.1.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.71",
+  "version": "2.1.83",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -63,7 +63,6 @@
     "node": ">=20.0.0"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.27.8",
     "@types/bun": "latest",
     "@types/tar": "^6.1.13",
     "minimatch": "^10.0.3",
@@ -88,8 +87,6 @@
     "@opentelemetry/semantic-conventions": "^1.28.0",
     "@types/jsonwebtoken": "^9.0.10",
     "commander": "^14.0.2",
-    "diff": "^8.0.2",
-    "dotenv": "^17.2.3",
     "hono": "^4.11.7",
     "jsonwebtoken": "^9.0.2",
     "tar": "^7.5.0",

package/src/acp-extensions.ts

@@ -62,101 +62,3 @@ export const POSTHOG_NOTIFICATIONS = {
   /** Marks a boundary for log compaction */
   COMPACT_BOUNDARY: "_posthog/compact_boundary",
 } as const;
-
-export type PostHogNotificationType =
-  (typeof POSTHOG_NOTIFICATIONS)[keyof typeof POSTHOG_NOTIFICATIONS];
-
-// --- Payload types for each notification ---
-
-export interface BranchCreatedPayload {
-  branch: string;
-}
-
-export interface RunStartedPayload {
-  sessionId: string;
-  runId: string;
-  taskId?: string;
-}
-
-export interface TaskCompletePayload {
-  sessionId: string;
-  taskId: string;
-}
-
-export interface ErrorNotificationPayload {
-  sessionId: string;
-  message: string;
-  error?: unknown;
-}
-
-export interface ConsoleNotificationPayload {
-  sessionId: string;
-  level: "debug" | "info" | "warn" | "error";
-  message: string;
-}
-
-export interface SdkSessionPayload {
-  taskRunId: string;
-  sessionId: string;
-  adapter: "claude" | "codex";
-}
-
-export interface TreeSnapshotPayload {
-  treeHash: string;
-  baseCommit: string | null;
-  archiveUrl?: string;
-  changes: Array<{ path: string; status: "A" | "M" | "D" }>;
-  timestamp: string;
-  interrupted?: boolean;
-  device?: {
-    type: "local" | "cloud";
-    name?: string;
-  };
-}
-
-export interface ModeChangePayload {
-  mode: "interactive" | "background";
-  previous_mode: "interactive" | "background";
-}
-
-export interface SessionResumePayload {
-  sessionId: string;
-  fromSnapshot?: string;
-}
-
-export interface UserMessagePayload {
-  content: string;
-}
-
-export interface StatusPayload {
-  sessionId: string;
-  status: string;
-  message?: string;
-}
-
-export interface TaskNotificationPayload {
-  sessionId: string;
-  type: string;
-  message?: string;
-  data?: Record<string, unknown>;
-}
-
-export interface CompactBoundaryPayload {
-  sessionId: string;
-  timestamp: string;
-}
-
-export type PostHogNotificationPayload =
-  | BranchCreatedPayload
-  | RunStartedPayload
-  | TaskCompletePayload
-  | ErrorNotificationPayload
-  | ConsoleNotificationPayload
-  | SdkSessionPayload
-  | TreeSnapshotPayload
-  | ModeChangePayload
-  | SessionResumePayload
-  | UserMessagePayload
-  | StatusPayload
-  | TaskNotificationPayload
-  | CompactBoundaryPayload;

package/src/adapters/acp-connection.ts

@@ -13,7 +13,7 @@ import {
 import { ClaudeAcpAgent } from "./claude/claude-agent.js";
 import { type CodexProcessOptions, spawnCodexProcess } from "./codex/spawn.js";
 
-export type AgentAdapter = "claude" | "codex";
+type AgentAdapter = "claude" | "codex";
 
 export type AcpConnectionConfig = {
   adapter?: AgentAdapter;
@@ -170,16 +170,17 @@ function createClaudeConnection(config: AcpConnectionConfig): AcpConnection {
       });
     }
 
+    const taskRunId = config.taskRunId;
     agentWritable = createTappedWritableStream(streams.agent.writable, {
       onMessage: (line) => {
-        logWriter.appendRawLine(config.taskRunId!, line);
+        logWriter.appendRawLine(taskRunId, line);
       },
       logger,
     });
 
     clientWritable = createTappedWritableStream(streams.client.writable, {
       onMessage: (line) => {
-        logWriter.appendRawLine(config.taskRunId!, line);
+        logWriter.appendRawLine(taskRunId, line);
       },
       logger,
     });
@@ -425,8 +426,8 @@ function createCodexConnection(config: AcpConnectionConfig): AcpConnection {
 
   const shouldTapLogs = config.taskRunId && logWriter;
 
-  if (shouldTapLogs) {
-    const taskRunId = config.taskRunId!;
+  if (shouldTapLogs && config.taskRunId) {
+    const taskRunId = config.taskRunId;
     if (!logWriter.isRegistered(taskRunId)) {
       logWriter.register(taskRunId, {
         taskId: config.taskId ?? taskRunId,

package/src/adapters/claude/claude-agent.ts

@@ -181,7 +181,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
 
     if (meta?.taskRunId) {
       await this.client.extNotification("_posthog/sdk_session", {
-        taskRunId: meta.taskRunId!,
+        taskRunId: meta.taskRunId,
         sessionId,
         adapter: "claude",
       });

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -5,7 +5,10 @@ import type {
 } from "@agentclientprotocol/sdk";
 import { RequestError } from "@agentclientprotocol/sdk";
 import type {
+  SDKAssistantMessage,
+  SDKMessage,
   SDKPartialAssistantMessage,
+  SDKResultMessage,
   SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
 import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
@@ -357,7 +360,7 @@ function streamEventToAcpNotifications(
 }
 
 export async function handleSystemMessage(
-  message: any,
+  message: Extract<SDKMessage, { type: "system" }>,
   context: MessageHandlerContext,
 ): Promise<void> {
   const { sessionId, client, logger } = context;
@@ -409,7 +412,7 @@ export async function handleSystemMessage(
 }
 
 export function handleResultMessage(
-  message: any,
+  message: SDKResultMessage,
   context: MessageHandlerContext,
 ): { shouldStop: boolean; stopReason?: string; error?: Error } {
   const { session } = context;
@@ -556,7 +559,7 @@ function filterMessageContent(
 }
 
 export async function handleUserAssistantMessage(
-  message: SDKUserMessage | { type: "assistant"; message: any },
+  message: SDKUserMessage | SDKAssistantMessage,
   context: MessageHandlerContext,
 ): Promise<{ shouldStop?: boolean; error?: Error }> {
   const { session, sessionId, client, toolUseCache, fileContentCache, logger } =

package/src/adapters/claude/mcp/tool-metadata.ts

@@ -1,4 +1,7 @@
-import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  McpHttpServerConfig,
+  McpServerConfig,
+} from "@anthropic-ai/claude-agent-sdk";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
@@ -16,17 +19,17 @@ function buildToolKey(serverName: string, toolName: string): string {
 
 function isHttpMcpServer(
   config: McpServerConfig,
-): config is McpServerConfig & { type: "http"; url: string } {
-  return config.type === "http" && typeof (config as any).url === "string";
+): config is McpHttpServerConfig {
+  return config.type === "http" && typeof config.url === "string";
 }
 
 async function fetchToolsFromHttpServer(
   _serverName: string,
-  config: McpServerConfig & { type: "http"; url: string },
+  config: McpHttpServerConfig,
 ): Promise<Tool[]> {
   const transport = new StreamableHTTPClientTransport(new URL(config.url), {
     requestInit: {
-      headers: (config as any).headers || {},
+      headers: config.headers ?? {},
     },
   });
 

package/src/adapters/claude/permissions/permission-handlers.ts

@@ -192,7 +192,7 @@ async function applyPlanApproval(
 async function handleEnterPlanModeTool(
   context: ToolHandlerContext,
 ): Promise<ToolPermissionResult> {
-  const { session, toolInput, logger } = context;
+  const { session, toolInput } = context;
 
   session.permissionMode = "plan";
   await session.query.setPermissionMode("plan");
@@ -325,6 +325,7 @@ async function handleDefaultPermissionFlow(
     toolName,
     toolInput as Record<string, unknown>,
     session?.cwd,
+    suggestions,
   );
 
   const response = await client.requestPermission({

package/src/adapters/claude/permissions/permission-options.ts

@@ -1,3 +1,4 @@
+import type { PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
 import { BASH_TOOLS, READ_TOOLS, SEARCH_TOOLS, WRITE_TOOLS } from "../tools.js";
 
 export interface PermissionOption {
@@ -24,13 +25,21 @@ export function buildPermissionOptions(
   toolName: string,
   toolInput: Record<string, unknown>,
   cwd?: string,
+  suggestions?: PermissionUpdate[],
 ): PermissionOption[] {
   if (BASH_TOOLS.has(toolName)) {
+    const rawRuleContent = suggestions
+      ?.flatMap((s) => ("rules" in s ? s.rules : []))
+      .find((r) => r.toolName === "Bash" && r.ruleContent)?.ruleContent;
+    const ruleContent = rawRuleContent?.replace(/:?\*$/, "");
+
     const command = toolInput?.command as string | undefined;
     const cmdName = command?.split(/\s+/)[0] ?? "this command";
     const cwdLabel = cwd ? ` in ${cwd}` : "";
+    const label = ruleContent ?? `\`${cmdName}\` commands`;
+
     return permissionOptions(
-      `Yes, and don't ask again for \`${cmdName}\` commands${cwdLabel}`,
+      `Yes, and don't ask again for ${label}${cwdLabel}`,
     );
   }
 

package/src/adapters/claude/session/options.ts

@@ -152,9 +152,15 @@ function buildSpawnWrapper(
       });
     }
 
+    if (!child.stdin || !child.stdout) {
+      throw new Error(
+        `Failed to get stdio streams for spawned process (pid=${child.pid})`,
+      );
+    }
+
     return {
-      stdin: child.stdin!,
-      stdout: child.stdout!,
+      stdin: child.stdin,
+      stdout: child.stdout,
       get killed() {
         return child.killed;
       },
@@ -164,12 +170,15 @@ function buildSpawnWrapper(
       kill(signal: NodeJS.Signals) {
         return child.kill(signal);
       },
+      // biome-ignore lint/suspicious/noExplicitAny: ChildProcess event listener types require any[]
       on(event: "exit" | "error", listener: (...args: any[]) => void) {
         child.on(event, listener);
       },
+      // biome-ignore lint/suspicious/noExplicitAny: ChildProcess event listener types require any[]
       once(event: "exit" | "error", listener: (...args: any[]) => void) {
         child.once(event, listener);
       },
+      // biome-ignore lint/suspicious/noExplicitAny: ChildProcess event listener types require any[]
       off(event: "exit" | "error", listener: (...args: any[]) => void) {
         child.off(event, listener);
       },

package/src/agent.ts

@@ -7,7 +7,7 @@ import {
   DEFAULT_GATEWAY_MODEL,
   fetchArrayModels,
 } from "./gateway-models.js";
-import { PostHogAPIClient } from "./posthog-api.js";
+import { PostHogAPIClient, type TaskRunUpdate } from "./posthog-api.js";
 import { SessionLogWriter } from "./session-log-writer.js";
 import type { AgentConfig, TaskExecutionOptions } from "./types.js";
 import { Logger } from "./utils/logger.js";
@@ -142,7 +142,7 @@ export class Agent {
       throw error;
     }
 
-    const updates: any = {
+    const updates: TaskRunUpdate = {
       output: { pr_url: prUrl },
     };
     if (branchName) {

package/src/gateway-models.ts

@@ -79,13 +79,6 @@ export function isAnthropicModel(model: GatewayModel): boolean {
   return model.id.startsWith("claude-") || model.id.startsWith("anthropic/");
 }
 
-export async function fetchArrayModelIds(
-  options?: FetchGatewayModelsOptions,
-): Promise<string[]> {
-  const models = await fetchArrayModels(options);
-  return models.map((model) => model.id);
-}
-
 export interface ArrayModelInfo {
   id: string;
   owned_by?: string;

package/src/index.ts

@@ -1,79 +1 @@
-export type {
-  BranchCreatedPayload,
-  CompactBoundaryPayload,
-  ConsoleNotificationPayload,
-  ErrorNotificationPayload,
-  ModeChangePayload,
-  PostHogNotificationPayload,
-  PostHogNotificationType,
-  RunStartedPayload,
-  SdkSessionPayload,
-  SessionResumePayload,
-  StatusPayload,
-  TaskCompletePayload,
-  TaskNotificationPayload,
-  TreeSnapshotPayload,
-  UserMessagePayload,
-} from "./acp-extensions.js";
-export { POSTHOG_NOTIFICATIONS } from "./acp-extensions.js";
-export type {
-  AcpConnection,
-  AcpConnectionConfig,
-  AgentAdapter,
-  InProcessAcpConnection,
-} from "./adapters/acp-connection.js";
-export { createAcpConnection } from "./adapters/acp-connection.js";
-export {
-  fetchMcpToolMetadata,
-  isMcpToolReadOnly,
-} from "./adapters/claude/mcp/tool-metadata.js";
-export type { CodexProcessOptions } from "./adapters/codex/spawn.js";
-export { Agent } from "./agent.js";
-export {
-  type ArrayModelInfo,
-  BLOCKED_MODELS,
-  DEFAULT_GATEWAY_MODEL,
-  type FetchGatewayModelsOptions,
-  fetchArrayModels,
-  fetchGatewayModels,
-  formatGatewayModelName,
-  type GatewayModel,
-  getProviderName,
-  isAnthropicModel,
-} from "./gateway-models.js";
-export type { OtelLogConfig, SessionContext } from "./otel-log-writer.js";
-export { OtelLogWriter } from "./otel-log-writer.js";
-export { PostHogAPIClient } from "./posthog-api.js";
-export type {
-  ConversationTurn,
-  ResumeConfig,
-  ResumeState,
-  ToolCallInfo,
-} from "./resume.js";
-export { conversationToPromptHistory, resumeFromLog } from "./resume.js";
-export type { SessionLogWriterOptions } from "./session-log-writer.js";
-export { SessionLogWriter } from "./session-log-writer.js";
-export type { TreeSnapshot, TreeTrackerConfig } from "./tree-tracker.js";
-export {
-  isCommitOnRemote,
-  TreeTracker,
-  validateForCloudHandoff,
-} from "./tree-tracker.js";
-export type {
-  AgentConfig,
-  AgentMode,
-  DeviceInfo,
-  FileChange,
-  FileStatus,
-  LogLevel,
-  OnLogCallback,
-  OtelTransportConfig,
-  StoredEntry,
-  StoredNotification,
-  Task,
-  TaskRun,
-  TreeSnapshotEvent,
-} from "./types.js";
-export { getLlmGatewayUrl } from "./utils/gateway.js";
-export type { LoggerConfig } from "./utils/logger.js";
-export { Logger } from "./utils/logger.js";
+export { isMcpToolReadOnly } from "./adapters/claude/mcp/tool-metadata.js";

package/src/sagas/apply-snapshot-saga.ts

@@ -33,27 +33,30 @@ export class ApplySnapshotSaga extends Saga<
       throw new Error("Cannot apply snapshot: no archive URL");
     }
 
+    const archiveUrl = snapshot.archiveUrl;
+
     await this.step({
       name: "create_tmp_dir",
       execute: () => mkdir(tmpDir, { recursive: true }),
       rollback: async () => {},
     });
 
-    this.archivePath = join(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    const archivePath = join(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    this.archivePath = archivePath;
     await this.step({
       name: "download_archive",
       execute: async () => {
         const arrayBuffer = await apiClient.downloadArtifact(
           taskId,
           runId,
-          snapshot.archiveUrl!,
+          archiveUrl,
         );
         if (!arrayBuffer) {
           throw new Error("Failed to download archive");
         }
         const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
         const binaryContent = Buffer.from(base64Content, "base64");
-        await writeFile(this.archivePath!, binaryContent);
+        await writeFile(archivePath, binaryContent);
       },
       rollback: async () => {
         if (this.archivePath) {

package/src/sagas/capture-tree-saga.test.ts

@@ -583,7 +583,7 @@ describe("CaptureTreeSaga", () => {
     });
 
     it("handles symlinks", async () => {
-      const { symlink, lstat } = await import("node:fs/promises");
+      const { symlink } = await import("node:fs/promises");
 
       await repo.writeFile("target.txt", "symlink target content");
       await symlink("target.txt", join(repo.path, "link.txt"));

package/src/test/mocks/msw-handlers.ts

@@ -1,7 +1,4 @@
 import { HttpResponse, http } from "msw";
-import { SseController } from "../controllers/sse-controller.js";
-
-export { SseController };
 
 type AnyHttpResponse = Response | ReturnType<typeof HttpResponse.json>;
 

package/dist/agent-DK1apkaG.d.ts

@@ -1,133 +0,0 @@
-import { AgentSideConnection } from '@agentclientprotocol/sdk';
-import { StoredNotification, ProcessSpawnedCallback, AgentConfig, TaskExecutionOptions } from './types.js';
-import { L as Logger } from './logger-DDBiMOOD.js';
-import { PostHogAPIClient } from './posthog-api.js';
-
-interface OtelLogConfig {
-    /** PostHog ingest host, e.g., "https://us.i.posthog.com" */
-    posthogHost: string;
-    /** Project API key, e.g., "phc_xxx" */
-    apiKey: string;
-    /** Batch flush interval in ms (default: 500) */
-    flushIntervalMs?: number;
-    /** Override the logs endpoint path (default: /i/v1/agent-logs) */
-    logsPath?: string;
-}
-/**
- * Session context for resource attributes.
- * These are set once per OTEL logger instance and indexed via resource_fingerprint
- */
-interface SessionContext {
-    /** Parent task grouping - all runs for a task share this */
-    taskId: string;
-    /** Primary conversation identifier - all events in a run share this */
-    runId: string;
-    /** Deployment environment - "local" for desktop, "cloud" for cloud sandbox */
-    deviceType?: "local" | "cloud";
-}
-declare class OtelLogWriter {
-    private loggerProvider;
-    private logger;
-    constructor(config: OtelLogConfig, sessionContext: SessionContext, _debugLogger?: Logger);
-    /**
-     * Emit an agent event to PostHog Logs via OTEL.
-     */
-    emit(entry: {
-        notification: StoredNotification;
-    }): void;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-interface SessionLogWriterOptions {
-    /** PostHog API client for log persistence */
-    posthogAPI?: PostHogAPIClient;
-    /** Logger instance */
-    logger?: Logger;
-    /** Local cache path for instant log loading (e.g., ~/.twig) */
-    localCachePath?: string;
-}
-declare class SessionLogWriter {
-    private static readonly FLUSH_DEBOUNCE_MS;
-    private static readonly FLUSH_MAX_INTERVAL_MS;
-    private static readonly MAX_FLUSH_RETRIES;
-    private static readonly MAX_RETRY_DELAY_MS;
-    private posthogAPI?;
-    private pendingEntries;
-    private flushTimeouts;
-    private lastFlushAttemptTime;
-    private retryCounts;
-    private sessions;
-    private messageCounts;
-    private logger;
-    private localCachePath?;
-    constructor(options?: SessionLogWriterOptions);
-    flushAll(): Promise<void>;
-    register(sessionId: string, context: SessionContext): void;
-    isRegistered(sessionId: string): boolean;
-    appendRawLine(sessionId: string, line: string): void;
-    flush(sessionId: string): Promise<void>;
-    private isAgentMessageChunk;
-    private extractChunkText;
-    private emitCoalescedMessage;
-    private scheduleFlush;
-    private writeToLocalCache;
-}
-
-type StreamPair = {
-    readable: globalThis.ReadableStream<Uint8Array>;
-    writable: globalThis.WritableStream<Uint8Array>;
-};
-
-interface CodexProcessOptions {
-    cwd?: string;
-    apiBaseUrl?: string;
-    apiKey?: string;
-    model?: string;
-    binaryPath?: string;
-    logger?: Logger;
-    processCallbacks?: ProcessSpawnedCallback;
-}
-
-type AgentAdapter = "claude" | "codex";
-type AcpConnectionConfig = {
-    adapter?: AgentAdapter;
-    logWriter?: SessionLogWriter;
-    taskRunId?: string;
-    taskId?: string;
-    /** Deployment environment - "local" for desktop, "cloud" for cloud sandbox */
-    deviceType?: "local" | "cloud";
-    logger?: Logger;
-    processCallbacks?: ProcessSpawnedCallback;
-    codexOptions?: CodexProcessOptions;
-    allowedModelIds?: Set<string>;
-};
-type AcpConnection = {
-    agentConnection?: AgentSideConnection;
-    clientStreams: StreamPair;
-    cleanup: () => Promise<void>;
-};
-type InProcessAcpConnection = AcpConnection;
-/**
- * Creates an ACP connection with the specified agent framework.
- *
- * @param config - Configuration including framework selection
- * @returns Connection with agent and client streams
- */
-declare function createAcpConnection(config?: AcpConnectionConfig): AcpConnection;
-
-declare class Agent {
-    private posthogAPI?;
-    private logger;
-    private acpConnection?;
-    private taskRunId?;
-    private sessionLogWriter?;
-    constructor(config: AgentConfig);
-    private _configureLlmGateway;
-    run(taskId: string, taskRunId: string, options?: TaskExecutionOptions): Promise<InProcessAcpConnection>;
-    attachPullRequestToTask(taskId: string, prUrl: string, branchName?: string): Promise<void>;
-    flushAllLogs(): Promise<void>;
-    cleanup(): Promise<void>;
-}
-
-export { type AcpConnection as A, type CodexProcessOptions as C, type InProcessAcpConnection as I, type OtelLogConfig as O, type SessionContext as S, type AcpConnectionConfig as a, Agent as b, type AgentAdapter as c, OtelLogWriter as d, SessionLogWriter as e, type SessionLogWriterOptions as f, createAcpConnection as g };

package/dist/logger-DDBiMOOD.d.ts

@@ -1,24 +0,0 @@
-import { OnLogCallback } from './types.js';
-
-interface LoggerConfig {
-    debug?: boolean;
-    prefix?: string;
-    scope?: string;
-    onLog?: OnLogCallback;
-}
-declare class Logger {
-    private debugEnabled;
-    private prefix;
-    private scope;
-    private onLog?;
-    constructor(config?: LoggerConfig);
-    private formatMessage;
-    private emitLog;
-    error(message: string, error?: Error | unknown): void;
-    warn(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    debug(message: string, data?: unknown): void;
-    child(childPrefix: string): Logger;
-}
-
-export { Logger as L, type LoggerConfig as a };