@codeany/open-agent-sdk 0.2.1 → 0.2.3

package/src/tools/read.ts

@@ -1,73 +0,0 @@
-/**
- * FileReadTool - Read file contents with line numbers
- */
-
-import { readFile, stat } from 'fs/promises'
-import { resolve } from 'path'
-import { defineTool } from './types.js'
-
-export const FileReadTool = defineTool({
-  name: 'Read',
-  description: 'Read a file from the filesystem. Returns content with line numbers. Supports text files, images (returns visual content), and PDFs.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: {
-        type: 'string',
-        description: 'The absolute path to the file to read',
-      },
-      offset: {
-        type: 'number',
-        description: 'Line number to start reading from (0-based)',
-      },
-      limit: {
-        type: 'number',
-        description: 'Maximum number of lines to read',
-      },
-    },
-    required: ['file_path'],
-  },
-  isReadOnly: true,
-  isConcurrencySafe: true,
-  async call(input, context) {
-    const filePath = resolve(context.cwd, input.file_path)
-
-    try {
-      const fileStat = await stat(filePath)
-      if (fileStat.isDirectory()) {
-        return { data: `Error: ${filePath} is a directory, not a file. Use Bash with 'ls' to list directory contents.`, is_error: true }
-      }
-
-      // Check for binary/image files
-      const ext = filePath.split('.').pop()?.toLowerCase()
-      if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg'].includes(ext || '')) {
-        return `[Image file: ${filePath} (${fileStat.size} bytes)]`
-      }
-
-      const content = await readFile(filePath, 'utf-8')
-      const lines = content.split('\n')
-
-      const offset = input.offset || 0
-      const limit = input.limit || 2000
-      const selectedLines = lines.slice(offset, offset + limit)
-
-      // Format with line numbers (cat -n style)
-      const numbered = selectedLines.map((line: string, i: number) => {
-        const lineNum = offset + i + 1
-        return `${lineNum}\t${line}`
-      }).join('\n')
-
-      let result = numbered
-      if (lines.length > offset + limit) {
-        result += `\n\n(${lines.length - offset - limit} more lines not shown)`
-      }
-
-      return result || '(empty file)'
-    } catch (err: any) {
-      if (err.code === 'ENOENT') {
-        return { data: `Error: File not found: ${filePath}`, is_error: true }
-      }
-      return { data: `Error reading file: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/send-message.ts

@@ -1,96 +0,0 @@
-/**
- * SendMessageTool - Inter-agent messaging
- *
- * Supports plain text and structured protocol messages
- * between teammates in a multi-agent setup.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-/**
- * Message inbox for inter-agent communication.
- */
-export interface AgentMessage {
-  from: string
-  to: string
-  content: string
-  timestamp: string
-  type: 'text' | 'shutdown_request' | 'shutdown_response' | 'plan_approval_response'
-}
-
-const mailboxes = new Map<string, AgentMessage[]>()
-
-/**
- * Read messages from a mailbox.
- */
-export function readMailbox(agentName: string): AgentMessage[] {
-  const messages = mailboxes.get(agentName) || []
-  mailboxes.set(agentName, []) // Clear after reading
-  return messages
-}
-
-/**
- * Write to a mailbox.
- */
-export function writeToMailbox(agentName: string, message: AgentMessage): void {
-  const messages = mailboxes.get(agentName) || []
-  messages.push(message)
-  mailboxes.set(agentName, messages)
-}
-
-/**
- * Clear all mailboxes.
- */
-export function clearMailboxes(): void {
-  mailboxes.clear()
-}
-
-export const SendMessageTool: ToolDefinition = {
-  name: 'SendMessage',
-  description: 'Send a message to another agent or teammate. Supports plain text and structured protocol messages.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      to: { type: 'string', description: 'Recipient agent name or ID. Use "*" for broadcast.' },
-      content: { type: 'string', description: 'Message content' },
-      type: {
-        type: 'string',
-        enum: ['text', 'shutdown_request', 'shutdown_response', 'plan_approval_response'],
-        description: 'Message type (default: text)',
-      },
-    },
-    required: ['to', 'content'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Send a message to another agent.' },
-  async call(input: any): Promise<ToolResult> {
-    const message: AgentMessage = {
-      from: 'self',
-      to: input.to,
-      content: input.content,
-      timestamp: new Date().toISOString(),
-      type: input.type || 'text',
-    }
-
-    if (input.to === '*') {
-      // Broadcast to all known mailboxes
-      for (const [name] of mailboxes) {
-        writeToMailbox(name, { ...message, to: name })
-      }
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Message broadcast to all agents`,
-      }
-    }
-
-    writeToMailbox(input.to, message)
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Message sent to ${input.to}`,
-    }
-  },
-}

package/src/tools/skill-tool.ts

@@ -1,133 +0,0 @@
-/**
- * Skill Tool
- *
- * Allows the model to invoke registered skills by name.
- * Skills are prompt templates that provide specialized capabilities.
- */
-
-import type { ToolDefinition, ToolResult, ToolContext } from '../types.js'
-import { getSkill, getUserInvocableSkills } from '../skills/registry.js'
-
-export const SkillTool: ToolDefinition = {
-  name: 'Skill',
-  description:
-    'Execute a skill within the current conversation. ' +
-    'Skills provide specialized capabilities and domain knowledge. ' +
-    'Use this tool with the skill name and optional arguments. ' +
-    'Available skills are listed in system-reminder messages.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      skill: {
-        type: 'string',
-        description: 'The skill name to execute (e.g., "commit", "review", "simplify")',
-      },
-      args: {
-        type: 'string',
-        description: 'Optional arguments for the skill',
-      },
-    },
-    required: ['skill'],
-  },
-
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => getUserInvocableSkills().length > 0,
-
-  async prompt(): Promise<string> {
-    const skills = getUserInvocableSkills()
-    if (skills.length === 0) return ''
-
-    const lines = skills.map((s) => {
-      const desc =
-        s.description.length > 200
-          ? s.description.slice(0, 200) + '...'
-          : s.description
-      return `- ${s.name}: ${desc}`
-    })
-
-    return (
-      'Execute a skill within the main conversation.\n\n' +
-      'Available skills:\n' +
-      lines.join('\n') +
-      '\n\nWhen a skill matches the user\'s request, invoke it using the Skill tool.'
-    )
-  },
-
-  async call(input: any, context: ToolContext): Promise<ToolResult> {
-    const skillName: string = input.skill
-    const args: string = input.args || ''
-
-    if (!skillName) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'Error: skill name is required',
-        is_error: true,
-      }
-    }
-
-    const skill = getSkill(skillName)
-    if (!skill) {
-      const available = getUserInvocableSkills()
-        .map((s) => s.name)
-        .join(', ')
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error: Unknown skill "${skillName}". Available skills: ${available || 'none'}`,
-        is_error: true,
-      }
-    }
-
-    // Check if skill is enabled
-    if (skill.isEnabled && !skill.isEnabled()) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error: Skill "${skillName}" is currently disabled`,
-        is_error: true,
-      }
-    }
-
-    try {
-      // Get skill prompt
-      const contentBlocks = await skill.getPrompt(args, context)
-
-      // Convert content blocks to text
-      const promptText = contentBlocks
-        .filter((b): b is { type: 'text'; text: string } => b.type === 'text')
-        .map((b) => b.text)
-        .join('\n\n')
-
-      // Build result with metadata
-      const result: Record<string, unknown> = {
-        success: true,
-        commandName: skill.name,
-        status: skill.context === 'fork' ? 'forked' : 'inline',
-        prompt: promptText,
-      }
-
-      if (skill.allowedTools) {
-        result.allowedTools = skill.allowedTools
-      }
-
-      if (skill.model) {
-        result.model = skill.model
-      }
-
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: JSON.stringify(result),
-      }
-    } catch (err: any) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error executing skill "${skillName}": ${err.message}`,
-        is_error: true,
-      }
-    }
-  },
-}

