@posthog/agent 1.24.2 → 1.25.0

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

@@ -1,338 +0,0 @@
-import type { AgentEvent, ArtifactEvent, StatusEvent } from '../../types.js';
-import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { ProviderAdapter } from '../types.js';
-import { ClaudeToolMapper } from './tool-mapper.js';
-
-/**
- * Claude provider adapter.
- * Transforms Claude SDK messages into our standardized AgentEvent format.
- */
-export class ClaudeAdapter implements ProviderAdapter {
-  readonly name = 'claude';
-  private toolMapper = new ClaudeToolMapper();
-  createRawSDKEvent(sdkMessage: any): AgentEvent {
-    return {
-      type: 'raw_sdk_event',
-      ts: Date.now(),
-      sdkMessage
-    };
-  }
-
-  transform(sdkMessage: SDKMessage): AgentEvent[] {
-    const baseEvent = { ts: Date.now() };
-
-    if (sdkMessage.type === 'stream_event') {
-      const event = sdkMessage.event;
-
-      switch (event.type) {
-        case 'message_start':
-          return [{
-            ...baseEvent,
-            type: 'message_start',
-            messageId: event.message?.id,
-            model: event.message?.model
-          }];
-
-        case 'content_block_start':
-          const contentBlock = event.content_block;
-          if (!contentBlock) return [];
-
-          return [{
-            ...baseEvent,
-            type: 'content_block_start',
-            index: event.index,
-            contentType: contentBlock.type as 'text' | 'tool_use' | 'thinking',
-            toolName: contentBlock.type === 'tool_use' ? contentBlock.name : undefined,
-            toolId: contentBlock.type === 'tool_use' ? contentBlock.id : undefined
-          }];
-
-        case 'content_block_delta':
-          const delta = event.delta;
-          if (!delta) return [];
-
-          if (delta.type === 'text_delta') {
-            return [{
-              ...baseEvent,
-              type: 'token',
-              content: delta.text,
-              contentType: 'text'
-            }];
-          } else if (delta.type === 'input_json_delta') {
-            return [{
-              ...baseEvent,
-              type: 'token',
-              content: delta.partial_json,
-              contentType: 'tool_input'
-            }];
-          } else if (delta.type === 'thinking_delta') {
-            return [{
-              ...baseEvent,
-              type: 'token',
-              content: delta.thinking,
-              contentType: 'thinking'
-            }];
-          }
-          return [];
-
-        case 'content_block_stop':
-          return [{
-            ...baseEvent,
-            type: 'content_block_stop',
-            index: event.index
-          }];
-
-        case 'message_delta':
-          return [{
-            ...baseEvent,
-            type: 'message_delta',
-            stopReason: event.delta?.stop_reason,
-            stopSequence: event.delta?.stop_sequence,
-            usage: event.usage ? {
-              outputTokens: event.usage.output_tokens
-            } : undefined
-          }];
-
-        case 'message_stop':
-          return [{
-            ...baseEvent,
-            type: 'message_stop'
-          }];
-
-        case 'ping':
-          // Ignore ping events
-          return [];
-
-        case 'error':
-          return [{
-            ...baseEvent,
-            type: 'error',
-            message: event.error?.message || 'Unknown error',
-            error: event.error,
-            errorType: event.error?.type || 'stream_error',
-            context: event.error ? {
-              type: event.error.type,
-              code: event.error.code,
-            } : undefined,
-            sdkError: event.error
-          }];
-
-        default:
-          return [];
-      }
-    }
-
-    // Handle assistant messages (full message, not streaming)
-    if (sdkMessage.type === 'assistant') {
-      const message = sdkMessage.message;
-      const events: AgentEvent[] = [];
-
-      // Extract tool calls from content blocks
-      // A single assistant message can contain multiple tool_use blocks
-      if (message.content && Array.isArray(message.content)) {
-        for (const block of message.content) {
-          if (block.type === 'tool_use') {
-            // Create tool_call event and enrich with metadata
-            const toolCallEvent = {
-              ...baseEvent,
-              type: 'tool_call' as const,
-              toolName: block.name,
-              callId: block.id,
-              args: block.input || {},
-              parentToolUseId: sdkMessage.parent_tool_use_id
-            };
-            // Enrich with tool metadata and add to events array
-            events.push(this.toolMapper.enrichToolCall(toolCallEvent));
-          }
-        }
-      }
-
-      // If we found tool calls, return them
-      if (events.length > 0) {
-        return events;
-      }
-
-      // If no tool calls, emit status event
-      return [{
-        ...baseEvent,
-        type: 'status',
-        phase: 'assistant_message',
-        messageId: message.id,
-        model: message.model
-      }];
-    }
-
-    // Handle user messages
-    if (sdkMessage.type === 'user') {
-      const message = sdkMessage.message;
-      const events: AgentEvent[] = [];
-
-      // Check for tool results in content blocks, A single user message can contain multiple tool_result blocks
-      if (message?.content && Array.isArray(message.content)) { 
-        for (const block of message.content) {
-          if (block.type === 'tool_result') {
-            const toolResultEvent = {
-              ...baseEvent,
-              type: 'tool_result' as const,
-              toolName: block.tool_name || 'unknown',
-              callId: block.tool_use_id || '',
-              result: block.content,
-              isError: block.is_error,
-              parentToolUseId: sdkMessage.parent_tool_use_id
-            };
-            events.push(this.toolMapper.enrichToolResult(toolResultEvent));
-          }
-        }
-      }
-
-      // If we found tool results, return them
-      if (events.length > 0) {
-        return events;
-      }
-
-      // Otherwise extract text content
-      const textContent = this.extractUserContent(message?.content);
-      if (!textContent) {
-        return [];
-      }
-      return [{
-        ...baseEvent,
-        type: 'user_message',
-        content: textContent,
-        isSynthetic: sdkMessage.isSynthetic
-      }];
-    }
-
-    // Handle result messages
-    if (sdkMessage.type === 'result') {
-      if (sdkMessage.subtype === 'success') {
-        return [{
-          ...baseEvent,
-          type: 'done',
-          result: sdkMessage.result,
-          durationMs: sdkMessage.duration_ms,
-          durationApiMs: sdkMessage.duration_api_ms,
-          numTurns: sdkMessage.num_turns,
-          totalCostUsd: sdkMessage.total_cost_usd,
-          usage: sdkMessage.usage,
-          modelUsage: sdkMessage.modelUsage,
-          permissionDenials: sdkMessage.permission_denials
-        }];
-      } else {
-        return [{
-          ...baseEvent,
-          type: 'error',
-          message: `Execution failed: ${sdkMessage.subtype}`,
-          error: { subtype: sdkMessage.subtype },
-          errorType: sdkMessage.subtype || 'result_error',
-          context: {
-            subtype: sdkMessage.subtype,
-            duration_ms: sdkMessage.duration_ms,
-            num_turns: sdkMessage.num_turns
-          },
-          sdkError: sdkMessage
-        }];
-      }
-    }
-
-    // Handle system messages
-    if (sdkMessage.type === 'system') {
-      if (sdkMessage.subtype === 'init') {
-        return [{
-          ...baseEvent,
-          type: 'init',
-          model: sdkMessage.model,
-          tools: sdkMessage.tools,
-          permissionMode: sdkMessage.permissionMode,
-          cwd: sdkMessage.cwd,
-          apiKeySource: sdkMessage.apiKeySource,
-          agents: sdkMessage.agents,
-          slashCommands: sdkMessage.slash_commands,
-          outputStyle: sdkMessage.output_style,
-          mcpServers: sdkMessage.mcp_servers
-        }];
-      } else if (sdkMessage.subtype === 'compact_boundary') {
-        return [{
-          ...baseEvent,
-          type: 'compact_boundary',
-          trigger: sdkMessage.compact_metadata.trigger,
-          preTokens: sdkMessage.compact_metadata.pre_tokens
-        }];
-      }
-    }
-
-    return [];
-  }
-  
-  createStatusEvent(phase: string, additionalData?: any): StatusEvent {
-    return {
-      type: 'status',
-      ts: Date.now(),
-      phase,
-      ...additionalData
-    };
-  }
-
-  createArtifactEvent(kind: string, content: any): ArtifactEvent {
-    return {
-      type: 'artifact',
-      ts: Date.now(),
-      kind,
-      content
-    };
-  }
-
-  private extractUserContent(content: unknown): string | null {
-    if (!content) {
-      return null;
-    }
-
-    if (typeof content === 'string') {
-      const trimmed = content.trim();
-      return trimmed.length > 0 ? trimmed : null;
-    }
-
-    if (Array.isArray(content)) {
-      const parts: string[] = [];
-      for (const block of content) {
-        const extracted = this.extractUserContent(block);
-        if (extracted) {
-          parts.push(extracted);
-        } else if (block && typeof block === 'object') {
-          const candidate = this.extractFromObject(block as Record<string, unknown>);
-          if (candidate) {
-            parts.push(candidate);
-          }
-        }
-      }
-      const text = parts.join('\n').trim();
-      return text.length > 0 ? text : null;
-    }
-
-    if (typeof content === 'object') {
-      return this.extractFromObject(content as Record<string, unknown>);
-    }
-
-    return null;
-  }
-
-  private extractFromObject(value: Record<string, unknown>): string | null {
-    const preferredKeys = ['text', 'input_text', 'input', 'markdown', 'content', 'message'];
-    for (const key of preferredKeys) {
-      if (typeof value[key] === 'string') {
-        const trimmed = (value[key] as string).trim();
-        if (trimmed.length > 0) {
-          return trimmed;
-        }
-      }
-    }
-
-    for (const entry of Object.values(value)) {
-      const extracted = this.extractUserContent(entry);
-      if (extracted) {
-        return extracted;
-      }
-    }
-
-    return null;
-  }
-}

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

