@codeany/open-agent-sdk 0.2.1 → 0.2.3

package/src/tools/team-tools.ts

@@ -1,128 +0,0 @@
-/**
- * Team Management Tools
- *
- * TeamCreate, TeamDelete - Multi-agent team coordination.
- * Manages team composition, task lists, and inter-agent messaging.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-/**
- * Team definition.
- */
-export interface Team {
-  id: string
-  name: string
-  members: string[]
-  leaderId: string
-  taskListId?: string
-  createdAt: string
-  status: 'active' | 'disbanded'
-}
-
-/**
- * Global team store.
- */
-const teamStore = new Map<string, Team>()
-let teamCounter = 0
-
-/**
- * Get all teams.
- */
-export function getAllTeams(): Team[] {
-  return Array.from(teamStore.values())
-}
-
-/**
- * Get a team by ID.
- */
-export function getTeam(id: string): Team | undefined {
-  return teamStore.get(id)
-}
-
-/**
- * Clear all teams.
- */
-export function clearTeams(): void {
-  teamStore.clear()
-  teamCounter = 0
-}
-
-// ============================================================================
-// TeamCreateTool
-// ============================================================================
-
-export const TeamCreateTool: ToolDefinition = {
-  name: 'TeamCreate',
-  description: 'Create a multi-agent team for coordinated work. Assigns a lead and manages member composition.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      name: { type: 'string', description: 'Team name' },
-      members: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'List of agent/teammate names',
-      },
-      task_description: { type: 'string', description: 'Description of the team\'s mission' },
-    },
-    required: ['name'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Create a team for multi-agent coordination.' },
-  async call(input: any): Promise<ToolResult> {
-    const id = `team_${++teamCounter}`
-    const team: Team = {
-      id,
-      name: input.name,
-      members: input.members || [],
-      leaderId: 'self',
-      createdAt: new Date().toISOString(),
-      status: 'active',
-    }
-    teamStore.set(id, team)
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Team created: ${id} "${team.name}" with ${team.members.length} members`,
-    }
-  },
-}
-
-// ============================================================================
-// TeamDeleteTool
-// ============================================================================
-
-export const TeamDeleteTool: ToolDefinition = {
-  name: 'TeamDelete',
-  description: 'Disband a team and clean up resources.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Team ID to disband' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Delete/disband a team.' },
-  async call(input: any): Promise<ToolResult> {
-    const team = teamStore.get(input.id)
-    if (!team) {
-      return { type: 'tool_result', tool_use_id: '', content: `Team not found: ${input.id}`, is_error: true }
-    }
-
-    team.status = 'disbanded'
-    teamStore.delete(input.id)
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Team disbanded: ${team.name}`,
-    }
-  },
-}

package/src/tools/todo-tool.ts

@@ -1,112 +0,0 @@
-/**
- * TodoWriteTool - Session todo/checklist management
- *
- * Manages a session-scoped todo list for tracking work items.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-export interface TodoItem {
-  id: number
-  text: string
-  done: boolean
-  priority?: 'high' | 'medium' | 'low'
-}
-
-const todoList: TodoItem[] = []
-let todoCounter = 0
-
-/**
- * Get all todos.
- */
-export function getTodos(): TodoItem[] {
-  return [...todoList]
-}
-
-/**
- * Clear all todos.
- */
-export function clearTodos(): void {
-  todoList.length = 0
-  todoCounter = 0
-}
-
-export const TodoWriteTool: ToolDefinition = {
-  name: 'TodoWrite',
-  description: 'Manage a session todo/checklist. Supports add, toggle, remove, and list operations.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['add', 'toggle', 'remove', 'list', 'clear'],
-        description: 'Operation to perform',
-      },
-      text: { type: 'string', description: 'Todo item text (for add)' },
-      id: { type: 'number', description: 'Todo item ID (for toggle/remove)' },
-      priority: {
-        type: 'string',
-        enum: ['high', 'medium', 'low'],
-        description: 'Priority level (for add)',
-      },
-    },
-    required: ['action'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Manage session todo list.' },
-  async call(input: any): Promise<ToolResult> {
-    switch (input.action) {
-      case 'add': {
-        if (!input.text) {
-          return { type: 'tool_result', tool_use_id: '', content: 'text required', is_error: true }
-        }
-        const item: TodoItem = {
-          id: ++todoCounter,
-          text: input.text,
-          done: false,
-          priority: input.priority,
-        }
-        todoList.push(item)
-        return { type: 'tool_result', tool_use_id: '', content: `Todo added: #${item.id} "${item.text}"` }
-      }
-
-      case 'toggle': {
-        const item = todoList.find(t => t.id === input.id)
-        if (!item) {
-          return { type: 'tool_result', tool_use_id: '', content: `Todo #${input.id} not found`, is_error: true }
-        }
-        item.done = !item.done
-        return { type: 'tool_result', tool_use_id: '', content: `Todo #${item.id} ${item.done ? 'completed' : 'reopened'}` }
-      }
-
-      case 'remove': {
-        const idx = todoList.findIndex(t => t.id === input.id)
-        if (idx === -1) {
-          return { type: 'tool_result', tool_use_id: '', content: `Todo #${input.id} not found`, is_error: true }
-        }
-        todoList.splice(idx, 1)
-        return { type: 'tool_result', tool_use_id: '', content: `Todo #${input.id} removed` }
-      }
-
-      case 'list': {
-        if (todoList.length === 0) {
-          return { type: 'tool_result', tool_use_id: '', content: 'No todos.' }
-        }
-        const lines = todoList.map(t =>
-          `${t.done ? '[x]' : '[ ]'} #${t.id} ${t.text}${t.priority ? ` (${t.priority})` : ''}`
-        )
-        return { type: 'tool_result', tool_use_id: '', content: lines.join('\n') }
-      }
-
-      case 'clear': {
-        todoList.length = 0
-        return { type: 'tool_result', tool_use_id: '', content: 'All todos cleared.' }
-      }
-
-      default:
-        return { type: 'tool_result', tool_use_id: '', content: `Unknown action: ${input.action}`, is_error: true }
-    }
-  },
-}

