@posthog/agent 2.3.24 → 2.3.43

package/dist/types.d.ts

@@ -79,6 +79,7 @@ interface TaskExecutionOptions {
     repositoryPath?: string;
     adapter?: "claude" | "codex";
     model?: string;
+    gatewayUrl?: string;
     codexBinaryPath?: string;
     processCallbacks?: ProcessSpawnedCallback;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.24",
+  "version": "2.3.43",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -74,8 +74,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@posthog/git": "1.0.0",
-    "@posthog/shared": "1.0.0"
+    "@posthog/shared": "1.0.0",
+    "@posthog/git": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.15.0",

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

@@ -59,7 +59,12 @@ import { fetchMcpToolMetadata } from "./mcp/tool-metadata";
 import { canUseTool } from "./permissions/permission-handlers";
 import { getAvailableSlashCommands } from "./session/commands";
 import { parseMcpServers } from "./session/mcp-config";
-import { DEFAULT_MODEL, toSdkModelId } from "./session/models";
+import {
+  DEFAULT_MODEL,
+  getDefaultContextWindow,
+  getEffortOptions,
+  toSdkModelId,
+} from "./session/models";
 import {
   buildSessionOptions,
   buildSystemPrompt,
@@ -337,7 +342,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               (m) => m.contextWindow,
             );
             const contextWindowSize =
-              contextWindows.length > 0 ? Math.min(...contextWindows) : 200000;
+              contextWindows.length > 0
+                ? Math.min(...contextWindows)
+                : getDefaultContextWindow(this.session.modelId ?? "");
 
             // Send usage_update notification
             if (lastAssistantTotalUsage !== null) {
@@ -509,6 +516,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     const sdkModelId = toSdkModelId(params.modelId);
     await this.session.query.setModel(sdkModelId);
     this.session.modelId = params.modelId;
+    this.rebuildEffortConfigOption(params.modelId);
     await this.updateConfigOption("model", params.modelId);
     return {};
   }
@@ -559,6 +567,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       const sdkModelId = toSdkModelId(params.value);
       await this.session.query.setModel(sdkModelId);
       this.session.modelId = params.value;
+      this.rebuildEffortConfigOption(params.value);
     } else if (params.configId === "effort") {
       const newEffort = params.value as EffortLevel;
       this.session.effort = newEffort;
@@ -865,7 +874,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       description: mode.description ?? undefined,
     }));
 