@@ -1,46 +0,0 @@
-import type { ToolCallEvent, ToolResultEvent } from '../../types.js';
-import { ToolRegistry } from '../../tools/registry.js';
-
-/**
- * Maps Claude tool names to our tool type system.
- * Enriches tool events with metadata for better UI consumption.
- */
-export class ClaudeToolMapper {
-  private registry = new ToolRegistry();
-
-  /**
-   * Enrich a tool call event with tool metadata.
-   * Looks up the tool definition and adds it to the event.
-   */
-  enrichToolCall(event: ToolCallEvent): ToolCallEvent {
-    const tool = this.registry.get(event.toolName);
-    if (!tool) {
-      // Tool not recognized, return as-is
-      return event;
-    }
-
-    return {
-      ...event,
-      tool,
-      category: tool.category,
-    };
-  }
-
-  /**
-   * Enrich a tool result event with tool metadata.
-   * Looks up the tool definition and adds it to the event.
-   */
-  enrichToolResult(event: ToolResultEvent): ToolResultEvent {
-    const tool = this.registry.get(event.toolName);
-    if (!tool) {
-      // Tool not recognized, return as-is
-      return event;
-    }
-
-    return {
-      ...event,
-      tool,
-      category: tool.category,
-    };
-  }
-}

package/src/adapters/types.ts

