@posthog/agent 2.1.70 → 2.1.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.70",
+  "version": "2.1.82",
   "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;

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

@@ -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

@@ -88,6 +88,7 @@ function buildEnvironment(): Record<string, string> {
     ...process.env,
     ELECTRON_RUN_AS_NODE: "1",
     CLAUDE_CODE_ENABLE_ASK_USER_QUESTION_TOOL: "true",
+    ENABLE_EXPERIMENTAL_MCP_CLI: "true",
   };
 }
 

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/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 };

package/src/adapters/claude/tool-meta.ts

@@ -1,143 +0,0 @@
-import { z } from "zod";
-
-const QuestionOptionSchema = z.object({
-  label: z.string(),
-  description: z.string().optional(),
-});
-
-const QuestionItemSchema = z.object({
-  question: z.string(),
-  header: z.string().optional(),
-  options: z.array(QuestionOptionSchema),
-  multiSelect: z.boolean().optional(),
-  completed: z.boolean().optional(),
-});
-
-export const QuestionMetaSchema = z.object({
-  questions: z.array(QuestionItemSchema),
-});
-
-export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
-export type QuestionItem = z.infer<typeof QuestionItemSchema>;
-export type QuestionMeta = z.infer<typeof QuestionMetaSchema>;
-
-const toolSchemas = {
-  bash: z.object({
-    command: z.string(),
-    description: z.string().optional(),
-  }),
-  edit: z.object({
-    file_path: z.string(),
-    old_string: z.string(),
-    new_string: z.string(),
-    replace_all: z.boolean().optional(),
-  }),
-  write: z.object({
-    file_path: z.string(),
-    content: z.string(),
-  }),
-  read: z.object({
-    file_path: z.string(),
-    offset: z.number().optional(),
-    limit: z.number().optional(),
-  }),
-  switch_mode: z.object({
-    plan: z.string().optional(),
-  }),
-} as const;
-
-type ToolKind = keyof typeof toolSchemas;
-const _toolKinds = Object.keys(toolSchemas) as ToolKind[];
-
-const sdkToolNameToKind: Record<string, ToolKind> = {
-  Bash: "bash",
-  Edit: "edit",
-  Write: "write",
-  Read: "read",
-  ExitPlanMode: "switch_mode",
-};
-
-const BaseTwigToolMetaSchema = z.object({
-  claudeCode: z
-    .object({
-      toolName: z.string(),
-      toolResponse: z.unknown().optional(),
-    })
-    .optional(),
-});
-
-type BaseMeta = z.infer<typeof BaseTwigToolMetaSchema>;
-
-type ToolMeta<K extends ToolKind> = BaseMeta & {
-  twigToolKind: K;
-} & { [P in K]: z.infer<(typeof toolSchemas)[K]> };
-
-export type BashToolMeta = ToolMeta<"bash">;
-export type EditToolMeta = ToolMeta<"edit">;
-export type WriteToolMeta = ToolMeta<"write">;
-export type ReadToolMeta = ToolMeta<"read">;
-export type SwitchModeToolMeta = ToolMeta<"switch_mode">;
-export type QuestionToolMeta = BaseMeta & {
-  twigToolKind: "question";
-  questions: QuestionItem[];
-};
-export type GenericToolMeta = BaseMeta & { twigToolKind?: undefined };
-
-export type TwigToolMeta =
-  | BashToolMeta
-  | EditToolMeta
-  | WriteToolMeta
-  | ReadToolMeta
-  | SwitchModeToolMeta
-  | QuestionToolMeta
-  | GenericToolMeta;
-
-export function isBashToolMeta(meta: TwigToolMeta): meta is BashToolMeta {
-  return meta.twigToolKind === "bash";
-}
-
-export function isEditToolMeta(meta: TwigToolMeta): meta is EditToolMeta {
-  return meta.twigToolKind === "edit";
-}
-
-export function isWriteToolMeta(meta: TwigToolMeta): meta is WriteToolMeta {
-  return meta.twigToolKind === "write";
-}
-
-export function isReadToolMeta(meta: TwigToolMeta): meta is ReadToolMeta {
-  return meta.twigToolKind === "read";
-}
-
-export function isSwitchModeToolMeta(
-  meta: TwigToolMeta,
-): meta is SwitchModeToolMeta {
-  return meta.twigToolKind === "switch_mode";
-}
-
-export function isQuestionToolMeta(
-  meta: TwigToolMeta,
-): meta is QuestionToolMeta {
-  return meta.twigToolKind === "question";
-}
-
-export function buildToolMeta(
-  toolName: string,
-  input: Record<string, unknown>,
-): TwigToolMeta {
-  const kind = sdkToolNameToKind[toolName];
-  if (!kind) {
-    return { claudeCode: { toolName } };
-  }
-
-  const schema = toolSchemas[kind];
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    return { claudeCode: { toolName } };
-  }
-
-  return {
-    claudeCode: { toolName },
-    twigToolKind: kind,
-    [kind]: result.data,
-  } as TwigToolMeta;
-}

package/src/test/assertions.ts

@@ -1,114 +0,0 @@
-import { expect } from "vitest";
-
-export interface NotificationEntry {
-  notification?: {
-    method?: string;
-    params?: {
-      sessionId?: string;
-      update?: {
-        sessionUpdate?: string;
-        content?: {
-          type?: string;
-          text?: string;
-        };
-      };
-    };
-  };
-}
-
-export interface NotificationMatcher {
-  method?: string;
-  text?: string;
-  sessionId?: string;
-  sessionUpdate?: string;
-}
-
-function entryMatchesNotification(
-  entry: unknown,
-  matcher: NotificationMatcher,
-): boolean {
-  const notification = (entry as NotificationEntry).notification;
-  if (!notification) return false;
-
-  if (matcher.method && notification.method !== matcher.method) {
-    return false;
-  }
-  if (
-    matcher.sessionId &&
-    notification.params?.sessionId !== matcher.sessionId
-  ) {
-    return false;
-  }
-  if (
-    matcher.sessionUpdate &&
-    notification.params?.update?.sessionUpdate !== matcher.sessionUpdate
-  ) {
-    return false;
-  }
-  if (matcher.text) {
-    const text = notification.params?.update?.content?.text;
-    if (!text || !text.includes(matcher.text)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function findNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): NotificationEntry | undefined {
-  for (const entries of appendLogCalls) {
-    for (const entry of entries) {
-      if (entryMatchesNotification(entry, matcher)) {
-        return entry as NotificationEntry;
-      }
-    }
-  }
-  return undefined;
-}
-
-export function hasNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): boolean {
-  return findNotification(appendLogCalls, matcher) !== undefined;
-}
-
-export function expectNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): NotificationEntry {
-  const found = findNotification(appendLogCalls, matcher);
-  expect(
-    found,
-    `Expected notification matching ${JSON.stringify(matcher)}`,
-  ).toBeDefined();
-  return found!;
-}
-
-export function expectNoNotification(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): void {
-  const found = findNotification(appendLogCalls, matcher);
-  expect(
-    found,
-    `Expected no notification matching ${JSON.stringify(matcher)}`,
-  ).toBeUndefined();
-}
-
-export function countNotifications(
-  appendLogCalls: unknown[][],
-  matcher: NotificationMatcher,
-): number {
-  let count = 0;
-  for (const entries of appendLogCalls) {
-    for (const entry of entries) {
-      if (entryMatchesNotification(entry, matcher)) {
-        count++;
-      }
-    }
-  }
-  return count;
-}