Tool Development Guide

from pydantic import BaseModel, Field

class Input(BaseModel):
    url: str = Field(description="URL to fetch")

class Output(BaseModel):
    title: str
    content: str

def run(input: Input) -> Output:
    # Implement your logic
    return Output(title="...", content="...")

import { z } from "zod";

export const input = z.object({
  url: z.string().describe("URL to fetch"),
});

export const output = z.object({
  title: z.string(),
  content: z.string(),
});

export async function run(data: z.infer<typeof input>) {
  // Implement your logic
  return { title: "...", content: "..." };
}

import requests  # Add "requests" in package settings
from bs4 import BeautifulSoup  # Add "beautifulsoup4"

def run(input: Input) -> Output:
    html = requests.get(input.url).text
    soup = BeautifulSoup(html, "html.parser")
    return Output(title=soup.title.string)

import os

def run(input: Input) -> Output:
    api_key = os.environ["SLACK_API_KEY"]
    # Use api_key...

export async function run(data: z.infer<typeof input>) {
  const apiKey = process.env.SLACK_API_KEY;
  // Use apiKey...
}

def run(input: Input) -> Output:
    if not input.url.startswith("https://"):
        raise ValueError("URL must start with https://")
    # ...

import os
import requests
from pydantic import BaseModel, Field

class Input(BaseModel):
    channel: str = Field(description="Target channel")
    message: str = Field(description="Message body")

class Output(BaseModel):
    success: bool
    ts: str = Field(description="Message timestamp")

def run(input: Input) -> Output:
    response = requests.post(
        "https://slack.com/api/chat.postMessage",
        headers={"Authorization": f"Bearer {os.environ['SLACK_BOT_TOKEN']}"},
        json={"channel": input.channel, "text": input.message},
    )
    data = response.json()
    if not data["ok"]:
        raise Exception(data["error"])
    return Output(success=True, ts=data["ts"])

import requests
from bs4 import BeautifulSoup
from pydantic import BaseModel

class Input(BaseModel):
    url: str

class Output(BaseModel):
    title: str
    description: str
    text: str

def run(input: Input) -> Output:
    html = requests.get(input.url).text
    soup = BeautifulSoup(html, "html.parser")

    title = soup.title.string if soup.title else ""
    desc_tag = soup.find("meta", {"name": "description"})
    description = desc_tag["content"] if desc_tag else ""
    text = soup.get_text()[:2000]

    return Output(title=title, description=description, text=text)

import os
import requests
from pydantic import BaseModel

class Input(BaseModel):
    query: str

class Output(BaseModel):
    results: list[dict]

def run(input: Input) -> Output:
    response = requests.get(
        "https://api.example.com/search",
        headers={"Authorization": f"Bearer {os.environ['API_KEY']}"},
        params={"q": input.query},
    )
    response.raise_for_status()
    return Output(results=response.json()["results"])

class Input(BaseModel):
    query: str = Field(description="Search keyword")
    limit: int = Field(default=10, description="Max results (1-100)")

export const input = z.object({
  query: z.string().describe("Search keyword"),
  limit: z.number().default(10).describe("Max results (1-100)"),
});

from typing import Optional

class Input(BaseModel):
    query: str
    filter: Optional[str] = None  # Optional

class Address(BaseModel):
    city: str
    country: str = "JP"

class Input(BaseModel):
    name: str
    address: Address