@codeany/open-agent-sdk 0.2.2 → 0.2.4

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

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