Tools

tools/
└── create_ticket/
    ├── tool.json       ← (optional) metadata, parameters, confirmation
    ├── handler.ts      ← handler code
    ├── package.json    ← (optional) npm dependencies
    └── requirements.txt ← (optional) Python dependencies

{
  "webTools": {
    "provider": "google",
    "apiKey": "env:GOOGLE_API_KEY",
    "model": "gemini-2.5-flash"
  }
}

web_search({query: "kubernetes 1.31 deprecations", max_results: 5})

fetch_url({url: "https://example.com/article", prompt: "Extract the API changes"})

tools/
└── create_ops_ticket/
    ├── tool.json
    └── handler.ts

{
  "name": "create_ops_ticket",
  "description": "Create a Jira issue in the OPS project. Use this when an investigation reveals an issue that needs tracking — infrastructure problems, security findings that need remediation, or follow-up tasks from incident response.",
  "parameters": {
    "type": "object",
    "properties": {
      "summary": {
        "type": "string",
        "description": "A concise title for the issue (under 100 characters)"
      },
      "description": {
        "type": "string",
        "description": "Detailed description including context from the investigation"
      },
      "priority": {
        "type": "string",
        "enum": ["P1", "P2", "P3", "P4"],
        "description": "P1 = outage/security incident, P2 = degraded service, P3 = needs attention this sprint, P4 = backlog"
      },
      "labels": {
        "type": "array",
        "items": { "type": "string" },
        "description": "Labels to categorize the issue (e.g., 'security', 'deployment', 'performance')"
      }
    },
    "required": ["summary", "priority"]
  },
  "confirm": "review",
  "timeout": 30000,
  "env": ["JIRA_API_TOKEN"]
}

export default async (params, ctx) => {
  // Build the Jira issue payload
  const fields = {
    project: { key: 'OPS' },
    summary: params.summary,
    priority: { name: params.priority },
    issuetype: { name: 'Task' },
    labels: params.labels || [],
  }
 
  // Add description if provided
  if (params.description) {
    fields.description = {
      type: 'doc',
      version: 1,
      content: [{
        type: 'paragraph',
        content: [{ type: 'text', text: params.description }],
      }],
    }
  }
 
  // Create the issue via the Jira connection
  const result = await ctx.request('jira', '/rest/api/3/issue', {
    method: 'POST',
    data: { fields },
  })
 
  // Return a clean summary — the agent doesn't need the full Jira response
  return {
    ticketId: result.key,
    url: `https://yourcompany.atlassian.net/browse/${result.key}`,
    summary: params.summary,
    priority: params.priority,
  }
}

{
  "name": "get_deploy_status",
  "description": "Check the status of a deployment in ArgoCD. Use this to verify whether a recent deploy succeeded, is still rolling out, or failed.",
  "type": "http",
  "connection": "argocd",
  "endpoint": "/api/v1/applications/{{app_name}}",
  "method": "GET",
  "parameters": {
    "type": "object",
    "properties": {
      "app_name": {
        "type": "string",
        "description": "The ArgoCD application name (e.g., 'payments-prod', 'auth-staging')"
      }
    },
    "required": ["app_name"]
  },
  "confirm": false,
  "responseShaping": {
    "pick": ["status.sync.status", "status.health.status", "status.operationState.phase", "status.operationState.message"],
    "rename": {
      "status.sync.status": "syncStatus",
      "status.health.status": "healthStatus",
      "status.operationState.phase": "phase",
      "status.operationState.message": "message"
    }
  }
}

{
  "name": "get_service_overview",
  "description": "Pull a complete overview of a service: deployment status, error metrics, and recent incidents. Use this when starting an investigation or when the user asks about a service's current state.",
  "type": "chain",
  "steps": [
    {
      "name": "deploy",
      "connection": "argocd",
      "endpoint": "/api/v1/applications/{{service_name}}",
      "method": "GET"
    },
    {
      "name": "metrics",
      "connection": "datadog",
      "endpoint": "/api/v1/query",
      "method": "GET",
      "params": {
        "query": "avg:http.error_rate{service:{{service_name}}}",
        "from": "{{now_minus_1h}}",
        "to": "{{now}}"
      }
    },
    {
      "name": "incidents",
      "connection": "pagerduty",
      "endpoint": "/incidents",
      "method": "GET",
      "params": {
        "service_ids[]": "{{pagerduty_service_id}}",
        "since": "{{now_minus_24h}}",
        "statuses[]": ["triggered", "acknowledged"]
      }
    }
  ],
  "parameters": {
    "type": "object",
    "properties": {
      "service_name": { "type": "string" },
      "pagerduty_service_id": { "type": "string" }
    },
    "required": ["service_name"]
  },
  "confirm": false
}

import { defineToolHandler } from '@amodalai/core'
 
