@codeany/open-agent-sdk 0.2.1 → 0.2.3

package/src/utils/messages.ts

@@ -1,195 +0,0 @@
-/**
- * Message Utilities
- *
- * Message creation factories, normalization for API,
- * synthetic placeholders, and content processing.
- */
-
-import type { Message, UserMessage, AssistantMessage, TokenUsage } from '../types.js'
-
-/**
- * Create a user message.
- */
-export function createUserMessage(
-  content: string | any[],
-  options?: {
-    uuid?: string
-    isMeta?: boolean
-    toolUseResult?: unknown
-  },
-): UserMessage {
-  return {
-    type: 'user',
-    message: {
-      role: 'user',
-      content,
-    },
-    uuid: options?.uuid || crypto.randomUUID(),
-    timestamp: new Date().toISOString(),
-  }
-}
-
-/**
- * Create an assistant message.
- */
-export function createAssistantMessage(
-  content: any[],
-  usage?: TokenUsage,
-): AssistantMessage {
-  return {
-    type: 'assistant',
-    message: {
-      role: 'assistant',
-      content,
-    },
-    uuid: crypto.randomUUID(),
-    timestamp: new Date().toISOString(),
-    usage,
-  }
-}
-
-/**
- * Normalize messages for the LLM API.
- * Ensures proper message format, strips internal metadata,
- * and fixes tool result pairing.
- */
-export function normalizeMessagesForAPI(
-  messages: Array<{ role: string; content: any }>,
-): Array<{ role: string; content: any }> {
-  const normalized: Array<{ role: string; content: any }> = []
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]
-
-    // Ensure alternating user/assistant messages
-    if (normalized.length > 0) {
-      const last = normalized[normalized.length - 1]
-      if (last.role === msg.role) {
-        // Merge same-role messages
-        if (msg.role === 'user') {
-          // Combine content
-          const lastContent = typeof last.content === 'string'
-            ? [{ type: 'text' as const, text: last.content }]
-            : last.content as any[]
-          const newContent = typeof msg.content === 'string'
-            ? [{ type: 'text' as const, text: msg.content }]
-            : msg.content as any[]
-          normalized[normalized.length - 1] = {
-            role: 'user',
-            content: [...lastContent, ...newContent],
-          }
-          continue
-        }
-      }
-    }
-
-    normalized.push({ ...msg })
-  }
-
-  // Ensure tool results are properly paired with tool_use
-  return fixToolResultPairing(normalized)
-}
-
-/**
- * Fix tool result pairing: ensure every tool_result has a
- * matching tool_use in the previous assistant message.
- */
-function fixToolResultPairing(
-  messages: Array<{ role: string; content: any }>,
-): Array<{ role: string; content: any }> {
-  const result: Array<{ role: string; content: any }> = []
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]
-
-    if (msg.role === 'user' && Array.isArray(msg.content)) {
-      // Check for tool_result blocks
-      const toolResults = (msg.content as any[]).filter(
-        (block: any) => block.type === 'tool_result',
-      )
-
-      if (toolResults.length > 0 && result.length > 0) {
-        // Find the previous assistant message
-        const prevAssistant = result[result.length - 1]
-        if (prevAssistant.role === 'assistant' && Array.isArray(prevAssistant.content)) {
-          const toolUseIds = new Set(
-            (prevAssistant.content as any[])
-              .filter((b: any) => b.type === 'tool_use')
-              .map((b: any) => b.id),
-          )
-
-          // Filter out orphaned tool results
-          const validContent = (msg.content as any[]).filter((block: any) => {
-            if (block.type === 'tool_result') {
-              return toolUseIds.has(block.tool_use_id)
-            }
-            return true
-          })
-
-          if (validContent.length > 0) {
-            result.push({ ...msg, content: validContent })
-          }
-          continue
-        }
-      }
-    }
-
-    result.push(msg)
-  }
-
-  return result
-}
-
-/**
- * Strip images from messages (for compaction).
- */
-export function stripImagesFromMessages(
-  messages: Array<{ role: string; content: any }>,
-): Array<{ role: string; content: any }> {
-  return messages.map((msg) => {
-    if (typeof msg.content === 'string') return msg
-    if (!Array.isArray(msg.content)) return msg
-
-    const filtered = (msg.content as any[]).filter(
-      (block: any) => block.type !== 'image',
-    )
-
-    return {
-      ...msg,
-      content: filtered.length > 0 ? filtered : '[content removed]',
-    }
-  })
-}
-
-/**
- * Extract text from message content blocks.
- */
-export function extractTextFromContent(
-  content: any[] | string,
-): string {
-  if (typeof content === 'string') return content
-
-  return content
-    .filter((b: any) => b.type === 'text')
-    .map((b: any) => b.text)
-    .join('')
-}
-
-/**
- * Create a system message for compact boundary.
- */
-export function createCompactBoundaryMessage(): { role: string; content: string } {
-  return {
-    role: 'user',
-    content: '[Previous context has been summarized above. Continuing conversation.]',
-  }
-}
-
-/**
- * Truncate text to max length with ellipsis.
- */
-export function truncateText(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text
-  const half = Math.floor(maxLength / 2)
-  return text.slice(0, half) + '\n...(truncated)...\n' + text.slice(-half)
-}