package/src/tools/tool-search.ts

@@ -1,87 +0,0 @@
-/**
- * ToolSearchTool - Discover deferred/lazy-loaded tools
- *
- * Allows the model to search for tools that haven't been loaded yet.
- * Supports keyword search and exact name selection.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-// Registry of deferred tools (set by the agent)
-let deferredTools: ToolDefinition[] = []
-
-/**
- * Set deferred tools available for search.
- */
-export function setDeferredTools(tools: ToolDefinition[]): void {
-  deferredTools = tools
-}
-
-export const ToolSearchTool: ToolDefinition = {
-  name: 'ToolSearch',
-  description: 'Search for additional tools that may be available but not yet loaded. Use keyword search or exact name selection.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: {
-        type: 'string',
-        description: 'Search query. Use "select:ToolName" for exact match or keywords for search.',
-      },
-      max_results: {
-        type: 'number',
-        description: 'Maximum results to return (default: 5)',
-      },
-    },
-    required: ['query'],
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Search for available tools.' },
-  async call(input: any): Promise<ToolResult> {
-    const { query, max_results = 5 } = input
-
-    if (deferredTools.length === 0) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'No deferred tools available.',
-      }
-    }
-
-    let matches: ToolDefinition[]
-
-    if (query.startsWith('select:')) {
-      // Exact name selection
-      const names = query.slice(7).split(',').map((n: string) => n.trim())
-      matches = deferredTools.filter(t => names.includes(t.name))
-    } else {
-      // Keyword search
-      const keywords: string[] = query.toLowerCase().split(/\s+/)
-      matches = deferredTools
-        .filter(t => {
-          const searchText = `${t.name} ${t.description}`.toLowerCase()
-          return keywords.some((kw: string) => searchText.includes(kw))
-        })
-        .slice(0, max_results)
-    }
-
-    if (matches.length === 0) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `No tools found matching "${query}"`,
-      }
-    }
-
-    const lines = matches.map(t =>
-      `- ${t.name}: ${t.description.slice(0, 200)}`
-    )
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Found ${matches.length} tool(s):\n${lines.join('\n')}`,
-    }
-  },
-}

package/src/tools/types.ts

@@ -1,66 +0,0 @@
-/**
- * Tool interface and helper utilities
- */
-
-import type { ToolDefinition, ToolInputSchema, ToolContext, ToolResult } from '../types.js'
-
-/**
- * Helper to create a tool definition with sensible defaults.
- */
-export function defineTool(config: {
-  name: string
-  description: string
-  inputSchema: ToolInputSchema
-  call: (input: any, context: ToolContext) => Promise<string | { data: string; is_error?: boolean }>
-  isReadOnly?: boolean
-  isConcurrencySafe?: boolean
-  prompt?: string | ((context: ToolContext) => Promise<string>)
-}): ToolDefinition {
-  return {
-    name: config.name,
-    description: config.description,
-    inputSchema: config.inputSchema,
-    isReadOnly: () => config.isReadOnly ?? false,
-    isConcurrencySafe: () => config.isConcurrencySafe ?? false,
-    isEnabled: () => true,
-    prompt: typeof config.prompt === 'function'
-      ? config.prompt
-      : async (_context: ToolContext) => (config.prompt as string) ?? config.description,
-    async call(input: any, context: ToolContext): Promise<ToolResult> {
-      try {
-        const result = await config.call(input, context)
-        const output = typeof result === 'string' ? result : result.data
-        const isError = typeof result === 'object' && result.is_error
-        return {
-          type: 'tool_result',
-          tool_use_id: '', // filled by engine
-          content: output,
-          is_error: isError || false,
-        }
-      } catch (err: any) {
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: `Error: ${err.message}`,
-          is_error: true,
-        }
-      }
-    },
-  }
-}
-
-/**
- * Convert a ToolDefinition to API-compatible tool format.
- * Returns the normalized tool format used by providers.
- */
-export function toApiTool(tool: ToolDefinition): {
-  name: string
-  description: string
-  input_schema: ToolInputSchema
-} {
-  return {
-    name: tool.name,
-    description: tool.description,
-    input_schema: tool.inputSchema,
-  }
-}

package/src/tools/web-fetch.ts

@@ -1,66 +0,0 @@
-/**
- * WebFetchTool - Fetch web content
- */
-
-import { defineTool } from './types.js'
-
-export const WebFetchTool = defineTool({
-  name: 'WebFetch',
-  description: 'Fetch content from a URL and return it as text. Supports HTML pages, JSON APIs, and plain text. Strips HTML tags for readability.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: {
-        type: 'string',
-        description: 'The URL to fetch content from',
-      },
-      headers: {
-        type: 'object',
-        description: 'Optional HTTP headers',
-      },
-    },
-    required: ['url'],
-  },
-  isReadOnly: true,
-  isConcurrencySafe: true,
-  async call(input, _context) {
-    const { url, headers } = input
-
-    try {
-      const response = await fetch(url, {
-        headers: {
-          'User-Agent': 'Mozilla/5.0 (compatible; AgentSDK/1.0)',
-          ...headers,
-        },
-        signal: AbortSignal.timeout(30000),
-      })
-
-      if (!response.ok) {
-        return { data: `HTTP ${response.status}: ${response.statusText}`, is_error: true }
-      }
-
-      const contentType = response.headers.get('content-type') || ''
-      let text = await response.text()
-
-      // Strip HTML tags for readability
-      if (contentType.includes('text/html')) {
-        // Remove script and style blocks
-        text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-        // Remove HTML tags
-        text = text.replace(/<[^>]+>/g, ' ')
-        // Clean up whitespace
-        text = text.replace(/\s+/g, ' ').trim()
-      }
-
-      // Truncate very large responses
-      if (text.length > 100000) {
-        text = text.slice(0, 100000) + '\n...(truncated)'
-      }
-
-      return text || '(empty response)'
-    } catch (err: any) {
-      return { data: `Error fetching ${url}: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/web-search.ts