@@ -1,37 +0,0 @@
-import type { AgentEvent, StatusEvent, ArtifactEvent } from '../types.js';
-
-/**
- * Provider adapter interface for transforming provider-specific messages
- * into our standardized AgentEvent format.
- *
- * This allows us to support multiple AI providers (Claude, Gemini, OpenAI, etc.)
- * while maintaining a consistent event interface for consumers.
- */
-export interface ProviderAdapter {
-  /** Provider name (e.g., 'claude', 'gemini') */
-  name: string;
-
-  /**
-   * Transform a provider-specific SDK message into one or more AgentEvents.
-   * Returns an array of events (can be empty if the message should be ignored).
-   */
-  transform(sdkMessage: unknown): AgentEvent[];
-
-  /**
-   * Create a standardized status event.
-   * Used for task phase transitions and other status updates.
-   */
-  createStatusEvent(phase: string, additionalData?: any): StatusEvent;
-
-  /**
-   * Create an artifact event for custom task artifacts (todos, etc).
-   * Used to emit structured artifacts for UI consumption.
-   */
-  createArtifactEvent(kind: string, content: any): ArtifactEvent;
-
-  /**
-   * Create a raw SDK event for debugging purposes.
-   * Wraps the original SDK message in a raw_sdk_event.
-   */
-  createRawSDKEvent(sdkMessage: any): AgentEvent;
-}