package/src/tools/task-tools.ts

@@ -1,290 +0,0 @@
-/**
- * Task Management Tools
- *
- * TaskCreate, TaskList, TaskUpdate, TaskGet, TaskStop, TaskOutput
- *
- * Provides in-memory task tracking for agent coordination.
- * Tasks persist across turns within a session.
- */
-
-import type { ToolDefinition, ToolContext, ToolResult } from '../types.js'
-
-/**
- * Task status.
- */
-export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled'
-
-/**
- * Task entry.
- */
-export interface Task {
-  id: string
-  subject: string
-  description?: string
-  status: TaskStatus
-  owner?: string
-  createdAt: string
-  updatedAt: string
-  output?: string
-  blockedBy?: string[]
-  blocks?: string[]
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Global task store (shared across tools in a session).
- */
-const taskStore = new Map<string, Task>()
-
-let taskCounter = 0
-
-/**
- * Get all tasks.
- */
-export function getAllTasks(): Task[] {
-  return Array.from(taskStore.values())
-}
-
-/**
- * Get a task by ID.
- */
-export function getTask(id: string): Task | undefined {
-  return taskStore.get(id)
-}
-
-/**
- * Clear all tasks (for session reset).
- */
-export function clearTasks(): void {
-  taskStore.clear()
-  taskCounter = 0
-}
-
-// ============================================================================
-// TaskCreateTool
-// ============================================================================
-
-export const TaskCreateTool: ToolDefinition = {
-  name: 'TaskCreate',
-  description: 'Create a new task for tracking work progress. Tasks help organize multi-step operations.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      subject: { type: 'string', description: 'Short task title' },
-      description: { type: 'string', description: 'Detailed task description' },
-      owner: { type: 'string', description: 'Task owner/assignee' },
-      status: { type: 'string', enum: ['pending', 'in_progress'], description: 'Initial status' },
-    },
-    required: ['subject'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Create a task for tracking progress.' },
-  async call(input: any): Promise<ToolResult> {
-    const id = `task_${++taskCounter}`
-    const task: Task = {
-      id,
-      subject: input.subject,
-      description: input.description,
-      status: input.status || 'pending',
-      owner: input.owner,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    }
-    taskStore.set(id, task)
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Task created: ${id} - "${task.subject}" (${task.status})`,
-    }
-  },
-}
-
-// ============================================================================
-// TaskListTool
-// ============================================================================
-
-export const TaskListTool: ToolDefinition = {
-  name: 'TaskList',
-  description: 'List all tasks with their status, ownership, and dependencies.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      status: { type: 'string', description: 'Filter by status' },
-      owner: { type: 'string', description: 'Filter by owner' },
-    },
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'List tasks.' },
-  async call(input: any): Promise<ToolResult> {
-    let tasks = getAllTasks()
-
-    if (input.status) {
-      tasks = tasks.filter(t => t.status === input.status)
-    }
-    if (input.owner) {
-      tasks = tasks.filter(t => t.owner === input.owner)
-    }
-
-    if (tasks.length === 0) {
-      return { type: 'tool_result', tool_use_id: '', content: 'No tasks found.' }
-    }
-
-    const lines = tasks.map(t =>
-      `[${t.id}] ${t.status.toUpperCase()} - ${t.subject}${t.owner ? ` (owner: ${t.owner})` : ''}`
-    )
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: lines.join('\n'),
-    }
-  },
-}
-
-// ============================================================================
-// TaskUpdateTool
-// ============================================================================
-
-export const TaskUpdateTool: ToolDefinition = {
-  name: 'TaskUpdate',
-  description: 'Update a task\'s status, description, or other properties.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Task ID' },
-      status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'failed', 'cancelled'] },
-      description: { type: 'string', description: 'Updated description' },
-      owner: { type: 'string', description: 'New owner' },
-      output: { type: 'string', description: 'Task output/result' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Update a task.' },
-  async call(input: any): Promise<ToolResult> {
-    const task = taskStore.get(input.id)
-    if (!task) {
-      return { type: 'tool_result', tool_use_id: '', content: `Task not found: ${input.id}`, is_error: true }
-    }
-
-    if (input.status) task.status = input.status
-    if (input.description) task.description = input.description
-    if (input.owner) task.owner = input.owner
-    if (input.output) task.output = input.output
-    task.updatedAt = new Date().toISOString()
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Task updated: ${task.id} - ${task.status} - "${task.subject}"`,
-    }
-  },
-}
-
-// ============================================================================
-// TaskGetTool
-// ============================================================================
-
-export const TaskGetTool: ToolDefinition = {
-  name: 'TaskGet',
-  description: 'Get full details of a specific task.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Task ID' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Get task details.' },
-  async call(input: any): Promise<ToolResult> {
-    const task = taskStore.get(input.id)
-    if (!task) {
-      return { type: 'tool_result', tool_use_id: '', content: `Task not found: ${input.id}`, is_error: true }
-    }
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: JSON.stringify(task, null, 2),
-    }
-  },
-}
-
-// ============================================================================
-// TaskStopTool
-// ============================================================================
-
-export const TaskStopTool: ToolDefinition = {
-  name: 'TaskStop',
-  description: 'Stop/cancel a running task.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Task ID to stop' },
-      reason: { type: 'string', description: 'Reason for stopping' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Stop a task.' },
-  async call(input: any): Promise<ToolResult> {
-    const task = taskStore.get(input.id)
-    if (!task) {
-      return { type: 'tool_result', tool_use_id: '', content: `Task not found: ${input.id}`, is_error: true }
-    }
-
-    task.status = 'cancelled'
-    task.updatedAt = new Date().toISOString()
-    if (input.reason) task.output = `Stopped: ${input.reason}`
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Task stopped: ${task.id}`,
-    }
-  },
-}
-
-// ============================================================================
-// TaskOutputTool
-// ============================================================================
-
-export const TaskOutputTool: ToolDefinition = {
-  name: 'TaskOutput',
-  description: 'Get the output/result of a task.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Task ID' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Get task output.' },
-  async call(input: any): Promise<ToolResult> {
-    const task = taskStore.get(input.id)
-    if (!task) {
-      return { type: 'tool_result', tool_use_id: '', content: `Task not found: ${input.id}`, is_error: true }
-    }
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: task.output || '(no output yet)',
-    }
-  },
-}