import { Tool } from 'assistme-agent-sdk'
import { z } from 'zod'

const calculator = Tool.create({
  name: 'calculator',
  description: 'Perform mathematical calculations',
  parameters: z.object({
    expression: z.string().describe('A mathematical expression like "2 + 2" or "sqrt(144)"'),
  }),
  execute: async ({ expression }) => {
    // Safe math evaluation
    const result = evaluate(expression)
    return { result }
  },
})

interface ToolConfig<TParams, TResult> {
  /** Unique name. The model uses this to identify the tool. */
  name: string

  /** Description of what the tool does. Critical for model decision-making. */
  description: string

  /** Zod schema for the tool's parameters */
  parameters: z.ZodType<TParams>

  /** The function that executes when the tool is called */
  execute: (params: TParams, context: ToolContext) => Promise<TResult>

  /** Optional: Restrict which agents can use this tool */
  allowedAgents?: string[]

  /** Optional: Mark tool as requiring human approval before execution */
  requiresApproval?: boolean | ((params: TParams) => boolean)

  /** Optional: Timeout in milliseconds */
  timeout?: number

  /** Optional: Error handler */
  onError?: (error: Error, params: TParams) => TResult | Promise<TResult>
}

const readFile = Tool.create({
  name: 'read_file',
  description: 'Read a file from the filesystem',
  parameters: z.object({
    path: z.string(),
  }),
  execute: async ({ path }, context) => {
    // Access run metadata
    console.log(`Agent "${context.agentName}" is reading ${path}`)
    console.log(`Run ID: ${context.runId}`)
    console.log(`Turn: ${context.turn}`)

    return await fs.readFile(path, 'utf-8')
  },
})

const sendEmail = Tool.create({
  name: 'send_email',
  description: 'Send an email to a recipient',
  parameters: z.object({
    to: z.string().email(),
    subject: z.string(),
    body: z.string(),
  }),
  // Always require approval
  requiresApproval: true,
  execute: async ({ to, subject, body }) => {
    return await emailService.send({ to, subject, body })
  },
})

const deleteRecords = Tool.create({
  name: 'delete_records',
  description: 'Delete records from the database',
  parameters: z.object({
    table: z.string(),
    filter: z.record(z.string()),
    count: z.number(),
  }),
  // Only require approval for bulk deletes
  requiresApproval: ({ count }) => count > 10,
  execute: async ({ table, filter }) => {
    return await db.delete(table, filter)
  },
})

const apiCall = Tool.create({
  name: 'api_call',
  description: 'Call an external API',
  parameters: z.object({ url: z.string(), method: z.string() }),
  timeout: 10_000, // 10 second timeout
  execute: async ({ url, method }) => {
    const response = await fetch(url, { method })
    if (!response.ok) {
      throw new Error(`API returned ${response.status}: ${response.statusText}`)
    }
    return response.json()
  },
  onError: (error, params) => {
    return { error: error.message, suggestion: 'Try a different URL or check the API status.' }
  },
})

import { MCPToolProvider } from 'assistme-agent-sdk/mcp'

// Connect to an MCP server
const githubTools = await MCPToolProvider.connect({
  transport: 'stdio',
  command: 'npx',
  args: ['@modelcontextprotocol/server-github'],
  env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
})

const agent = new Agent({
  name: 'github-assistant',
  model: claude('claude-sonnet-4-6'),
  instructions: 'Help users manage their GitHub repositories.',
  tools: [
    ...githubTools.tools(), // All tools from the MCP server
  ],
})

// Only include specific tools from the MCP server
const agent = new Agent({
  name: 'reader',
  model: claude('claude-sonnet-4-6'),
  instructions: 'Read and summarize files.',
  tools: [
    ...githubTools.tools({
      include: ['read_file', 'list_files', 'search_code'],
      // exclude: ['delete_file', 'push_commit'],
    }),
  ],
})

import { ToolSearch } from 'assistme-agent-sdk'

const toolSearch = new ToolSearch({
  tools: [
    ...githubTools.tools(),
    ...slackTools.tools(),
    ...jiraTools.tools(),
    ...dbTools.tools(),
  ],
  maxResults: 5, // Return top 5 matching tools
})

const agent = new Agent({
  name: 'omniscient',
  model: claude('claude-sonnet-4-6'),
  instructions: 'You have access to many tools. Use tool search to find the right one.',
  tools: [
    toolSearch.asTool(), // Meta-tool that searches for tools
  ],
})

const searchAndSummarize = Tool.compose({
  name: 'search_and_summarize',
  description: 'Search the web and return a summary of findings',
  parameters: z.object({
    topic: z.string(),
    maxResults: z.number().default(3),
  }),
  steps: [
    { tool: webSearch, map: ({ topic }) => ({ query: topic }) },
    { tool: readUrl, forEach: (results) => results.slice(0, 3).map(r => ({ url: r.url })) },
    { reduce: (contents) => contents.join('\n---\n').substring(0, 10000) },
  ],
})

const dbTools = Tool.group({
  name: 'database',
  description: 'Database operations',
  tools: [queryTool, insertTool, updateTool, deleteTool],
  // Apply shared config to all tools in the group
  defaults: {
    timeout: 30_000,
    requiresApproval: false,
  },
})

const agent = new Agent({
  name: 'db-admin',
  model: claude('claude-sonnet-4-6'),
  instructions: 'Manage the database.',
  tools: dbTools.tools(),
})