package/src/utils/retry.ts

@@ -1,140 +0,0 @@
-/**
- * Retry Logic with Exponential Backoff
- *
- * Handles API retries for rate limits, overloaded servers,
- * and transient failures.
- */
-
-/**
- * Retry configuration.
- */
-export interface RetryConfig {
-  maxRetries: number
-  baseDelayMs: number
-  maxDelayMs: number
-  retryableStatusCodes: number[]
-}
-
-/**
- * Default retry configuration.
- */
-export const DEFAULT_RETRY_CONFIG: RetryConfig = {
-  maxRetries: 3,
-  baseDelayMs: 2000,
-  maxDelayMs: 30000,
-  retryableStatusCodes: [429, 500, 502, 503, 529],
-}
-
-/**
- * Check if an error is retryable.
- */
-export function isRetryableError(err: any, config: RetryConfig = DEFAULT_RETRY_CONFIG): boolean {
-  if (err?.status && config.retryableStatusCodes.includes(err.status)) {
-    return true
-  }
-
-  // Network errors
-  if (err?.code === 'ECONNRESET' || err?.code === 'ETIMEDOUT' || err?.code === 'ECONNREFUSED') {
-    return true
-  }
-
-  // API overloaded
-  if (err?.error?.type === 'overloaded_error') {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Calculate delay for exponential backoff.
- */
-export function getRetryDelay(attempt: number, config: RetryConfig = DEFAULT_RETRY_CONFIG): number {
-  const delay = config.baseDelayMs * Math.pow(2, attempt)
-  // Add jitter (±25%)
-  const jitter = delay * 0.25 * (Math.random() * 2 - 1)
-  return Math.min(delay + jitter, config.maxDelayMs)
-}
-
-/**
- * Execute a function with retries.
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  config: RetryConfig = DEFAULT_RETRY_CONFIG,
-  abortSignal?: AbortSignal,
-): Promise<T> {
-  let lastError: any
-
-  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
-    if (abortSignal?.aborted) {
-      throw new Error('Aborted')
-    }
-
-    try {
-      return await fn()
-    } catch (err: any) {
-      lastError = err
-
-      if (!isRetryableError(err, config)) {
-        throw err
-      }
-
-      if (attempt === config.maxRetries) {
-        throw err
-      }
-
-      // Wait before retry
-      const delay = getRetryDelay(attempt, config)
-      await new Promise((resolve) => setTimeout(resolve, delay))
-    }
-  }
-
-  throw lastError
-}
-
-/**
- * Check if an error is a "prompt too long" error.
- */
-export function isPromptTooLongError(err: any): boolean {
-  if (err?.status === 400) {
-    const message = err?.error?.error?.message || err?.message || ''
-    return message.includes('prompt is too long') ||
-      message.includes('max_tokens') ||
-      message.includes('context length')
-  }
-  return false
-}
-
-/**
- * Check if error is an auth error.
- */
-export function isAuthError(err: any): boolean {
-  return err?.status === 401 || err?.status === 403
-}
-
-/**
- * Check if error is a rate limit error.
- */
-export function isRateLimitError(err: any): boolean {
-  return err?.status === 429
-}
-
-/**
- * Format an API error for display.
- */
-export function formatApiError(err: any): string {
-  if (isAuthError(err)) {
-    return 'Authentication failed. Check your CODEANY_API_KEY.'
-  }
-  if (isRateLimitError(err)) {
-    return 'Rate limit exceeded. Please retry after a short wait.'
-  }
-  if (err?.status === 529) {
-    return 'API overloaded. Please retry later.'
-  }
-  if (isPromptTooLongError(err)) {
-    return 'Prompt too long. Auto-compacting conversation...'
-  }
-  return `API error: ${err.message || err}`
-}

package/src/utils/tokens.ts

@@ -1,145 +0,0 @@
-/**
- * Token Estimation & Counting
- *
- * Provides rough token estimation (character-based) and
- * API-based exact counting when available.
- */
-
-/**
- * Rough token estimation: ~4 chars per token (conservative).
- */
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4)
-}
-
-/**
- * Estimate tokens for a message array.
- */
-export function estimateMessagesTokens(
-  messages: Array<{ role: string; content: any }>,
-): number {
-  let total = 0
-  for (const msg of messages) {
-    if (typeof msg.content === 'string') {
-      total += estimateTokens(msg.content)
-    } else if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if ('text' in block && typeof block.text === 'string') {
-          total += estimateTokens(block.text)
-        } else if ('content' in block && typeof block.content === 'string') {
-          total += estimateTokens(block.content)
-        } else {
-          // tool_use, image, etc - rough estimate
-          total += estimateTokens(JSON.stringify(block))
-        }
-      }
-    }
-  }
-  return total
-}
-
-/**
- * Estimate tokens for a system prompt.
- */
-export function estimateSystemPromptTokens(systemPrompt: string): number {
-  return estimateTokens(systemPrompt)
-}
-
-/**
- * Count tokens from API usage response.
- */
-export function getTokenCountFromUsage(usage: {
-  input_tokens: number
-  output_tokens: number
-  cache_creation_input_tokens?: number
-  cache_read_input_tokens?: number
-}): number {
-  return (
-    usage.input_tokens +
-    usage.output_tokens +
-    (usage.cache_creation_input_tokens || 0) +
-    (usage.cache_read_input_tokens || 0)
-  )
-}
-
-/**
- * Get the context window size for a model.
- */
-export function getContextWindowSize(model: string): number {
-  // Anthropic model context windows
-  if (model.includes('opus-4') && model.includes('1m')) return 1_000_000
-  if (model.includes('opus-4')) return 200_000
-  if (model.includes('sonnet-4')) return 200_000
-  if (model.includes('haiku-4')) return 200_000
-  if (model.includes('claude-3')) return 200_000
-
-  // OpenAI model context windows
-  if (model.includes('gpt-4o')) return 128_000
-  if (model.includes('gpt-4-turbo')) return 128_000
-  if (model.includes('gpt-4-1')) return 1_000_000
-  if (model.includes('gpt-4')) return 128_000
-  if (model.includes('gpt-3.5')) return 16_385
-  if (model.includes('o1')) return 200_000
-  if (model.includes('o3')) return 200_000
-  if (model.includes('o4')) return 200_000
-
-  // DeepSeek models
-  if (model.includes('deepseek')) return 128_000
-
-  // Default
-  return 200_000
-}
-
-/**
- * Auto-compact buffer: trigger compaction when within this many tokens of the limit.
- */
-export const AUTOCOMPACT_BUFFER_TOKENS = 13_000
-
-/**
- * Get the auto-compact threshold for a model.
- */
-export function getAutoCompactThreshold(model: string): number {
-  return getContextWindowSize(model) - AUTOCOMPACT_BUFFER_TOKENS
-}
-
-/**
- * Model pricing (USD per token).
- */
-export const MODEL_PRICING: Record<string, { input: number; output: number }> = {
-  // Anthropic models
-  'claude-opus-4-6': { input: 15 / 1_000_000, output: 75 / 1_000_000 },
-  'claude-opus-4-5': { input: 15 / 1_000_000, output: 75 / 1_000_000 },
-  'claude-sonnet-4-6': { input: 3 / 1_000_000, output: 15 / 1_000_000 },
-  'claude-sonnet-4-5': { input: 3 / 1_000_000, output: 15 / 1_000_000 },
-  'claude-haiku-4-5': { input: 0.8 / 1_000_000, output: 4 / 1_000_000 },
-  'claude-3-5-sonnet': { input: 3 / 1_000_000, output: 15 / 1_000_000 },
-  'claude-3-5-haiku': { input: 0.8 / 1_000_000, output: 4 / 1_000_000 },
-  'claude-3-opus': { input: 15 / 1_000_000, output: 75 / 1_000_000 },
-
-  // OpenAI models
-  'gpt-4o': { input: 2.5 / 1_000_000, output: 10 / 1_000_000 },
-  'gpt-4o-mini': { input: 0.15 / 1_000_000, output: 0.6 / 1_000_000 },
-  'gpt-4-turbo': { input: 10 / 1_000_000, output: 30 / 1_000_000 },
-  'gpt-4-1': { input: 2 / 1_000_000, output: 8 / 1_000_000 },
-  'o1': { input: 15 / 1_000_000, output: 60 / 1_000_000 },
-  'o3': { input: 10 / 1_000_000, output: 40 / 1_000_000 },
-  'o4-mini': { input: 1.1 / 1_000_000, output: 4.4 / 1_000_000 },
-
-  // DeepSeek models
-  'deepseek-chat': { input: 0.27 / 1_000_000, output: 1.1 / 1_000_000 },
-  'deepseek-reasoner': { input: 0.55 / 1_000_000, output: 2.19 / 1_000_000 },
-}
-
-/**
- * Estimate cost from usage and model.
- */
-export function estimateCost(
-  model: string,
-  usage: { input_tokens: number; output_tokens: number },
-): number {
-  const pricing = Object.entries(MODEL_PRICING).find(([key]) =>
-    model.includes(key),
-  )?.[1] ?? { input: 3 / 1_000_000, output: 15 / 1_000_000 }
-
-  return usage.input_tokens * pricing.input + usage.output_tokens * pricing.output
-}