@codeany/open-agent-sdk 0.2.2 → 0.2.3

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,
-      }
-    }
-  },
-}

package/src/tools/write.ts

@@ -1,42 +0,0 @@
-/**
- * FileWriteTool - Write/create files
- */
-
-import { writeFile, mkdir } from 'fs/promises'
-import { resolve, dirname } from 'path'
-import { defineTool } from './types.js'
-
-export const FileWriteTool = defineTool({
-  name: 'Write',
-  description: 'Write content to a file. Creates the file if it does not exist, or overwrites if it does. Creates parent directories as needed.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: {
-        type: 'string',
-        description: 'The absolute path to the file to write',
-      },
-      content: {
-        type: 'string',
-        description: 'The content to write to the file',
-      },
-    },
-    required: ['file_path', 'content'],
-  },
-  isReadOnly: false,
-  isConcurrencySafe: false,
-  async call(input, context) {
-    const filePath = resolve(context.cwd, input.file_path)
-
-    try {
-      await mkdir(dirname(filePath), { recursive: true })
-      await writeFile(filePath, input.content, 'utf-8')
-
-      const lines = input.content.split('\n').length
-      const bytes = Buffer.byteLength(input.content, 'utf-8')
-      return `File written: ${filePath} (${lines} lines, ${bytes} bytes)`
-    } catch (err: any) {
-      return { data: `Error writing file: ${err.message}`, is_error: true }
-    }
-  },
-})