export default defineToolHandler({
  description: 'Calculate the weighted pipeline value for a set of deals based on stage probability and engagement score. Use this for pipeline reviews or forecasting.',
  parameters: {
    type: 'object',
    properties: {
      deal_ids: {
        type: 'array',
        items: { type: 'string' },
        description: 'Salesforce opportunity IDs to include',
      },
      include_at_risk: {
        type: 'boolean',
        description: 'Whether to include deals flagged as at-risk (default: true)',
      },
    },
    required: ['deal_ids'],
  },
  confirm: 'review',
  timeout: 60000,
  handler: async (params, ctx) => {
    // Pull deal data from Salesforce
    const query = `SELECT Id, Name, Amount, StageName, Probability, LastActivityDate
                   FROM Opportunity
                   WHERE Id IN ('${params.deal_ids.join("','")}')`
 
    const result = await ctx.request('salesforce', '/services/data/v59.0/query', {
      params: { q: query },
    })
 
    const deals = result.records.map((deal) => {
      const daysSinceActivity = deal.LastActivityDate
        ? Math.floor((Date.now() - new Date(deal.LastActivityDate).getTime()) / 86400000)
        : 999
 
      // Engagement decay: reduce probability if the deal has gone quiet
      const engagementMultiplier = daysSinceActivity <= 7 ? 1.0
        : daysSinceActivity <= 14 ? 0.85
        : daysSinceActivity <= 30 ? 0.6
        : 0.3
 
      const adjustedProbability = (deal.Probability / 100) * engagementMultiplier
      const weightedValue = deal.Amount * adjustedProbability
 
      return {
        id: deal.Id,
        name: deal.Name,
        amount: deal.Amount,
        stage: deal.StageName,
        rawProbability: deal.Probability,
        daysSinceActivity,
        engagementMultiplier,
        adjustedProbability: Math.round(adjustedProbability * 100),
        weightedValue: Math.round(weightedValue),
        atRisk: daysSinceActivity > 14 || deal.Probability < 30,
      }
    })
 
    const included = params.include_at_risk !== false
      ? deals
      : deals.filter((d) => !d.atRisk)
 
    return {
      totalWeightedValue: included.reduce((sum, d) => sum + d.weightedValue, 0),
      dealCount: included.length,
      atRiskCount: deals.filter((d) => d.atRisk).length,
      deals: included,
    }
  },
})

{
  "name": "create_ticket",
  "description": "Create a Jira issue in the ops project",
  "parameters": {
    "type": "object",
    "properties": {
      "summary": { "type": "string" },
      "priority": { "type": "string", "enum": ["P1", "P2", "P3", "P4"] }
    },
    "required": ["summary"]
  },
  "confirm": "review",
  "timeout": 30000,
  "env": ["JIRA_API_TOKEN"]
}

export default async (params, ctx) => {
  const result = await ctx.request('jira', '/rest/api/3/issue', {
    method: 'POST',
    data: {
      fields: {
        project: { key: 'OPS' },
        summary: params.summary,
        priority: { name: params.priority },
        issuetype: { name: 'Task' },
      },
    },
  })
  return { ticketId: result.key, url: result.self }
}

import { defineToolHandler } from '@amodalai/core'
 
export default defineToolHandler({
  description: 'Calculate weighted pipeline value',
  parameters: {
    type: 'object',
    properties: {
      deal_ids: { type: 'array', items: { type: 'string' } },
    },
    required: ['deal_ids'],
  },
  confirm: 'review',
  timeout: 60000,
  env: ['STRIPE_API_KEY'],
  handler: async (params, ctx) => {
    const deals = await ctx.request('crm', '/deals', {
      params: { ids: params.deal_ids.join(',') },
    })
    return { total: deals.reduce((sum, d) => sum + d.amount, 0) }
  },
})

{
  "name": "get_user_details",
  "description": "Look up a user's profile, role, and recent login activity from Okta.",
  "type": "http",
  "connection": "okta",
  "endpoint": "/api/v1/users/{{user_id}}",
  "method": "GET",
  "parameters": {
    "type": "object",
    "properties": {
      "user_id": { "type": "string" }
    },
    "required": ["user_id"]
  },
  "confirm": false,
  "responseShaping": {
    "pick": [
      "profile.firstName",
      "profile.lastName",
      "profile.email",
      "profile.department",
      "status",
      "lastLogin",
      "created"
    ],
    "rename": {
      "profile.firstName": "firstName",
      "profile.lastName": "lastName",
      "profile.email": "email",
      "profile.department": "department"
    },
    "template": "User: {{firstName}} {{lastName}} ({{email}})\nDepartment: {{department}}\nStatus: {{status}}\nLast Login: {{lastLogin}}\nAccount Created: {{created}}"
  }
}

export default async (params, ctx) => {
  // Simple GET — auth is handled by the 'datadog' connection config
  const metrics = await ctx.request('datadog', '/api/v1/query', {
    params: {
      query: `avg:system.cpu.user{host:${params.hostname}}`,
      from: params.startTime,
      to: params.endTime,
    },
  })
 
  // POST with a body
  const incident = await ctx.request('pagerduty', '/incidents', {
    method: 'POST',
    data: {
      incident: {
        type: 'incident',
        title: params.title,
        service: { id: params.serviceId, type: 'service_reference' },
        urgency: params.urgency,
      },
    },
  })
 
  return {
    cpuAverage: metrics.series[0]?.pointlist?.map(([ts, val]) => val) || [],
    incidentId: incident.incident.id,
  }
}

export default async (params, ctx) => {
  // Run a database query via CLI
  const result = await ctx.exec(
    `psql "${ctx.env('DATABASE_URL')}" -c "SELECT count(*) as failed_jobs FROM jobs WHERE status = 'failed' AND created_at > now() - interval '1 hour'" --json`,
    { timeout: 10000 }
  )
 
  const parsed = JSON.parse(result.stdout)
  return { failedJobsLastHour: parsed[0].failed_jobs }
}

// tool.json has: "env": ["SLACK_WEBHOOK_URL"]
export default async (params, ctx) => {
  const webhookUrl = ctx.env('SLACK_WEBHOOK_URL')
 
  // Use the webhook directly (not through a connection)
  const response = await fetch(webhookUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: params.message,
      channel: params.channel,
    }),
  })
 
  return { sent: response.ok }
}