@@ -1,86 +0,0 @@
-/**
- * WebSearchTool - Web search (via web fetch of search engines)
- */
-
-import { defineTool } from './types.js'
-
-export const WebSearchTool = defineTool({
-  name: 'WebSearch',
-  description: 'Search the web for information. Returns search results with titles, URLs, and snippets.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: {
-        type: 'string',
-        description: 'The search query',
-      },
-      num_results: {
-        type: 'number',
-        description: 'Number of results to return (default: 5)',
-      },
-    },
-    required: ['query'],
-  },
-  isReadOnly: true,
-  isConcurrencySafe: true,
-  async call(input, _context) {
-    const { query } = input
-
-    try {
-      // Use DuckDuckGo HTML search as a free fallback
-      const encoded = encodeURIComponent(query)
-      const url = `https://html.duckduckgo.com/html/?q=${encoded}`
-
-      const response = await fetch(url, {
-        headers: {
-          'User-Agent': 'Mozilla/5.0 (compatible; AgentSDK/1.0)',
-        },
-        signal: AbortSignal.timeout(15000),
-      })
-
-      if (!response.ok) {
-        return { data: `Search failed: HTTP ${response.status}`, is_error: true }
-      }
-
-      const html = await response.text()
-
-      // Parse search results from DuckDuckGo HTML
-      const results: string[] = []
-      const resultRegex = /<a rel="nofollow" class="result__a" href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi
-      const snippetRegex = /<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi
-
-      let match
-      const links: Array<{ title: string; url: string }> = []
-
-      while ((match = resultRegex.exec(html)) !== null) {
-        const href = match[1]
-        const title = match[2].replace(/<[^>]+>/g, '').trim()
-        if (href && title && !href.includes('duckduckgo.com')) {
-          links.push({ title, url: href })
-        }
-      }
-
-      const snippets: string[] = []
-      while ((match = snippetRegex.exec(html)) !== null) {
-        snippets.push(match[1].replace(/<[^>]+>/g, '').trim())
-      }
-
-      const numResults = Math.min(input.num_results || 5, links.length)
-      for (let i = 0; i < numResults; i++) {
-        const link = links[i]
-        if (!link) continue
-        let entry = `${i + 1}. ${link.title}\n   ${link.url}`
-        if (snippets[i]) {
-          entry += `\n   ${snippets[i]}`
-        }
-        results.push(entry)
-      }
-
-      return results.length > 0
-        ? results.join('\n\n')
-        : `No results found for "${query}"`
-    } catch (err: any) {
-      return { data: `Search error: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/worktree-tools.ts

@@ -1,140 +0,0 @@
-/**
- * Git Worktree Tools
- *
- * EnterWorktree / ExitWorktree - Isolated git worktree environments
- * for parallel work without affecting the main working tree.
- */
-
-import { execSync } from 'child_process'
-import { existsSync } from 'fs'
-import { join } from 'path'
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-// Track active worktrees
-const activeWorktrees = new Map<string, { path: string; branch: string; originalCwd: string }>()
-
-export const EnterWorktreeTool: ToolDefinition = {
-  name: 'EnterWorktree',
-  description: 'Create an isolated git worktree for parallel work. The agent will work in the worktree without affecting the main working tree.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      branch: { type: 'string', description: 'Branch name for the worktree (auto-generated if not provided)' },
-      path: { type: 'string', description: 'Path for the worktree (auto-generated if not provided)' },
-    },
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Create an isolated git worktree for parallel work.' },
-  async call(input: any, context: { cwd: string }): Promise<ToolResult> {
-    try {
-      // Check if we're in a git repo
-      execSync('git rev-parse --git-dir', { cwd: context.cwd, encoding: 'utf-8' })
-
-      const branch = input.branch || `worktree-${Date.now()}`
-      const worktreePath = input.path || join(context.cwd, '..', `.worktree-${branch}`)
-
-      // Create the branch if it doesn't exist
-      try {
-        execSync(`git branch ${branch}`, { cwd: context.cwd, encoding: 'utf-8', stdio: 'pipe' })
-      } catch {
-        // Branch might already exist
-      }
-
-      // Create worktree
-      execSync(`git worktree add ${JSON.stringify(worktreePath)} ${branch}`, {
-        cwd: context.cwd,
-        encoding: 'utf-8',
-      })
-
-      const id = crypto.randomUUID()
-      activeWorktrees.set(id, {
-        path: worktreePath,
-        branch,
-        originalCwd: context.cwd,
-      })
-
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Worktree created:\n  ID: ${id}\n  Path: ${worktreePath}\n  Branch: ${branch}\n\nYou are now working in the isolated worktree.`,
-      }
-    } catch (err: any) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error creating worktree: ${err.message}`,
-        is_error: true,
-      }
-    }
-  },
-}
-
-export const ExitWorktreeTool: ToolDefinition = {
-  name: 'ExitWorktree',
-  description: 'Exit and optionally remove a git worktree. Use "keep" to preserve changes or "remove" to clean up.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Worktree ID' },
-      action: {
-        type: 'string',
-        enum: ['keep', 'remove'],
-        description: 'Whether to keep or remove the worktree (default: remove)',
-      },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Exit a git worktree.' },
-  async call(input: any): Promise<ToolResult> {
-    const worktree = activeWorktrees.get(input.id)
-    if (!worktree) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Worktree not found: ${input.id}`,
-        is_error: true,
-      }
-    }
-
-    const action = input.action || 'remove'
-
-    try {
-      if (action === 'remove') {
-        execSync(`git worktree remove ${JSON.stringify(worktree.path)} --force`, {
-          cwd: worktree.originalCwd,
-          encoding: 'utf-8',
-        })
-        // Clean up branch
-        try {
-          execSync(`git branch -D ${worktree.branch}`, {
-            cwd: worktree.originalCwd,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-          })
-        } catch {
-          // Branch might have commits
-        }
-      }
-
-      activeWorktrees.delete(input.id)
-
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Worktree ${action === 'remove' ? 'removed' : 'kept'}: ${worktree.path}`,
-      }
-    } catch (err: any) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error: ${err.message}`,
-        is_error: true,
-      }
-    }
-  },
-}