-    return [
+    const configOptions: SessionConfigOption[] = [
       {
         id: "mode",
         name: "Approval Preset",
@@ -885,21 +894,67 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         category: "model" as SessionConfigOptionCategory,
         description: "Choose which model Claude should use",
       },
-      {
+    ];
+
+    const effortOptions = getEffortOptions(modelOptions.currentModelId);
+    if (effortOptions) {
+      configOptions.push({
         id: "effort",
         name: "Effort",
         type: "select",
         currentValue: currentEffort,
-        options: [
-          { value: "low", name: "Low" },
-          { value: "medium", name: "Medium" },
-          { value: "high", name: "High" },
-          { value: "max", name: "Max" },
-        ],
+        options: effortOptions,
         category: "thought_level" as SessionConfigOptionCategory,
         description: "Controls how much effort Claude puts into its response",
-      },
-    ];
+      });
+    }
+
+    return configOptions;
+  }
+
+  private rebuildEffortConfigOption(modelId: string): void {
+    const effortOptions = getEffortOptions(modelId);
+    const existingEffort = this.session.configOptions.find(
+      (o) => o.id === "effort",
+    );
+
+    if (!effortOptions) {
+      this.session.configOptions = this.session.configOptions.filter(
+        (o) => o.id !== "effort",
+      );
+      if (this.session.effort) {
+        this.session.effort = undefined;
+        this.session.queryOptions.effort = undefined;
+      }
+      return;
+    }
+
+    const currentValue = existingEffort?.currentValue ?? "high";
+    const isValidValue = effortOptions.some((o) => o.value === currentValue);
+    const resolvedValue = isValidValue ? currentValue : "high";
+
+    if (resolvedValue !== currentValue && this.session.effort) {
+      this.session.effort = resolvedValue as EffortLevel;
+      this.session.queryOptions.effort = resolvedValue as EffortLevel;
+    }
+
+    const effortConfig: SessionConfigOption = {
+      id: "effort",
+      name: "Effort",
+      type: "select",
+      currentValue: resolvedValue,
+      options: effortOptions,
+      category: "thought_level" as SessionConfigOptionCategory,
+      description: "Controls how much effort Claude puts into its response",
+    };
+
+    if (existingEffort) {
+      this.session.configOptions = this.session.configOptions.map((o) =>
+        o.id === "effort" ? effortConfig : o,
+      );
+    } else {
+      this.session.configOptions.push(effortConfig);
+    }
   }
 
   private async sendAvailableCommandsUpdate(): Promise<void> {

package/src/adapters/claude/session/jsonl-hydration.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { ContentBlock } from "@agentclientprotocol/sdk";
 import type { PostHogAPIClient } from "../../../posthog-api";
 import type { StoredEntry } from "../../../types";
+import { supports1MContext } from "./models";
 
 interface ConversationTurn {
   role: "user" | "assistant";
@@ -188,6 +189,7 @@ export function rebuildConversation(
 
 const CHARS_PER_TOKEN = 4;
 const DEFAULT_MAX_TOKENS = 150_000;
+const LARGE_CONTEXT_MAX_TOKENS = 800_000;
 
 function estimateTurnTokens(turn: ConversationTurn): number {
   let chars = 0;
@@ -546,7 +548,10 @@ export async function hydrateSessionJsonl(params: {
       return;
     }
 
-    const conversation = selectRecentTurns(allTurns);
+    const maxTokens = supports1MContext(params.model ?? "")
+      ? LARGE_CONTEXT_MAX_TOKENS
+      : DEFAULT_MAX_TOKENS;
+    const conversation = selectRecentTurns(allTurns, maxTokens);
     log.info("Selected recent turns for hydration", {
       totalTurns: allTurns.length,
       selectedTurns: conversation.length,

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

@@ -11,3 +11,53 @@ const GATEWAY_TO_SDK_MODEL: Record<string, string> = {
 export function toSdkModelId(modelId: string): string {
   return GATEWAY_TO_SDK_MODEL[modelId] ?? modelId;
 }
+
+const MODELS_WITH_1M_CONTEXT = new Set([
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+]);
+
+export function supports1MContext(modelId: string): boolean {
+  return MODELS_WITH_1M_CONTEXT.has(modelId);
+}
+
+export function getDefaultContextWindow(modelId: string): number {
+  return supports1MContext(modelId) ? 1_000_000 : 200_000;
+}
+
+const MODELS_WITH_EFFORT = new Set([
+  "claude-opus-4-5",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+]);
+
+const MODELS_WITH_MAX_EFFORT = new Set(["claude-opus-4-6"]);
+
+export function supportsEffort(modelId: string): boolean {
+  return MODELS_WITH_EFFORT.has(modelId);
+}
+
+export function supportsMaxEffort(modelId: string): boolean {
+  return MODELS_WITH_MAX_EFFORT.has(modelId);
+}
+
+interface EffortOption {
+  value: string;
+  name: string;
+}
+
+export function getEffortOptions(modelId: string): EffortOption[] | null {
+  if (!supportsEffort(modelId)) return null;
+
+  const options: EffortOption[] = [
+    { value: "low", name: "Low" },
+    { value: "medium", name: "Medium" },
+    { value: "high", name: "High" },
+  ];
+
+  if (supportsMaxEffort(modelId)) {
+    options.push({ value: "max", name: "Max" });
+  }
+
+  return options;
+}

package/src/agent.ts

@@ -5,7 +5,7 @@ import {
 import {
   BLOCKED_MODELS,
   DEFAULT_GATEWAY_MODEL,
-  fetchArrayModels,
+  fetchModelsList,
 } from "./gateway-models";
 import { PostHogAPIClient, type TaskRunUpdate } from "./posthog-api";
 import { SessionLogWriter } from "./session-log-writer";
@@ -45,7 +45,7 @@ export class Agent {
     }
   }
 
-  private _configureLlmGateway(_adapter?: "claude" | "codex"): {
+  private _configureLlmGateway(overrideUrl?: string): {
     gatewayUrl: string;
     apiKey: string;
   } | null {
@@ -54,7 +54,7 @@ export class Agent {
     }
 
     try {
-      const gatewayUrl = this.posthogAPI.getLlmGatewayUrl();
+      const gatewayUrl = overrideUrl ?? this.posthogAPI.getLlmGatewayUrl();
       const apiKey = this.posthogAPI.getApiKey();
 
       process.env.OPENAI_BASE_URL = `${gatewayUrl}/v1`;
@@ -74,7 +74,7 @@ export class Agent {
     taskRunId: string,
     options: TaskExecutionOptions = {},
   ): Promise<InProcessAcpConnection> {
-    const gatewayConfig = this._configureLlmGateway(options.adapter);
+    const gatewayConfig = this._configureLlmGateway(options.gatewayUrl);
     this.logger.info("Configured LLM gateway", {
       adapter: options.adapter,
     });
@@ -86,7 +86,7 @@ export class Agent {
         ? options.model
         : undefined;
     if (options.adapter === "codex" && gatewayConfig) {
-      const models = await fetchArrayModels({
+      const models = await fetchModelsList({
         gatewayUrl: gatewayConfig.gatewayUrl,
       });
       const codexModelIds = models

package/src/gateway-models.ts

@@ -19,7 +19,7 @@ export const DEFAULT_GATEWAY_MODEL = "claude-opus-4-6";
 
 export const BLOCKED_MODELS = new Set(["gpt-5-mini", "openai/gpt-5-mini"]);
 
-type ArrayModelsResponse =
+type ModelsListResponse =
   | {
       data?: Array<{ id?: string; owned_by?: string }>;
       models?: Array<{ id?: string; owned_by?: string }>;
@@ -79,53 +79,50 @@ export function isAnthropicModel(model: GatewayModel): boolean {
   return model.id.startsWith("claude-") || model.id.startsWith("anthropic/");
 }
 
-export interface ArrayModelInfo {
+export interface ModelInfo {
   id: string;
   owned_by?: string;
 }
 
-let arrayModelsCache: {
-  models: ArrayModelInfo[];
+let modelsListCache: {
+  models: ModelInfo[];
   expiry: number;
   url: string;
 } | null = null;
 
-export async function fetchArrayModels(
+export async function fetchModelsList(
   options?: FetchGatewayModelsOptions,
-): Promise<ArrayModelInfo[]> {
+): Promise<ModelInfo[]> {
   const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
   if (!gatewayUrl) {
     return [];
   }
 
   if (
-    arrayModelsCache &&
-    arrayModelsCache.url === gatewayUrl &&
-    Date.now() < arrayModelsCache.expiry
+    modelsListCache &&
+    modelsListCache.url === gatewayUrl &&
+    Date.now() < modelsListCache.expiry
   ) {
-    return arrayModelsCache.models;
+    return modelsListCache.models;
   }
 
   try {
-    const base = new URL(gatewayUrl);
-    base.pathname = "/array/v1/models";
-    base.search = "";
-    base.hash = "";
-    const response = await fetch(base.toString());
+    const modelsUrl = `${gatewayUrl}/v1/models`;
+    const response = await fetch(modelsUrl);
     if (!response.ok) {
       return [];
     }
-    const data = (await response.json()) as ArrayModelsResponse;
+    const data = (await response.json()) as ModelsListResponse;
     const models = Array.isArray(data)
       ? data
       : (data.data ?? data.models ?? []);
-    const results: ArrayModelInfo[] = [];
+    const results: ModelInfo[] = [];
     for (const model of models) {
       const id = model?.id ? String(model.id) : "";
       if (!id) continue;
       results.push({ id, owned_by: model?.owned_by });
     }
-    arrayModelsCache = {
+    modelsListCache = {
       models: results,
       expiry: Date.now() + CACHE_TTL,
       url: gatewayUrl,

package/src/types.ts

@@ -109,6 +109,7 @@ export interface TaskExecutionOptions {
   repositoryPath?: string;
   adapter?: "claude" | "codex";
   model?: string;
+  gatewayUrl?: string;
   codexBinaryPath?: string;
   processCallbacks?: ProcessSpawnedCallback;
 }