Every capability, on every surface.

With the server connected, say something like:

Use the ToolForte tool text_diff (Text Diff) with original: one
two
three, modified: one
two point five
three.

The assistant then makes this tool call:

{
  "name": "text_diff",
  "arguments": {
    "original": "one\ntwo\nthree",
    "modified": "one\ntwo point five\nthree"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-diff \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"original":"one\ntwo\nthree","modified":"one\ntwo point five\nthree"}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-diff", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "original": "one\ntwo\nthree",
    "modified": "one\ntwo point five\nthree"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-diff",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"original":"one\ntwo\nthree","modified":"one\ntwo point five\nthree"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool markdown_to_html (Markdown to HTML) with markdown: # Hello

This is **bold** text..

The assistant then makes this tool call:

{
  "name": "markdown_to_html",
  "arguments": {
    "markdown": "# Hello\n\nThis is **bold** text."
  }
}

curl -X POST https://toolforte.com/api/v1/tools/markdown-to-html \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"markdown":"# Hello\n\nThis is **bold** text."}'

const response = await fetch("https://toolforte.com/api/v1/tools/markdown-to-html", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "markdown": "# Hello\n\nThis is **bold** text."
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/markdown-to-html",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"markdown":"# Hello\n\nThis is **bold** text."},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool count_words (Word) with text: The quick brown fox jumps over the lazy dog..

The assistant then makes this tool call:

{
  "name": "count_words",
  "arguments": {
    "text": "The quick brown fox jumps over the lazy dog."
  }
}

curl -X POST https://toolforte.com/api/v1/tools/word-counter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"The quick brown fox jumps over the lazy dog."}'

const response = await fetch("https://toolforte.com/api/v1/tools/word-counter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "The quick brown fox jumps over the lazy dog."
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/word-counter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"The quick brown fox jumps over the lazy dog."},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_slug (Slug) with text: Hello World! This is a Test., separator: -, lowercase: true, max_length: 0.

The assistant then makes this tool call:

{
  "name": "generate_slug",
  "arguments": {
    "text": "Hello World! This is a Test.",
    "separator": "-",
    "lowercase": true,
    "max_length": 0
  }
}

curl -X POST https://toolforte.com/api/v1/tools/slug-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello World! This is a Test.","separator":"-","lowercase":true,"max_length":0}'

const response = await fetch("https://toolforte.com/api/v1/tools/slug-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Hello World! This is a Test.",
    "separator": "-",
    "lowercase": true,
    "max_length": 0
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/slug-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Hello World! This is a Test.","separator":"-","lowercase":true,"max_length":0},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_case (Text Case) with text: hello world from ToolForte, mode: snake.

The assistant then makes this tool call:

{
  "name": "convert_case",
  "arguments": {
    "text": "hello world from ToolForte",
    "mode": "snake"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-case-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world from ToolForte","mode":"snake"}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-case-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "hello world from ToolForte",
    "mode": "snake"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-case-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"hello world from ToolForte","mode":"snake"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool sort_lines (Sort Lines) with text: banana
apple
Cherry
item10
item2, mode: natural, caseInsensitive: true, removeDuplicates: false, reverse: false, seed: 1.

The assistant then makes this tool call:

{
  "name": "sort_lines",
  "arguments": {
    "text": "banana\napple\nCherry\nitem10\nitem2",
    "mode": "natural",
    "caseInsensitive": true,
    "removeDuplicates": false,
    "reverse": false,
    "seed": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sort-lines \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"banana\napple\nCherry\nitem10\nitem2","mode":"natural","caseInsensitive":true,"removeDuplicates":false,"reverse":false,"seed":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/sort-lines", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "banana\napple\nCherry\nitem10\nitem2",
    "mode": "natural",
    "caseInsensitive": true,
    "removeDuplicates": false,
    "reverse": false,
    "seed": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sort-lines",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"banana\napple\nCherry\nitem10\nitem2","mode":"natural","caseInsensitive":true,"removeDuplicates":false,"reverse":false,"seed":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dedupe_lines (Remove Duplicate Lines) with text: apple
banana
apple
 banana
cherry, caseInsensitive: false, trim: true, keepFirst: true.

The assistant then makes this tool call:

{
  "name": "dedupe_lines",
  "arguments": {
    "text": "apple\nbanana\napple\n banana\ncherry",
    "caseInsensitive": false,
    "trim": true,
    "keepFirst": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/remove-duplicate-lines \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"apple\nbanana\napple\n banana\ncherry","caseInsensitive":false,"trim":true,"keepFirst":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/remove-duplicate-lines", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "apple\nbanana\napple\n banana\ncherry",
    "caseInsensitive": false,
    "trim": true,
    "keepFirst": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/remove-duplicate-lines",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"apple\nbanana\napple\n banana\ncherry","caseInsensitive":false,"trim":true,"keepFirst":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool reverse_text (Reverse Text) with text: one two three, mode: words.

The assistant then makes this tool call:

{
  "name": "reverse_text",
  "arguments": {
    "text": "one two three",
    "mode": "words"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/reverse-text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"one two three","mode":"words"}'

const response = await fetch("https://toolforte.com/api/v1/tools/reverse-text", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "one two three",
    "mode": "words"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/reverse-text",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"one two three","mode":"words"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool find_and_replace (Find and Replace) with text: The cat sat on the mat with another cat., find: cat, replace: dog, caseSensitive: false, wholeWord: true, useRegex: false.

The assistant then makes this tool call:

{
  "name": "find_and_replace",
  "arguments": {
    "text": "The cat sat on the mat with another cat.",
    "find": "cat",
    "replace": "dog",
    "caseSensitive": false,
    "wholeWord": true,
    "useRegex": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/find-and-replace \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"The cat sat on the mat with another cat.","find":"cat","replace":"dog","caseSensitive":false,"wholeWord":true,"useRegex":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/find-and-replace", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "The cat sat on the mat with another cat.",
    "find": "cat",
    "replace": "dog",
    "caseSensitive": false,
    "wholeWord": true,
    "useRegex": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/find-and-replace",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"The cat sat on the mat with another cat.","find":"cat","replace":"dog","caseSensitive":false,"wholeWord":true,"useRegex":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool word_frequency (Word Frequency) with text: the cat and the dog and the bird, ignoreCase: true, minLength: 1, excludeStopWords: false, limit: 3.

The assistant then makes this tool call:

{
  "name": "word_frequency",
  "arguments": {
    "text": "the cat and the dog and the bird",
    "ignoreCase": true,
    "minLength": 1,
    "excludeStopWords": false,
    "limit": 3
  }
}

curl -X POST https://toolforte.com/api/v1/tools/word-frequency-counter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"the cat and the dog and the bird","ignoreCase":true,"minLength":1,"excludeStopWords":false,"limit":3}'

const response = await fetch("https://toolforte.com/api/v1/tools/word-frequency-counter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "the cat and the dog and the bird",
    "ignoreCase": true,
    "minLength": 1,
    "excludeStopWords": false,
    "limit": 3
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/word-frequency-counter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"the cat and the dog and the bird","ignoreCase":true,"minLength":1,"excludeStopWords":false,"limit":3},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool reading_time (Reading Time) with text: Knowing how long your content takes to read helps you pla..., readingWpm: 238, speakingWpm: 150.

The assistant then makes this tool call:

{
  "name": "reading_time",
  "arguments": {
    "text": "Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.",
    "readingWpm": 238,
    "speakingWpm": 150
  }
}

curl -X POST https://toolforte.com/api/v1/tools/reading-time-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.","readingWpm":238,"speakingWpm":150}'

const response = await fetch("https://toolforte.com/api/v1/tools/reading-time-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.",
    "readingWpm": 238,
    "speakingWpm": 150
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/reading-time-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.","readingWpm":238,"speakingWpm":150},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool rot13 (ROT13) with text: Hello, World!, shift: 13, decode: false.

The assistant then makes this tool call:

{
  "name": "rot13",
  "arguments": {
    "text": "Hello, World!",
    "shift": 13,
    "decode": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/rot13 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello, World!","shift":13,"decode":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/rot13", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Hello, World!",
    "shift": 13,
    "decode": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/rot13",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Hello, World!","shift":13,"decode":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool morse_code (Morse Code Translator) with text: SOS help, mode: encode.

The assistant then makes this tool call:

{
  "name": "morse_code",
  "arguments": {
    "text": "SOS help",
    "mode": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/morse-code-translator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"SOS help","mode":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/morse-code-translator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "SOS help",
    "mode": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/morse-code-translator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"SOS help","mode":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool numbers_to_words (Numbers to Words) with number: 1234.56, mode: plain, currency: dollars, british: false.

The assistant then makes this tool call:

{
  "name": "numbers_to_words",
  "arguments": {
    "number": "1234.56",
    "mode": "plain",
    "currency": "dollars",
    "british": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/numbers-to-words \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"number":"1234.56","mode":"plain","currency":"dollars","british":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/numbers-to-words", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "number": "1234.56",
    "mode": "plain",
    "currency": "dollars",
    "british": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/numbers-to-words",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"number":"1234.56","mode":"plain","currency":"dollars","british":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool roman_numerals (Roman Numeral) with value: 1994, mode: auto.

The assistant then makes this tool call:

{
  "name": "roman_numerals",
  "arguments": {
    "value": "1994",
    "mode": "auto"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/roman-numeral-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":"1994","mode":"auto"}'

const response = await fetch("https://toolforte.com/api/v1/tools/roman-numeral-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": "1994",
    "mode": "auto"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/roman-numeral-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":"1994","mode":"auto"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool clean_text (Text Cleaner) with text: <p>Hello   world</p>


  “quoted”  text  , extraSpaces: true, trimLines: true, emptyLines: true, lineBreaks: false, htmlTags: true, punctuation: false, numbers: false, emojis: false, plainQuotes: true, controlChars: false.

The assistant then makes this tool call:

{
  "name": "clean_text",
  "arguments": {
    "text": "<p>Hello   world</p>\n\n\n  “quoted”  text  ",
    "extraSpaces": true,
    "trimLines": true,
    "emptyLines": true,
    "lineBreaks": false,
    "htmlTags": true,
    "punctuation": false,
    "numbers": false,
    "emojis": false,
    "plainQuotes": true,
    "controlChars": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-cleaner \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<p>Hello   world</p>\n\n\n  “quoted”  text  ","extraSpaces":true,"trimLines":true,"emptyLines":true,"lineBreaks":false,"htmlTags":true,"punctuation":false,"numbers":false,"emojis":false,"plainQuotes":true,"controlChars":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-cleaner", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "<p>Hello   world</p>\n\n\n  “quoted”  text  ",
    "extraSpaces": true,
    "trimLines": true,
    "emptyLines": true,
    "lineBreaks": false,
    "htmlTags": true,
    "punctuation": false,
    "numbers": false,
    "emojis": false,
    "plainQuotes": true,
    "controlChars": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-cleaner",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"<p>Hello   world</p>\n\n\n  “quoted”  text  ","extraSpaces":true,"trimLines":true,"emptyLines":true,"lineBreaks":false,"htmlTags":true,"punctuation":false,"numbers":false,"emojis":false,"plainQuotes":true,"controlChars":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_subtitles (Subtitle) with text: 1
00:00:01,000 --> 00:00:03,500
Hello there., format: vtt, shiftSeconds: -2.5, scalePercent: 104.271, repair: true, appendText: 1
00:00:00,500 --> 00:00:02,000
Part two begins., appendOffsetSeconds: 5400.

The assistant then makes this tool call:

{
  "name": "convert_subtitles",
  "arguments": {
    "text": "1\n00:00:01,000 --> 00:00:03,500\nHello there.",
    "format": "vtt",
    "shiftSeconds": -2.5,
    "scalePercent": 104.271,
    "repair": true,
    "appendText": "1\n00:00:00,500 --> 00:00:02,000\nPart two begins.",
    "appendOffsetSeconds": 5400
  }
}

curl -X POST https://toolforte.com/api/v1/tools/subtitle-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"1\n00:00:01,000 --> 00:00:03,500\nHello there.","format":"vtt","shiftSeconds":-2.5,"scalePercent":104.271,"repair":true,"appendText":"1\n00:00:00,500 --> 00:00:02,000\nPart two begins.","appendOffsetSeconds":5400}'

const response = await fetch("https://toolforte.com/api/v1/tools/subtitle-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "1\n00:00:01,000 --> 00:00:03,500\nHello there.",
    "format": "vtt",
    "shiftSeconds": -2.5,
    "scalePercent": 104.271,
    "repair": true,
    "appendText": "1\n00:00:00,500 --> 00:00:02,000\nPart two begins.",
    "appendOffsetSeconds": 5400
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/subtitle-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"1\n00:00:01,000 --> 00:00:03,500\nHello there.","format":"vtt","shiftSeconds":-2.5,"scalePercent":104.271,"repair":true,"appendText":"1\n00:00:00,500 --> 00:00:02,000\nPart two begins.","appendOffsetSeconds":5400},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool add_line_numbers (Add Line Numbers) with text: alpha
beta
gamma, start: 1, step: 1, separator: . , skipEmptyLines: false, padNumbers: false.

The assistant then makes this tool call:

{
  "name": "add_line_numbers",
  "arguments": {
    "text": "alpha\nbeta\ngamma",
    "start": 1,
    "step": 1,
    "separator": ". ",
    "skipEmptyLines": false,
    "padNumbers": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/add-line-numbers \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"alpha\nbeta\ngamma","start":1,"step":1,"separator":". ","skipEmptyLines":false,"padNumbers":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/add-line-numbers", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "alpha\nbeta\ngamma",
    "start": 1,
    "step": 1,
    "separator": ". ",
    "skipEmptyLines": false,
    "padNumbers": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/add-line-numbers",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"alpha\nbeta\ngamma","start":1,"step":1,"separator":". ","skipEmptyLines":false,"padNumbers":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool add_prefix_suffix (Add Prefix and Suffix) with text: apple
banana
cherry, prefix: ', suffix: ',, skipEmptyLines: true.

The assistant then makes this tool call:

{
  "name": "add_prefix_suffix",
  "arguments": {
    "text": "apple\nbanana\ncherry",
    "prefix": "'",
    "suffix": "',",
    "skipEmptyLines": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/add-prefix-suffix \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"apple\nbanana\ncherry","prefix":"'","suffix":"',","skipEmptyLines":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/add-prefix-suffix", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "apple\nbanana\ncherry",
    "prefix": "'",
    "suffix": "',",
    "skipEmptyLines": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/add-prefix-suffix",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"apple\nbanana\ncherry","prefix":"'","suffix":"',","skipEmptyLines":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool remove_line_breaks (Remove Line Breaks) with text: A sentence that
was broken
in three.

A second paragraph., separator:  , keepParagraphs: true.

The assistant then makes this tool call:

{
  "name": "remove_line_breaks",
  "arguments": {
    "text": "A sentence that\nwas broken\nin three.\n\nA second paragraph.",
    "separator": " ",
    "keepParagraphs": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/remove-line-breaks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"A sentence that\nwas broken\nin three.\n\nA second paragraph.","separator":" ","keepParagraphs":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/remove-line-breaks", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "A sentence that\nwas broken\nin three.\n\nA second paragraph.",
    "separator": " ",
    "keepParagraphs": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/remove-line-breaks",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"A sentence that\nwas broken\nin three.\n\nA second paragraph.","separator":" ","keepParagraphs":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool count_characters (Character) with text: Hello world. This is a test!, limit: 5.

The assistant then makes this tool call:

{
  "name": "count_characters",
  "arguments": {
    "text": "Hello world. This is a test!",
    "limit": 5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/character-counter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello world. This is a test!","limit":5}'

const response = await fetch("https://toolforte.com/api/v1/tools/character-counter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Hello world. This is a test!",
    "limit": 5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/character-counter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Hello world. This is a test!","limit":5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool upside_down_text (Upside Down Text) with text: hello world, mode: upside.

The assistant then makes this tool call:

{
  "name": "upside_down_text",
  "arguments": {
    "text": "hello world",
    "mode": "upside"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/upside-down-text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world","mode":"upside"}'

const response = await fetch("https://toolforte.com/api/v1/tools/upside-down-text", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "hello world",
    "mode": "upside"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/upside-down-text",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"hello world","mode":"upside"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool leetspeak (Leetspeak Translator) with text: paste your leet here, action: encode, intensity: basic.

The assistant then makes this tool call:

{
  "name": "leetspeak",
  "arguments": {
    "text": "paste your leet here",
    "action": "encode",
    "intensity": "basic"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/leetspeak-translator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"paste your leet here","action":"encode","intensity":"basic"}'

const response = await fetch("https://toolforte.com/api/v1/tools/leetspeak-translator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "paste your leet here",
    "action": "encode",
    "intensity": "basic"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/leetspeak-translator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"paste your leet here","action":"encode","intensity":"basic"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool keyword_density (Keyword Density Analyzer) with text: Keyword density matters. Keyword density is the share of ..., phraseLength: 2, minCount: 2, limit: 10, excludeStopWords: true, sortBy: count, order: desc, targetKeyword: keyword density.

The assistant then makes this tool call:

{
  "name": "keyword_density",
  "arguments": {
    "text": "Keyword density matters. Keyword density is the share of a page a keyword takes up. Good keyword density is between one and three percent.",
    "phraseLength": 2,
    "minCount": 2,
    "limit": 10,
    "excludeStopWords": true,
    "sortBy": "count",
    "order": "desc",
    "targetKeyword": "keyword density"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/keyword-density-analyzer \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Keyword density matters. Keyword density is the share of a page a keyword takes up. Good keyword density is between one and three percent.","phraseLength":2,"minCount":2,"limit":10,"excludeStopWords":true,"sortBy":"count","order":"desc","targetKeyword":"keyword density"}'

const response = await fetch("https://toolforte.com/api/v1/tools/keyword-density-analyzer", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Keyword density matters. Keyword density is the share of a page a keyword takes up. Good keyword density is between one and three percent.",
    "phraseLength": 2,
    "minCount": 2,
    "limit": 10,
    "excludeStopWords": true,
    "sortBy": "count",
    "order": "desc",
    "targetKeyword": "keyword density"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/keyword-density-analyzer",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Keyword density matters. Keyword density is the share of a page a keyword takes up. Good keyword density is between one and three percent.","phraseLength":2,"minCount":2,"limit":10,"excludeStopWords":true,"sortBy":"count","order":"desc","targetKeyword":"keyword density"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool readability_scores (Readability) with text: The quick brown fox jumps over the lazy dog. This is a sa....

The assistant then makes this tool call:

{
  "name": "readability_scores",
  "arguments": {
    "text": "The quick brown fox jumps over the lazy dog. This is a sample text to demonstrate the readability checker tool."
  }
}

curl -X POST https://toolforte.com/api/v1/tools/readability-checker \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"The quick brown fox jumps over the lazy dog. This is a sample text to demonstrate the readability checker tool."}'

const response = await fetch("https://toolforte.com/api/v1/tools/readability-checker", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "The quick brown fox jumps over the lazy dog. This is a sample text to demonstrate the readability checker tool."
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/readability-checker",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"The quick brown fox jumps over the lazy dog. This is a sample text to demonstrate the readability checker tool."},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool text_similarity (Text Similarity Analyzer) with textA: The quick brown fox jumps over the lazy dog., textB: The quick brown cat jumps over the lazy dog., commonWordLimit: 50, uniqueWordLimit: 30.

The assistant then makes this tool call:

{
  "name": "text_similarity",
  "arguments": {
    "textA": "The quick brown fox jumps over the lazy dog.",
    "textB": "The quick brown cat jumps over the lazy dog.",
    "commonWordLimit": 50,
    "uniqueWordLimit": 30
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-similarity-analyzer \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"textA":"The quick brown fox jumps over the lazy dog.","textB":"The quick brown cat jumps over the lazy dog.","commonWordLimit":50,"uniqueWordLimit":30}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-similarity-analyzer", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "textA": "The quick brown fox jumps over the lazy dog.",
    "textB": "The quick brown cat jumps over the lazy dog.",
    "commonWordLimit": 50,
    "uniqueWordLimit": 30
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-similarity-analyzer",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"textA":"The quick brown fox jumps over the lazy dog.","textB":"The quick brown cat jumps over the lazy dog.","commonWordLimit":50,"uniqueWordLimit":30},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_json (JSON) with json: {"name":"ToolForte","version":1}, action: format, indent: 2.

The assistant then makes this tool call:

{
  "name": "format_json",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"version\":1}",
    "action": "format",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"version\":1}","action":"format","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"version\":1}",
    "action": "format",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"version\":1}","action":"format","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool csv_to_json (CSV to JSON) with csv: name,age
Alice,30
Bob,25, first_row_headers: true.

The assistant then makes this tool call:

{
  "name": "csv_to_json",
  "arguments": {
    "csv": "name,age\nAlice,30\nBob,25",
    "first_row_headers": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,age\nAlice,30\nBob,25","first_row_headers":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "csv": "name,age\nAlice,30\nBob,25",
    "first_row_headers": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"csv":"name,age\nAlice,30\nBob,25","first_row_headers":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_csv (JSON to CSV) with json: [{"name":"Alice","address":{"city":"Utrecht"}},{"name":"B..., delimiter: ,, includeHeader: true, flatten: true.

The assistant then makes this tool call:

{
  "name": "json_to_csv",
  "arguments": {
    "json": "[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]",
    "delimiter": ",",
    "includeHeader": true,
    "flatten": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-csv \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]","delimiter":",","includeHeader":true,"flatten":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-csv", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]",
    "delimiter": ",",
    "includeHeader": true,
    "flatten": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-csv",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]","delimiter":",","includeHeader":true,"flatten":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_yaml (JSON to YAML) with json: {"name":"ToolForte","tags":["fast","free"],"owner":null}, indent: 2, sortKeys: false, nullStyle: null.

The assistant then makes this tool call:

{
  "name": "json_to_yaml",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}",
    "indent": 2,
    "sortKeys": false,
    "nullStyle": "null"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-yaml \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}","indent":2,"sortKeys":false,"nullStyle":"null"}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-yaml", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}",
    "indent": 2,
    "sortKeys": false,
    "nullStyle": "null"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-yaml",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}","indent":2,"sortKeys":false,"nullStyle":"null"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool yaml_to_json (YAML to JSON) with yaml: name: ToolForte
tags:
  - fast
  - free
port: 8080, indent: 2.

The assistant then makes this tool call:

{
  "name": "yaml_to_json",
  "arguments": {
    "yaml": "name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/yaml-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"yaml":"name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/yaml-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "yaml": "name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/yaml-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"yaml":"name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool xml_to_json (XML to JSON) with xml: <order id="42"><item sku="A1">Bolts</item><item sku="B2">..., attributePrefix: @, dropNamespaces: true, indent: 2.

The assistant then makes this tool call:

{
  "name": "xml_to_json",
  "arguments": {
    "xml": "<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>",
    "attributePrefix": "@",
    "dropNamespaces": true,
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/xml-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"xml":"<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>","attributePrefix":"@","dropNamespaces":true,"indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/xml-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "xml": "<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>",
    "attributePrefix": "@",
    "dropNamespaces": true,
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/xml-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"xml":"<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>","attributePrefix":"@","dropNamespaces":true,"indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_xml (JSON to XML) with json: {"name":"ToolForte","tags":["fast","free"]}, rootName: product, declaration: true.

The assistant then makes this tool call:

{
  "name": "json_to_xml",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}",
    "rootName": "product",
    "declaration": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-xml \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}","rootName":"product","declaration":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-xml", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}",
    "rootName": "product",
    "declaration": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-xml",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}","rootName":"product","declaration":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_xml (XML) with xml: <a><b x="1">text</b><c/></a>, mode: pretty, indent: 2.

The assistant then makes this tool call:

{
  "name": "format_xml",
  "arguments": {
    "xml": "<a><b x=\"1\">text</b><c/></a>",
    "mode": "pretty",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/xml-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"xml":"<a><b x=\"1\">text</b><c/></a>","mode":"pretty","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/xml-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "xml": "<a><b x=\"1\">text</b><c/></a>",
    "mode": "pretty",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/xml-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"xml":"<a><b x=\"1\">text</b><c/></a>","mode":"pretty","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool csv_to_markdown (CSV to Markdown) with csv: name,age
Alice,30
Bob,25, delimiter: auto, firstRowHeader: true, padded: true, alignment: left.

The assistant then makes this tool call:

{
  "name": "csv_to_markdown",
  "arguments": {
    "csv": "name,age\nAlice,30\nBob,25",
    "delimiter": "auto",
    "firstRowHeader": true,
    "padded": true,
    "alignment": "left"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-to-markdown \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,age\nAlice,30\nBob,25","delimiter":"auto","firstRowHeader":true,"padded":true,"alignment":"left"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-to-markdown", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "csv": "name,age\nAlice,30\nBob,25",
    "delimiter": "auto",
    "firstRowHeader": true,
    "padded": true,
    "alignment": "left"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-to-markdown",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"csv":"name,age\nAlice,30\nBob,25","delimiter":"auto","firstRowHeader":true,"padded":true,"alignment":"left"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool build_utm_url (UTM) with url: https://example.com/pricing?ref=1, source: newsletter, medium: email, campaign: spring_sale, term: running_shoes, content: header_banner.

The assistant then makes this tool call:

{
  "name": "build_utm_url",
  "arguments": {
    "url": "https://example.com/pricing?ref=1",
    "source": "newsletter",
    "medium": "email",
    "campaign": "spring_sale",
    "term": "running_shoes",
    "content": "header_banner"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/utm-builder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/pricing?ref=1","source":"newsletter","medium":"email","campaign":"spring_sale","term":"running_shoes","content":"header_banner"}'

const response = await fetch("https://toolforte.com/api/v1/tools/utm-builder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "url": "https://example.com/pricing?ref=1",
    "source": "newsletter",
    "medium": "email",
    "campaign": "spring_sale",
    "term": "running_shoes",
    "content": "header_banner"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/utm-builder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"url":"https://example.com/pricing?ref=1","source":"newsletter","medium":"email","campaign":"spring_sale","term":"running_shoes","content":"header_banner"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool merge_csv (CSV Merge) with files: [{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}], mode: byHeader, sourceColumn: true, delimiter: ;.

The assistant then makes this tool call:

{
  "name": "merge_csv",
  "arguments": {
    "files": [
      {
        "name": "jan.csv",
        "text": "id,amount\n1,10\n"
      },
      {
        "name": "feb.csv",
        "text": "amount,id\n20,2\n"
      }
    ],
    "mode": "byHeader",
    "sourceColumn": true,
    "delimiter": ";"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-merge \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"files":[{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}],"mode":"byHeader","sourceColumn":true,"delimiter":";"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-merge", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "files": [
      {
        "name": "jan.csv",
        "text": "id,amount\n1,10\n"
      },
      {
        "name": "feb.csv",
        "text": "amount,id\n20,2\n"
      }
    ],
    "mode": "byHeader",
    "sourceColumn": true,
    "delimiter": ";"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-merge",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"files":[{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}],"mode":"byHeader","sourceColumn":true,"delimiter":";"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool split_csv (CSV Split) with text: id,country
1,NL
2,BE
3,NL
, by: column, size: 1000, column: country, name: orders.

The assistant then makes this tool call:

{
  "name": "split_csv",
  "arguments": {
    "text": "id,country\n1,NL\n2,BE\n3,NL\n",
    "by": "column",
    "size": 1000,
    "column": "country",
    "name": "orders"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-split \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"id,country\n1,NL\n2,BE\n3,NL\n","by":"column","size":1000,"column":"country","name":"orders"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-split", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "id,country\n1,NL\n2,BE\n3,NL\n",
    "by": "column",
    "size": 1000,
    "column": "country",
    "name": "orders"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-split",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"id,country\n1,NL\n2,BE\n3,NL\n","by":"column","size":1000,"column":"country","name":"orders"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool average (Average) with values: [12,15,9,21,15,18].

The assistant then makes this tool call:

{
  "name": "average",
  "arguments": {
    "values": [
      12,
      15,
      9,
      21,
      15,
      18
    ]
  }
}

curl -X POST https://toolforte.com/api/v1/tools/average-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"values":[12,15,9,21,15,18]}'

const response = await fetch("https://toolforte.com/api/v1/tools/average-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "values": [
      12,
      15,
      9,
      21,
      15,
      18
    ]
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/average-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"values":[12,15,9,21,15,18]},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool standard_deviation (Standard Deviation) with values: [4,8,15,16,23,42], type: sample.

The assistant then makes this tool call:

{
  "name": "standard_deviation",
  "arguments": {
    "values": [
      4,
      8,
      15,
      16,
      23,
      42
    ],
    "type": "sample"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/standard-deviation-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"values":[4,8,15,16,23,42],"type":"sample"}'

const response = await fetch("https://toolforte.com/api/v1/tools/standard-deviation-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "values": [
      4,
      8,
      15,
      16,
      23,
      42
    ],
    "type": "sample"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/standard-deviation-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"values":[4,8,15,16,23,42],"type":"sample"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool tsv_to_csv (TSV to CSV) with text: product	description	price
AB-12	Hex bolt, stainless	0,45, direction: tsv-to-csv, delimiter: ,, crlf: false, byteOrderMark: false, trailingNewline: false.

The assistant then makes this tool call:

{
  "name": "tsv_to_csv",
  "arguments": {
    "text": "product\tdescription\tprice\nAB-12\tHex bolt, stainless\t0,45",
    "direction": "tsv-to-csv",
    "delimiter": ",",
    "crlf": false,
    "byteOrderMark": false,
    "trailingNewline": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/tsv-to-csv \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"product\tdescription\tprice\nAB-12\tHex bolt, stainless\t0,45","direction":"tsv-to-csv","delimiter":",","crlf":false,"byteOrderMark":false,"trailingNewline":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/tsv-to-csv", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "product\tdescription\tprice\nAB-12\tHex bolt, stainless\t0,45",
    "direction": "tsv-to-csv",
    "delimiter": ",",
    "crlf": false,
    "byteOrderMark": false,
    "trailingNewline": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/tsv-to-csv",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"product\tdescription\tprice\nAB-12\tHex bolt, stainless\t0,45","direction":"tsv-to-csv","delimiter":",","crlf":false,"byteOrderMark":false,"trailingNewline":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool csv_extract_columns (CSV Column Extractor) with csv: name,email,city
Alice,alice@example.com,Amsterdam
Bob,bob..., columns: ["city","name"], exclude: false, delimiter: auto, firstRowHeader: true, format: csv.

The assistant then makes this tool call:

{
  "name": "csv_extract_columns",
  "arguments": {
    "csv": "name,email,city\nAlice,alice@example.com,Amsterdam\nBob,bob@example.com,Utrecht",
    "columns": [
      "city",
      "name"
    ],
    "exclude": false,
    "delimiter": "auto",
    "firstRowHeader": true,
    "format": "csv"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-column-extractor \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,email,city\nAlice,alice@example.com,Amsterdam\nBob,bob@example.com,Utrecht","columns":["city","name"],"exclude":false,"delimiter":"auto","firstRowHeader":true,"format":"csv"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-column-extractor", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "csv": "name,email,city\nAlice,alice@example.com,Amsterdam\nBob,bob@example.com,Utrecht",
    "columns": [
      "city",
      "name"
    ],
    "exclude": false,
    "delimiter": "auto",
    "firstRowHeader": true,
    "format": "csv"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-column-extractor",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"csv":"name,email,city\nAlice,alice@example.com,Amsterdam\nBob,bob@example.com,Utrecht","columns":["city","name"],"exclude":false,"delimiter":"auto","firstRowHeader":true,"format":"csv"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool url_encode (URL Encoder/Decoder) with input: hello world & more, action: encode.

The assistant then makes this tool call:

{
  "name": "url_encode",
  "arguments": {
    "input": "hello world & more",
    "action": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/url-encoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"hello world & more","action":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/url-encoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": "hello world & more",
    "action": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/url-encoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input":"hello world & more","action":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool base64 (Base64 Encode/Decode) with input: ToolForte, action: encode.

The assistant then makes this tool call:

{
  "name": "base64",
  "arguments": {
    "input": "ToolForte",
    "action": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/base64 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"ToolForte","action":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/base64", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": "ToolForte",
    "action": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/base64",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input":"ToolForte","action":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool test_regex (Regex Tester) with pattern: \b\w+@\w+\.\w+\b, test_string: write to ada@example.com today, flags: g.

The assistant then makes this tool call:

{
  "name": "test_regex",
  "arguments": {
    "pattern": "\\b\\w+@\\w+\\.\\w+\\b",
    "test_string": "write to ada@example.com today",
    "flags": "g"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/regex-tester \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"pattern":"\\b\\w+@\\w+\\.\\w+\\b","test_string":"write to ada@example.com today","flags":"g"}'

const response = await fetch("https://toolforte.com/api/v1/tools/regex-tester", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "pattern": "\\b\\w+@\\w+\\.\\w+\\b",
    "test_string": "write to ada@example.com today",
    "flags": "g"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/regex-tester",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"pattern":"\\b\\w+@\\w+\\.\\w+\\b","test_string":"write to ada@example.com today","flags":"g"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool parse_cron (Cron Parser) with expression: 0 9 * * 1.

The assistant then makes this tool call:

{
  "name": "parse_cron",
  "arguments": {
    "expression": "0 9 * * 1"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/cron-parser \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expression":"0 9 * * 1"}'

const response = await fetch("https://toolforte.com/api/v1/tools/cron-parser", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "expression": "0 9 * * 1"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/cron-parser",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"expression":"0 9 * * 1"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_uuids (UUID) with count: 3, format: uuid, display_format: default.

The assistant then makes this tool call:

{
  "name": "generate_uuids",
  "arguments": {
    "count": 3,
    "format": "uuid",
    "display_format": "default"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/uuid-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":3,"format":"uuid","display_format":"default"}'

const response = await fetch("https://toolforte.com/api/v1/tools/uuid-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 3,
    "format": "uuid",
    "display_format": "default"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/uuid-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"count":3,"format":"uuid","display_format":"default"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_sql (SQL) with sql: select id, name from users where active = 1 and role = 'a....

The assistant then makes this tool call:

{
  "name": "format_sql",
  "arguments": {
    "sql": "select id, name from users where active = 1 and role = 'admin' order by name"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sql-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sql":"select id, name from users where active = 1 and role = 'admin' order by name"}'

const response = await fetch("https://toolforte.com/api/v1/tools/sql-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sql": "select id, name from users where active = 1 and role = 'admin' order by name"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sql-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sql":"select id, name from users where active = 1 and role = 'admin' order by name"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool html_entities (HTML Entity) with text: <a href="x">Tom & Jerry</a>, mode: encode, encodeNonAscii: false.

The assistant then makes this tool call:

{
  "name": "html_entities",
  "arguments": {
    "text": "<a href=\"x\">Tom & Jerry</a>",
    "mode": "encode",
    "encodeNonAscii": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/html-entity-encoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<a href=\"x\">Tom & Jerry</a>","mode":"encode","encodeNonAscii":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/html-entity-encoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "<a href=\"x\">Tom & Jerry</a>",
    "mode": "encode",
    "encodeNonAscii": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/html-entity-encoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"<a href=\"x\">Tom & Jerry</a>","mode":"encode","encodeNonAscii":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_typescript (JSON to TypeScript) with json: {"id":1,"name":"Ada","address":{"city":"Utrecht"},"tags":..., rootName: User, exportInterfaces: true, optionalProps: false, readonlyProps: false.

The assistant then makes this tool call:

{
  "name": "json_to_typescript",
  "arguments": {
    "json": "{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}",
    "rootName": "User",
    "exportInterfaces": true,
    "optionalProps": false,
    "readonlyProps": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-typescript \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}","rootName":"User","exportInterfaces":true,"optionalProps":false,"readonlyProps":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-typescript", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}",
    "rootName": "User",
    "exportInterfaces": true,
    "optionalProps": false,
    "readonlyProps": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-typescript",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}","rootName":"User","exportInterfaces":true,"optionalProps":false,"readonlyProps":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool hash_text (Hash) with text: hello world, algorithm: SHA-256.

The assistant then makes this tool call:

{
  "name": "hash_text",
  "arguments": {
    "text": "hello world",
    "algorithm": "SHA-256"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/hash-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world","algorithm":"SHA-256"}'

const response = await fetch("https://toolforte.com/api/v1/tools/hash-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "hello world",
    "algorithm": "SHA-256"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/hash-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"hello world","algorithm":"SHA-256"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool decode_jwt (JWT) with token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3..., now: 2026-09-07T12:00:00Z.

The assistant then makes this tool call:

{
  "name": "decode_jwt",
  "arguments": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
    "now": "2026-09-07T12:00:00Z"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/jwt-decoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c","now":"2026-09-07T12:00:00Z"}'

const response = await fetch("https://toolforte.com/api/v1/tools/jwt-decoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
    "now": "2026-09-07T12:00:00Z"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/jwt-decoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c","now":"2026-09-07T12:00:00Z"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_number_base (Number Base) with value: 255, fromBase: 10, toBase: 2.

The assistant then makes this tool call:

{
  "name": "convert_number_base",
  "arguments": {
    "value": "255",
    "fromBase": 10,
    "toBase": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/number-base-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":"255","fromBase":10,"toBase":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/number-base-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": "255",
    "fromBase": 10,
    "toBase": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/number-base-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":"255","fromBase":10,"toBase":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool chmod (Chmod) with permissions: 755.

The assistant then makes this tool call:

{
  "name": "chmod",
  "arguments": {
    "permissions": "755"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/chmod-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"permissions":"755"}'

const response = await fetch("https://toolforte.com/api/v1/tools/chmod-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "permissions": "755"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/chmod-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"permissions":"755"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool http_status (HTTP Status Codes) with query: 404.

The assistant then makes this tool call:

{
  "name": "http_status",
  "arguments": {
    "query": "404"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/http-status-codes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"404"}'

const response = await fetch("https://toolforte.com/api/v1/tools/http-status-codes", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "query": "404"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/http-status-codes",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"query":"404"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool text_to_binary (Text to Binary) with input: Hi, action: encode, format: binary, separator: space.

The assistant then makes this tool call:

{
  "name": "text_to_binary",
  "arguments": {
    "input": "Hi",
    "action": "encode",
    "format": "binary",
    "separator": "space"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-to-binary \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"Hi","action":"encode","format":"binary","separator":"space"}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-to-binary", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": "Hi",
    "action": "encode",
    "format": "binary",
    "separator": "space"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-to-binary",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input":"Hi","action":"encode","format":"binary","separator":"space"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_color (Color) with color: #c5f04a.

The assistant then makes this tool call:

{
  "name": "convert_color",
  "arguments": {
    "color": "#c5f04a"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/color-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"color":"#c5f04a"}'

const response = await fetch("https://toolforte.com/api/v1/tools/color-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "color": "#c5f04a"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/color-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"color":"#c5f04a"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool color_contrast (Color Contrast) with foreground: #1e293b, background: #ffffff.

The assistant then makes this tool call:

{
  "name": "color_contrast",
  "arguments": {
    "foreground": "#1e293b",
    "background": "#ffffff"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/color-contrast-checker \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"foreground":"#1e293b","background":"#ffffff"}'

const response = await fetch("https://toolforte.com/api/v1/tools/color-contrast-checker", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "foreground": "#1e293b",
    "background": "#ffffff"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/color-contrast-checker",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"foreground":"#1e293b","background":"#ffffff"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool password_strength (Password Strength) with password: correct-horse-battery-staple.

The assistant then makes this tool call:

{
  "name": "password_strength",
  "arguments": {
    "password": "correct-horse-battery-staple"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/password-strength \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"password":"correct-horse-battery-staple"}'

const response = await fetch("https://toolforte.com/api/v1/tools/password-strength", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "password": "correct-horse-battery-staple"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/password-strength",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"password":"correct-horse-battery-staple"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_password (Password) with length: 16, uppercase: true, lowercase: true, numbers: true, symbols: true, excludeAmbiguous: false, count: 1.

The assistant then makes this tool call:

{
  "name": "generate_password",
  "arguments": {
    "length": 16,
    "uppercase": true,
    "lowercase": true,
    "numbers": true,
    "symbols": true,
    "excludeAmbiguous": false,
    "count": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/password-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"length":16,"uppercase":true,"lowercase":true,"numbers":true,"symbols":true,"excludeAmbiguous":false,"count":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/password-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "length": 16,
    "uppercase": true,
    "lowercase": true,
    "numbers": true,
    "symbols": true,
    "excludeAmbiguous": false,
    "count": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/password-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"length":16,"uppercase":true,"lowercase":true,"numbers":true,"symbols":true,"excludeAmbiguous":false,"count":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool validate_email (Email) with email: user@gmial.com.

The assistant then makes this tool call:

{
  "name": "validate_email",
  "arguments": {
    "email": "user@gmial.com"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/email-validator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@gmial.com"}'

const response = await fetch("https://toolforte.com/api/v1/tools/email-validator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "email": "user@gmial.com"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/email-validator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"email":"user@gmial.com"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool validate_card_number (Card Number) with cardNumber: 4242 4242 4242 4242.

The assistant then makes this tool call:

{
  "name": "validate_card_number",
  "arguments": {
    "cardNumber": "4242 4242 4242 4242"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/credit-card-validator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"cardNumber":"4242 4242 4242 4242"}'

const response = await fetch("https://toolforte.com/api/v1/tools/credit-card-validator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "cardNumber": "4242 4242 4242 4242"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/credit-card-validator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"cardNumber":"4242 4242 4242 4242"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool validate_iban (IBAN) with iban: NL91 ABNA 0417 1643 00.

The assistant then makes this tool call:

{
  "name": "validate_iban",
  "arguments": {
    "iban": "NL91 ABNA 0417 1643 00"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/iban-validator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"iban":"NL91 ABNA 0417 1643 00"}'

const response = await fetch("https://toolforte.com/api/v1/tools/iban-validator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "iban": "NL91 ABNA 0417 1643 00"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/iban-validator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"iban":"NL91 ABNA 0417 1643 00"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool calculate_vat (VAT) with amount: 100, rate: 21, mode: add.

The assistant then makes this tool call:

{
  "name": "calculate_vat",
  "arguments": {
    "amount": 100,
    "rate": 21,
    "mode": "add"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/vat-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":100,"rate":21,"mode":"add"}'

const response = await fetch("https://toolforte.com/api/v1/tools/vat-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 100,
    "rate": 21,
    "mode": "add"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/vat-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":100,"rate":21,"mode":"add"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool check_vat_number_format (VAT Number Format Check) with vatNumber: NL123456789B01.

The assistant then makes this tool call:

{
  "name": "check_vat_number_format",
  "arguments": {
    "vatNumber": "NL123456789B01"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/vat-number-check \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"vatNumber":"NL123456789B01"}'

const response = await fetch("https://toolforte.com/api/v1/tools/vat-number-check", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "vatNumber": "NL123456789B01"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/vat-number-check",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"vatNumber":"NL123456789B01"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool percentage (Percentage) with mode: percentOf, x: 15, y: 200.

The assistant then makes this tool call:

{
  "name": "percentage",
  "arguments": {
    "mode": "percentOf",
    "x": 15,
    "y": 200
  }
}

curl -X POST https://toolforte.com/api/v1/tools/percentage-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"percentOf","x":15,"y":200}'

const response = await fetch("https://toolforte.com/api/v1/tools/percentage-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "percentOf",
    "x": 15,
    "y": 200
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/percentage-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"percentOf","x":15,"y":200},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool compound_interest (Compound Interest) with principal: 10000, annualRatePercent: 7, years: 10, compoundsPerYear: 12, monthlyContribution: 100.

The assistant then makes this tool call:

{
  "name": "compound_interest",
  "arguments": {
    "principal": 10000,
    "annualRatePercent": 7,
    "years": 10,
    "compoundsPerYear": 12,
    "monthlyContribution": 100
  }
}

curl -X POST https://toolforte.com/api/v1/tools/compound-interest-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":10000,"annualRatePercent":7,"years":10,"compoundsPerYear":12,"monthlyContribution":100}'

const response = await fetch("https://toolforte.com/api/v1/tools/compound-interest-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "principal": 10000,
    "annualRatePercent": 7,
    "years": 10,
    "compoundsPerYear": 12,
    "monthlyContribution": 100
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/compound-interest-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"principal":10000,"annualRatePercent":7,"years":10,"compoundsPerYear":12,"monthlyContribution":100},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool loan_payment (Loan) with amount: 250000, annualRatePercent: 4.5, term: 30, termUnit: years.

The assistant then makes this tool call:

{
  "name": "loan_payment",
  "arguments": {
    "amount": 250000,
    "annualRatePercent": 4.5,
    "term": 30,
    "termUnit": "years"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/loan-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":250000,"annualRatePercent":4.5,"term":30,"termUnit":"years"}'

const response = await fetch("https://toolforte.com/api/v1/tools/loan-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 250000,
    "annualRatePercent": 4.5,
    "term": 30,
    "termUnit": "years"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/loan-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":250000,"annualRatePercent":4.5,"term":30,"termUnit":"years"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool discount (Discount) with price: 80, discountPercent: 25, additionalDiscountPercents: [10], vatPercent: 21.

The assistant then makes this tool call:

{
  "name": "discount",
  "arguments": {
    "price": 80,
    "discountPercent": 25,
    "additionalDiscountPercents": [
      10
    ],
    "vatPercent": 21
  }
}

curl -X POST https://toolforte.com/api/v1/tools/discount-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"price":80,"discountPercent":25,"additionalDiscountPercents":[10],"vatPercent":21}'

const response = await fetch("https://toolforte.com/api/v1/tools/discount-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "price": 80,
    "discountPercent": 25,
    "additionalDiscountPercents": [
      10
    ],
    "vatPercent": 21
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/discount-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"price":80,"discountPercent":25,"additionalDiscountPercents":[10],"vatPercent":21},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool split_tip (Tip) with bill: 86.4, tipPercent: 15, people: 4, roundUp: false.

The assistant then makes this tool call:

{
  "name": "split_tip",
  "arguments": {
    "bill": 86.4,
    "tipPercent": 15,
    "people": 4,
    "roundUp": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/tip-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"bill":86.4,"tipPercent":15,"people":4,"roundUp":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/tip-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "bill": 86.4,
    "tipPercent": 15,
    "people": 4,
    "roundUp": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/tip-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"bill":86.4,"tipPercent":15,"people":4,"roundUp":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool roi (ROI) with invested: 10000, returned: 14000, years: 3.

The assistant then makes this tool call:

{
  "name": "roi",
  "arguments": {
    "invested": 10000,
    "returned": 14000,
    "years": 3
  }
}

curl -X POST https://toolforte.com/api/v1/tools/roi-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"invested":10000,"returned":14000,"years":3}'

const response = await fetch("https://toolforte.com/api/v1/tools/roi-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "invested": 10000,
    "returned": 14000,
    "years": 3
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/roi-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"invested":10000,"returned":14000,"years":3},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool break_even (Break-even) with fixedCosts: 5000, variableCostPerUnit: 10, pricePerUnit: 25, volume: 500.

The assistant then makes this tool call:

{
  "name": "break_even",
  "arguments": {
    "fixedCosts": 5000,
    "variableCostPerUnit": 10,
    "pricePerUnit": 25,
    "volume": 500
  }
}

curl -X POST https://toolforte.com/api/v1/tools/break-even-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"fixedCosts":5000,"variableCostPerUnit":10,"pricePerUnit":25,"volume":500}'

const response = await fetch("https://toolforte.com/api/v1/tools/break-even-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "fixedCosts": 5000,
    "variableCostPerUnit": 10,
    "pricePerUnit": 25,
    "volume": 500
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/break-even-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"fixedCosts":5000,"variableCostPerUnit":10,"pricePerUnit":25,"volume":500},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_inheritance_tax (Dutch Inheritance Tax) with amount: 100000, heir: child.

The assistant then makes this tool call:

{
  "name": "dutch_inheritance_tax",
  "arguments": {
    "amount": 100000,
    "heir": "child"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/erfbelasting-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":100000,"heir":"child"}'

const response = await fetch("https://toolforte.com/api/v1/tools/erfbelasting-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 100000,
    "heir": "child"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/erfbelasting-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":100000,"heir":"child"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_gift_tax (Dutch Gift Tax) with amount: 25000, relationship: child, exemption: annual.

The assistant then makes this tool call:

{
  "name": "dutch_gift_tax",
  "arguments": {
    "amount": 25000,
    "relationship": "child",
    "exemption": "annual"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/schenkbelasting-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":25000,"relationship":"child","exemption":"annual"}'

const response = await fetch("https://toolforte.com/api/v1/tools/schenkbelasting-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 25000,
    "relationship": "child",
    "exemption": "annual"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/schenkbelasting-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":25000,"relationship":"child","exemption":"annual"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_ww_duration (Dutch WW Duration) with birthYear: 1975, workedYearsSince1998: 20.

The assistant then makes this tool call:

{
  "name": "dutch_ww_duration",
  "arguments": {
    "birthYear": 1975,
    "workedYearsSince1998": 20
  }
}

curl -X POST https://toolforte.com/api/v1/tools/ww-duration-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthYear":1975,"workedYearsSince1998":20}'

const response = await fetch("https://toolforte.com/api/v1/tools/ww-duration-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthYear": 1975,
    "workedYearsSince1998": 20
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/ww-duration-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthYear":1975,"workedYearsSince1998":20},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_30_percent_ruling (30% Ruling) with grossAnnualSalary: 70000, youngMaster: false.

The assistant then makes this tool call:

{
  "name": "dutch_30_percent_ruling",
  "arguments": {
    "grossAnnualSalary": 70000,
    "youngMaster": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/30-percent-ruling-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"grossAnnualSalary":70000,"youngMaster":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/30-percent-ruling-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "grossAnnualSalary": 70000,
    "youngMaster": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/30-percent-ruling-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"grossAnnualSalary":70000,"youngMaster":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_holiday_allowance (Dutch Holiday Allowance) with monthlySalary: 3500, monthsWorked: 12, allowancePercent: 8, specialRatePercent: 42.01.

The assistant then makes this tool call:

{
  "name": "dutch_holiday_allowance",
  "arguments": {
    "monthlySalary": 3500,
    "monthsWorked": 12,
    "allowancePercent": 8,
    "specialRatePercent": 42.01
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"monthlySalary":3500,"monthsWorked":12,"allowancePercent":8,"specialRatePercent":42.01}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "monthlySalary": 3500,
    "monthsWorked": 12,
    "allowancePercent": 8,
    "specialRatePercent": 42.01
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"monthlySalary":3500,"monthsWorked":12,"allowancePercent":8,"specialRatePercent":42.01},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_severance (Dutch Severance) with monthlySalary: 3500, fixedAnnualBonuses: 0, includeHolidayAllowance: true, startDate: 2018-01-01, endDate: 2026-12-31.

The assistant then makes this tool call:

{
  "name": "dutch_severance",
  "arguments": {
    "monthlySalary": 3500,
    "fixedAnnualBonuses": 0,
    "includeHolidayAllowance": true,
    "startDate": "2018-01-01",
    "endDate": "2026-12-31"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-severance-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"monthlySalary":3500,"fixedAnnualBonuses":0,"includeHolidayAllowance":true,"startDate":"2018-01-01","endDate":"2026-12-31"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-severance-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "monthlySalary": 3500,
    "fixedAnnualBonuses": 0,
    "includeHolidayAllowance": true,
    "startDate": "2018-01-01",
    "endDate": "2026-12-31"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-severance-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"monthlySalary":3500,"fixedAnnualBonuses":0,"includeHolidayAllowance":true,"startDate":"2018-01-01","endDate":"2026-12-31"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_mileage_allowance (Dutch Mileage Allowance) with kmPerTrip: 25, tripsPerWeek: 8, kmPerWeek: 200, weeksPerYear: 46, ratePerKm: 0.25.

The assistant then makes this tool call:

{
  "name": "dutch_mileage_allowance",
  "arguments": {
    "kmPerTrip": 25,
    "tripsPerWeek": 8,
    "kmPerWeek": 200,
    "weeksPerYear": 46,
    "ratePerKm": 0.25
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-mileage-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kmPerTrip":25,"tripsPerWeek":8,"kmPerWeek":200,"weeksPerYear":46,"ratePerKm":0.25}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-mileage-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "kmPerTrip": 25,
    "tripsPerWeek": 8,
    "kmPerWeek": 200,
    "weeksPerYear": 46,
    "ratePerKm": 0.25
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-mileage-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"kmPerTrip":25,"tripsPerWeek":8,"kmPerWeek":200,"weeksPerYear":46,"ratePerKm":0.25},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool mortgage_payment (Mortgage) with homePrice: 350000, downPayment: 70000, annualRatePercent: 4.5, termYears: 30, paymentFrequency: monthly.

The assistant then makes this tool call:

{
  "name": "mortgage_payment",
  "arguments": {
    "homePrice": 350000,
    "downPayment": 70000,
    "annualRatePercent": 4.5,
    "termYears": 30,
    "paymentFrequency": "monthly"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/mortgage-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"homePrice":350000,"downPayment":70000,"annualRatePercent":4.5,"termYears":30,"paymentFrequency":"monthly"}'

const response = await fetch("https://toolforte.com/api/v1/tools/mortgage-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "homePrice": 350000,
    "downPayment": 70000,
    "annualRatePercent": 4.5,
    "termYears": 30,
    "paymentFrequency": "monthly"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/mortgage-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"homePrice":350000,"downPayment":70000,"annualRatePercent":4.5,"termYears":30,"paymentFrequency":"monthly"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool simple_interest (Simple Interest) with principal: 10000, annualRatePercent: 5, time: 3, timeUnit: years.

The assistant then makes this tool call:

{
  "name": "simple_interest",
  "arguments": {
    "principal": 10000,
    "annualRatePercent": 5,
    "time": 3,
    "timeUnit": "years"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/simple-interest-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":10000,"annualRatePercent":5,"time":3,"timeUnit":"years"}'

const response = await fetch("https://toolforte.com/api/v1/tools/simple-interest-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "principal": 10000,
    "annualRatePercent": 5,
    "time": 3,
    "timeUnit": "years"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/simple-interest-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"principal":10000,"annualRatePercent":5,"time":3,"timeUnit":"years"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool investment_growth (Investment) with initialInvestment: 10000, monthlyContribution: 500, annualReturnPercent: 7, years: 20.

The assistant then makes this tool call:

{
  "name": "investment_growth",
  "arguments": {
    "initialInvestment": 10000,
    "monthlyContribution": 500,
    "annualReturnPercent": 7,
    "years": 20
  }
}

curl -X POST https://toolforte.com/api/v1/tools/investment-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"initialInvestment":10000,"monthlyContribution":500,"annualReturnPercent":7,"years":20}'

const response = await fetch("https://toolforte.com/api/v1/tools/investment-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "initialInvestment": 10000,
    "monthlyContribution": 500,
    "annualReturnPercent": 7,
    "years": 20
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/investment-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"initialInvestment":10000,"monthlyContribution":500,"annualReturnPercent":7,"years":20},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool sip_returns (SIP) with monthlyInvestment: 5000, expectedAnnualReturnPercent: 12, years: 10.

The assistant then makes this tool call:

{
  "name": "sip_returns",
  "arguments": {
    "monthlyInvestment": 5000,
    "expectedAnnualReturnPercent": 12,
    "years": 10
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sip-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"monthlyInvestment":5000,"expectedAnnualReturnPercent":12,"years":10}'

const response = await fetch("https://toolforte.com/api/v1/tools/sip-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "monthlyInvestment": 5000,
    "expectedAnnualReturnPercent": 12,
    "years": 10
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sip-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"monthlyInvestment":5000,"expectedAnnualReturnPercent":12,"years":10},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool emi (EMI) with loanAmount: 1000000, annualRatePercent: 8.5, tenure: 20, tenureUnit: years.

The assistant then makes this tool call:

{
  "name": "emi",
  "arguments": {
    "loanAmount": 1000000,
    "annualRatePercent": 8.5,
    "tenure": 20,
    "tenureUnit": "years"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/emi-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"loanAmount":1000000,"annualRatePercent":8.5,"tenure":20,"tenureUnit":"years"}'

const response = await fetch("https://toolforte.com/api/v1/tools/emi-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "loanAmount": 1000000,
    "annualRatePercent": 8.5,
    "tenure": 20,
    "tenureUnit": "years"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/emi-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"loanAmount":1000000,"annualRatePercent":8.5,"tenure":20,"tenureUnit":"years"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool profit_margin (Profit Margin) with mode: margin, cost: 60, revenue: 100, targetMarginPercent: 40.

The assistant then makes this tool call:

{
  "name": "profit_margin",
  "arguments": {
    "mode": "margin",
    "cost": 60,
    "revenue": 100,
    "targetMarginPercent": 40
  }
}

curl -X POST https://toolforte.com/api/v1/tools/profit-margin-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"margin","cost":60,"revenue":100,"targetMarginPercent":40}'

const response = await fetch("https://toolforte.com/api/v1/tools/profit-margin-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "margin",
    "cost": 60,
    "revenue": 100,
    "targetMarginPercent": 40
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/profit-margin-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"margin","cost":60,"revenue":100,"targetMarginPercent":40},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool margin_markup (Margin and Markup) with mode: costRevenue, cost: 60, revenue: 100, marginPercent: 40.

The assistant then makes this tool call:

{
  "name": "margin_markup",
  "arguments": {
    "mode": "costRevenue",
    "cost": 60,
    "revenue": 100,
    "marginPercent": 40
  }
}

curl -X POST https://toolforte.com/api/v1/tools/margin-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"costRevenue","cost":60,"revenue":100,"marginPercent":40}'

const response = await fetch("https://toolforte.com/api/v1/tools/margin-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "costRevenue",
    "cost": 60,
    "revenue": 100,
    "marginPercent": 40
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/margin-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"costRevenue","cost":60,"revenue":100,"marginPercent":40},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool commission (Commission) with saleAmount: 50000, mode: tiered, ratePercent: 5, tiers: [{"upTo":10000,"ratePercent":3},{"upTo":30000,"ratePercent":5},{"ratePercent":8}].

The assistant then makes this tool call:

{
  "name": "commission",
  "arguments": {
    "saleAmount": 50000,
    "mode": "tiered",
    "ratePercent": 5,
    "tiers": [
      {
        "upTo": 10000,
        "ratePercent": 3
      },
      {
        "upTo": 30000,
        "ratePercent": 5
      },
      {
        "ratePercent": 8
      }
    ]
  }
}

curl -X POST https://toolforte.com/api/v1/tools/commission-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"saleAmount":50000,"mode":"tiered","ratePercent":5,"tiers":[{"upTo":10000,"ratePercent":3},{"upTo":30000,"ratePercent":5},{"ratePercent":8}]}'

const response = await fetch("https://toolforte.com/api/v1/tools/commission-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "saleAmount": 50000,
    "mode": "tiered",
    "ratePercent": 5,
    "tiers": [
      {
        "upTo": 10000,
        "ratePercent": 3
      },
      {
        "upTo": 30000,
        "ratePercent": 5
      },
      {
        "ratePercent": 8
      }
    ]
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/commission-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"saleAmount":50000,"mode":"tiered","ratePercent":5,"tiers":[{"upTo":10000,"ratePercent":3},{"upTo":30000,"ratePercent":5},{"ratePercent":8}]},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool sales_tax (Sales Tax) with amount: 100, ratePercent: 8.875, mode: add.

The assistant then makes this tool call:

{
  "name": "sales_tax",
  "arguments": {
    "amount": 100,
    "ratePercent": 8.875,
    "mode": "add"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sales-tax-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":100,"ratePercent":8.875,"mode":"add"}'

const response = await fetch("https://toolforte.com/api/v1/tools/sales-tax-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 100,
    "ratePercent": 8.875,
    "mode": "add"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sales-tax-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":100,"ratePercent":8.875,"mode":"add"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool gst (GST) with amount: 10000, ratePercent: 18, mode: add.

The assistant then makes this tool call:

{
  "name": "gst",
  "arguments": {
    "amount": 10000,
    "ratePercent": 18,
    "mode": "add"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/gst-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":10000,"ratePercent":18,"mode":"add"}'

const response = await fetch("https://toolforte.com/api/v1/tools/gst-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 10000,
    "ratePercent": 18,
    "mode": "add"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/gst-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":10000,"ratePercent":18,"mode":"add"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool inflation_adjust (Inflation) with mode: cpi, amount: 100, annualRatePercent: 3, years: 10, fromYear: 1990, toYear: 2025.

The assistant then makes this tool call:

{
  "name": "inflation_adjust",
  "arguments": {
    "mode": "cpi",
    "amount": 100,
    "annualRatePercent": 3,
    "years": 10,
    "fromYear": 1990,
    "toYear": 2025
  }
}

curl -X POST https://toolforte.com/api/v1/tools/inflation-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"cpi","amount":100,"annualRatePercent":3,"years":10,"fromYear":1990,"toYear":2025}'

const response = await fetch("https://toolforte.com/api/v1/tools/inflation-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "cpi",
    "amount": 100,
    "annualRatePercent": 3,
    "years": 10,
    "fromYear": 1990,
    "toYear": 2025
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/inflation-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"cpi","amount":100,"annualRatePercent":3,"years":10,"fromYear":1990,"toYear":2025},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool retirement_savings (Retirement) with currentAge: 30, retirementAge: 67, currentSavings: 25000, monthlyContribution: 500, annualReturnPercent: 7, annualInflationPercent: 2.5.

The assistant then makes this tool call:

{
  "name": "retirement_savings",
  "arguments": {
    "currentAge": 30,
    "retirementAge": 67,
    "currentSavings": 25000,
    "monthlyContribution": 500,
    "annualReturnPercent": 7,
    "annualInflationPercent": 2.5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/retirement-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"currentAge":30,"retirementAge":67,"currentSavings":25000,"monthlyContribution":500,"annualReturnPercent":7,"annualInflationPercent":2.5}'

const response = await fetch("https://toolforte.com/api/v1/tools/retirement-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "currentAge": 30,
    "retirementAge": 67,
    "currentSavings": 25000,
    "monthlyContribution": 500,
    "annualReturnPercent": 7,
    "annualInflationPercent": 2.5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/retirement-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"currentAge":30,"retirementAge":67,"currentSavings":25000,"monthlyContribution":500,"annualReturnPercent":7,"annualInflationPercent":2.5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool debt_payoff (Debt Payoff) with debts: [{"name":"Credit card","balance":3500,"aprPercent":21,"minPayment":90},{"name":"Car loan","balance":9000,"aprPercent":7.5,"minPayment":260}], extraMonthlyPayment: 200.

The assistant then makes this tool call:

{
  "name": "debt_payoff",
  "arguments": {
    "debts": [
      {
        "name": "Credit card",
        "balance": 3500,
        "aprPercent": 21,
        "minPayment": 90
      },
      {
        "name": "Car loan",
        "balance": 9000,
        "aprPercent": 7.5,
        "minPayment": 260
      }
    ],
    "extraMonthlyPayment": 200
  }
}

curl -X POST https://toolforte.com/api/v1/tools/debt-payoff-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"debts":[{"name":"Credit card","balance":3500,"aprPercent":21,"minPayment":90},{"name":"Car loan","balance":9000,"aprPercent":7.5,"minPayment":260}],"extraMonthlyPayment":200}'

const response = await fetch("https://toolforte.com/api/v1/tools/debt-payoff-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "debts": [
      {
        "name": "Credit card",
        "balance": 3500,
        "aprPercent": 21,
        "minPayment": 90
      },
      {
        "name": "Car loan",
        "balance": 9000,
        "aprPercent": 7.5,
        "minPayment": 260
      }
    ],
    "extraMonthlyPayment": 200
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/debt-payoff-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"debts":[{"name":"Credit card","balance":3500,"aprPercent":21,"minPayment":90},{"name":"Car loan","balance":9000,"aprPercent":7.5,"minPayment":260}],"extraMonthlyPayment":200},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool savings_goal (Savings Goal) with mode: monthsToGoal, goal: 10000, currentSavings: 1500, monthlyDeposit: 300, months: 24, annualRatePercent: 2.5.

The assistant then makes this tool call:

{
  "name": "savings_goal",
  "arguments": {
    "mode": "monthsToGoal",
    "goal": 10000,
    "currentSavings": 1500,
    "monthlyDeposit": 300,
    "months": 24,
    "annualRatePercent": 2.5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/savings-goal-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"monthsToGoal","goal":10000,"currentSavings":1500,"monthlyDeposit":300,"months":24,"annualRatePercent":2.5}'

const response = await fetch("https://toolforte.com/api/v1/tools/savings-goal-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "monthsToGoal",
    "goal": 10000,
    "currentSavings": 1500,
    "monthlyDeposit": 300,
    "months": 24,
    "annualRatePercent": 2.5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/savings-goal-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"monthsToGoal","goal":10000,"currentSavings":1500,"monthlyDeposit":300,"months":24,"annualRatePercent":2.5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool split_bill (Split Bill) with people: ["Alex","Sam","Kim"], expenses: [{"payer":"Alex","description":"Dinner","amount":84},{"payer":"Sam","description":"Taxi","amount":21}], tipPercent: 10, roundTransfersTo: 5.

The assistant then makes this tool call:

{
  "name": "split_bill",
  "arguments": {
    "people": [
      "Alex",
      "Sam",
      "Kim"
    ],
    "expenses": [
      {
        "payer": "Alex",
        "description": "Dinner",
        "amount": 84
      },
      {
        "payer": "Sam",
        "description": "Taxi",
        "amount": 21
      }
    ],
    "tipPercent": 10,
    "roundTransfersTo": 5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/split-bill-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"people":["Alex","Sam","Kim"],"expenses":[{"payer":"Alex","description":"Dinner","amount":84},{"payer":"Sam","description":"Taxi","amount":21}],"tipPercent":10,"roundTransfersTo":5}'

const response = await fetch("https://toolforte.com/api/v1/tools/split-bill-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "people": [
      "Alex",
      "Sam",
      "Kim"
    ],
    "expenses": [
      {
        "payer": "Alex",
        "description": "Dinner",
        "amount": 84
      },
      {
        "payer": "Sam",
        "description": "Taxi",
        "amount": 21
      }
    ],
    "tipPercent": 10,
    "roundTransfersTo": 5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/split-bill-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"people":["Alex","Sam","Kim"],"expenses":[{"payer":"Alex","description":"Dinner","amount":84},{"payer":"Sam","description":"Taxi","amount":21}],"tipPercent":10,"roundTransfersTo":5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool freelance_rate (Freelance Rate) with targetNetIncome: 45000, businessCosts: 5000, nonBillablePercent: 30, vacationWeeks: 5, hoursPerWeek: 40, bufferPercent: 10, monthlyDisabilityInsurance: 150, monthlyPensionDeposit: 250, hoursPerDay: 8.

The assistant then makes this tool call:

{
  "name": "freelance_rate",
  "arguments": {
    "targetNetIncome": 45000,
    "businessCosts": 5000,
    "nonBillablePercent": 30,
    "vacationWeeks": 5,
    "hoursPerWeek": 40,
    "bufferPercent": 10,
    "monthlyDisabilityInsurance": 150,
    "monthlyPensionDeposit": 250,
    "hoursPerDay": 8
  }
}

curl -X POST https://toolforte.com/api/v1/tools/freelance-rate-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"targetNetIncome":45000,"businessCosts":5000,"nonBillablePercent":30,"vacationWeeks":5,"hoursPerWeek":40,"bufferPercent":10,"monthlyDisabilityInsurance":150,"monthlyPensionDeposit":250,"hoursPerDay":8}'

const response = await fetch("https://toolforte.com/api/v1/tools/freelance-rate-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "targetNetIncome": 45000,
    "businessCosts": 5000,
    "nonBillablePercent": 30,
    "vacationWeeks": 5,
    "hoursPerWeek": 40,
    "bufferPercent": 10,
    "monthlyDisabilityInsurance": 150,
    "monthlyPensionDeposit": 250,
    "hoursPerDay": 8
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/freelance-rate-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"targetNetIncome":45000,"businessCosts":5000,"nonBillablePercent":30,"vacationWeeks":5,"hoursPerWeek":40,"bufferPercent":10,"monthlyDisabilityInsurance":150,"monthlyPensionDeposit":250,"hoursPerDay":8},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool meeting_cost (Meeting Cost) with attendees: 5, hourlyRate: 75, durationMinutes: 60, currency: USD.

The assistant then makes this tool call:

{
  "name": "meeting_cost",
  "arguments": {
    "attendees": 5,
    "hourlyRate": 75,
    "durationMinutes": 60,
    "currency": "USD"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/meeting-cost-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"attendees":5,"hourlyRate":75,"durationMinutes":60,"currency":"USD"}'

const response = await fetch("https://toolforte.com/api/v1/tools/meeting-cost-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "attendees": 5,
    "hourlyRate": 75,
    "durationMinutes": 60,
    "currency": "USD"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/meeting-cost-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"attendees":5,"hourlyRate":75,"durationMinutes":60,"currency":"USD"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool fuel_cost (Fuel Cost) with distance: 100, distanceUnit: km, consumption: 6.5, consumptionUnit: l100km, price: 1.95, priceUnit: liter, passengers: 1, roundTrip: false, trips: 1.

The assistant then makes this tool call:

{
  "name": "fuel_cost",
  "arguments": {
    "distance": 100,
    "distanceUnit": "km",
    "consumption": 6.5,
    "consumptionUnit": "l100km",
    "price": 1.95,
    "priceUnit": "liter",
    "passengers": 1,
    "roundTrip": false,
    "trips": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/fuel-cost-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"distance":100,"distanceUnit":"km","consumption":6.5,"consumptionUnit":"l100km","price":1.95,"priceUnit":"liter","passengers":1,"roundTrip":false,"trips":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/fuel-cost-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "distance": 100,
    "distanceUnit": "km",
    "consumption": 6.5,
    "consumptionUnit": "l100km",
    "price": 1.95,
    "priceUnit": "liter",
    "passengers": 1,
    "roundTrip": false,
    "trips": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/fuel-cost-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"distance":100,"distanceUnit":"km","consumption":6.5,"consumptionUnit":"l100km","price":1.95,"priceUnit":"liter","passengers":1,"roundTrip":false,"trips":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool appliance_energy_cost (Appliance Energy Cost) with watts: 90, pricePerKwh: 0.3, mode: daily, hoursPerDay: 4, usesPerWeek: 4, minutesPerUse: 60.

The assistant then makes this tool call:

{
  "name": "appliance_energy_cost",
  "arguments": {
    "watts": 90,
    "pricePerKwh": 0.3,
    "mode": "daily",
    "hoursPerDay": 4,
    "usesPerWeek": 4,
    "minutesPerUse": 60
  }
}

curl -X POST https://toolforte.com/api/v1/tools/appliance-energy-cost-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"watts":90,"pricePerKwh":0.3,"mode":"daily","hoursPerDay":4,"usesPerWeek":4,"minutesPerUse":60}'

const response = await fetch("https://toolforte.com/api/v1/tools/appliance-energy-cost-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "watts": 90,
    "pricePerKwh": 0.3,
    "mode": "daily",
    "hoursPerDay": 4,
    "usesPerWeek": 4,
    "minutesPerUse": 60
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/appliance-energy-cost-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"watts":90,"pricePerKwh":0.3,"mode":"daily","hoursPerDay":4,"usesPerWeek":4,"minutesPerUse":60},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool timesheet_hours (Timesheet) with days: [{"label":"Monday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Tuesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Wednesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Thursday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Friday","start":"09:00","end":"17:00","breakMinutes":30}], overtimeThresholdHours: 40, hourlyRate: 25.

The assistant then makes this tool call:

{
  "name": "timesheet_hours",
  "arguments": {
    "days": [
      {
        "label": "Monday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Tuesday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Wednesday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Thursday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Friday",
        "start": "09:00",
        "end": "17:00",
        "breakMinutes": 30
      }
    ],
    "overtimeThresholdHours": 40,
    "hourlyRate": 25
  }
}

curl -X POST https://toolforte.com/api/v1/tools/timesheet-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"days":[{"label":"Monday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Tuesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Wednesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Thursday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Friday","start":"09:00","end":"17:00","breakMinutes":30}],"overtimeThresholdHours":40,"hourlyRate":25}'

const response = await fetch("https://toolforte.com/api/v1/tools/timesheet-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "days": [
      {
        "label": "Monday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Tuesday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Wednesday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Thursday",
        "start": "09:00",
        "end": "17:30",
        "breakMinutes": 30
      },
      {
        "label": "Friday",
        "start": "09:00",
        "end": "17:00",
        "breakMinutes": 30
      }
    ],
    "overtimeThresholdHours": 40,
    "hourlyRate": 25
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/timesheet-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"days":[{"label":"Monday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Tuesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Wednesday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Thursday","start":"09:00","end":"17:30","breakMinutes":30},{"label":"Friday","start":"09:00","end":"17:00","breakMinutes":30}],"overtimeThresholdHours":40,"hourlyRate":25},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool overtime_pay (Overtime) with hourlyRate: 25, regularHours: 40, overtimeHours: 5, doubleTimeHours: 0, overtimeMultiplier: 1.5.

The assistant then makes this tool call:

{
  "name": "overtime_pay",
  "arguments": {
    "hourlyRate": 25,
    "regularHours": 40,
    "overtimeHours": 5,
    "doubleTimeHours": 0,
    "overtimeMultiplier": 1.5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/overtime-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"hourlyRate":25,"regularHours":40,"overtimeHours":5,"doubleTimeHours":0,"overtimeMultiplier":1.5}'

const response = await fetch("https://toolforte.com/api/v1/tools/overtime-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "hourlyRate": 25,
    "regularHours": 40,
    "overtimeHours": 5,
    "doubleTimeHours": 0,
    "overtimeMultiplier": 1.5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/overtime-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"hourlyRate":25,"regularHours":40,"overtimeHours":5,"doubleTimeHours":0,"overtimeMultiplier":1.5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool pto_accrual (PTO) with mode: perPeriod, accrualPerPeriod: 4.62, payFrequency: biweekly, daysPerYear: 15, hoursPerDay: 8, currentBalanceHours: 40, plannedHours: 0, targetDate: 2026-07-01, today: 2026-01-01.

The assistant then makes this tool call:

{
  "name": "pto_accrual",
  "arguments": {
    "mode": "perPeriod",
    "accrualPerPeriod": 4.62,
    "payFrequency": "biweekly",
    "daysPerYear": 15,
    "hoursPerDay": 8,
    "currentBalanceHours": 40,
    "plannedHours": 0,
    "targetDate": "2026-07-01",
    "today": "2026-01-01"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/pto-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"perPeriod","accrualPerPeriod":4.62,"payFrequency":"biweekly","daysPerYear":15,"hoursPerDay":8,"currentBalanceHours":40,"plannedHours":0,"targetDate":"2026-07-01","today":"2026-01-01"}'

const response = await fetch("https://toolforte.com/api/v1/tools/pto-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "perPeriod",
    "accrualPerPeriod": 4.62,
    "payFrequency": "biweekly",
    "daysPerYear": 15,
    "hoursPerDay": 8,
    "currentBalanceHours": 40,
    "plannedHours": 0,
    "targetDate": "2026-07-01",
    "today": "2026-01-01"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/pto-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"perPeriod","accrualPerPeriod":4.62,"payFrequency":"biweekly","daysPerYear":15,"hoursPerDay":8,"currentBalanceHours":40,"plannedHours":0,"targetDate":"2026-07-01","today":"2026-01-01"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool salary_convert (Salary) with amount: 85000, period: annual, hoursPerWeek: 40, weeksPerYear: 52.

The assistant then makes this tool call:

{
  "name": "salary_convert",
  "arguments": {
    "amount": 85000,
    "period": "annual",
    "hoursPerWeek": 40,
    "weeksPerYear": 52
  }
}

curl -X POST https://toolforte.com/api/v1/tools/salary-calculator-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":85000,"period":"annual","hoursPerWeek":40,"weeksPerYear":52}'

const response = await fetch("https://toolforte.com/api/v1/tools/salary-calculator-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 85000,
    "period": "annual",
    "hoursPerWeek": 40,
    "weeksPerYear": 52
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/salary-calculator-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":85000,"period":"annual","hoursPerWeek":40,"weeksPerYear":52},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_mortgage (Dutch Mortgage) with amount: 300000, years: 30, annualRatePercent: 4.5, type: annuiteit, deductionRatePercent: 36.97.

The assistant then makes this tool call:

{
  "name": "dutch_mortgage",
  "arguments": {
    "amount": 300000,
    "years": 30,
    "annualRatePercent": 4.5,
    "type": "annuiteit",
    "deductionRatePercent": 36.97
  }
}

curl -X POST https://toolforte.com/api/v1/tools/hypotheek-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":300000,"years":30,"annualRatePercent":4.5,"type":"annuiteit","deductionRatePercent":36.97}'

const response = await fetch("https://toolforte.com/api/v1/tools/hypotheek-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 300000,
    "years": 30,
    "annualRatePercent": 4.5,
    "type": "annuiteit",
    "deductionRatePercent": 36.97
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/hypotheek-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":300000,"years":30,"annualRatePercent":4.5,"type":"annuiteit","deductionRatePercent":36.97},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_net_salary (Dutch Salary) with amount: 45000, period: year, mode: grossToNet.

The assistant then makes this tool call:

{
  "name": "dutch_net_salary",
  "arguments": {
    "amount": 45000,
    "period": "year",
    "mode": "grossToNet"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/salaris-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":45000,"period":"year","mode":"grossToNet"}'

const response = await fetch("https://toolforte.com/api/v1/tools/salaris-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 45000,
    "period": "year",
    "mode": "grossToNet"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/salaris-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":45000,"period":"year","mode":"grossToNet"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_student_finance (Dutch Student Finance) with study: hbowo, living: away, parentalIncome: low.

The assistant then makes this tool call:

{
  "name": "dutch_student_finance",
  "arguments": {
    "study": "hbowo",
    "living": "away",
    "parentalIncome": "low"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-student-finance-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"study":"hbowo","living":"away","parentalIncome":"low"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-student-finance-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "study": "hbowo",
    "living": "away",
    "parentalIncome": "low"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-student-finance-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"study":"hbowo","living":"away","parentalIncome":"low"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_public_holidays (Dutch Public Holidays) with year: 2026.

The assistant then makes this tool call:

{
  "name": "dutch_public_holidays",
  "arguments": {
    "year": 2026
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-holidays \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"year":2026}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-holidays", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "year": 2026
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-holidays",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"year":2026},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool working_days_between (Working Days) with start: 2026-01-01, end: 2026-01-31, excludeDutchHolidays: true.

The assistant then makes this tool call:

{
  "name": "working_days_between",
  "arguments": {
    "start": "2026-01-01",
    "end": "2026-01-31",
    "excludeDutchHolidays": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/working-days \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"start":"2026-01-01","end":"2026-01-31","excludeDutchHolidays":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/working-days", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "start": "2026-01-01",
    "end": "2026-01-31",
    "excludeDutchHolidays": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/working-days",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"start":"2026-01-01","end":"2026-01-31","excludeDutchHolidays":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_timestamp (Timestamp) with value: 1725710400, unit: auto.

The assistant then makes this tool call:

{
  "name": "convert_timestamp",
  "arguments": {
    "value": 1725710400,
    "unit": "auto"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/timestamp-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":1725710400,"unit":"auto"}'

const response = await fetch("https://toolforte.com/api/v1/tools/timestamp-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 1725710400,
    "unit": "auto"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/timestamp-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":1725710400,"unit":"auto"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool date_difference (Date Difference) with startDate: 2026-01-01, endDate: 2026-12-31, includeEndDate: false.

The assistant then makes this tool call:

{
  "name": "date_difference",
  "arguments": {
    "startDate": "2026-01-01",
    "endDate": "2026-12-31",
    "includeEndDate": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/date-difference-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"startDate":"2026-01-01","endDate":"2026-12-31","includeEndDate":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/date-difference-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "startDate": "2026-01-01",
    "endDate": "2026-12-31",
    "includeEndDate": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/date-difference-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"startDate":"2026-01-01","endDate":"2026-12-31","includeEndDate":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool age (Age) with birthDate: 1990-05-15, asOf: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "age",
  "arguments": {
    "birthDate": "1990-05-15",
    "asOf": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/age-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthDate":"1990-05-15","asOf":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/age-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthDate": "1990-05-15",
    "asOf": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/age-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthDate":"1990-05-15","asOf":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool week_number (Week Number) with date: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "week_number",
  "arguments": {
    "date": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/week-number \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/week-number", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "date": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/week-number",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"date":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_timezone (Timezone) with dateTime: 2026-03-15T14:30, from: Europe/Amsterdam, to: America/New_York.

The assistant then makes this tool call:

{
  "name": "convert_timezone",
  "arguments": {
    "dateTime": "2026-03-15T14:30",
    "from": "Europe/Amsterdam",
    "to": "America/New_York"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/timezone-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dateTime":"2026-03-15T14:30","from":"Europe/Amsterdam","to":"America/New_York"}'

const response = await fetch("https://toolforte.com/api/v1/tools/timezone-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "dateTime": "2026-03-15T14:30",
    "from": "Europe/Amsterdam",
    "to": "America/New_York"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/timezone-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"dateTime":"2026-03-15T14:30","from":"Europe/Amsterdam","to":"America/New_York"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool aow_age (AOW Age) with birthDate: 1975-05-12, today: 2026-08-28.

The assistant then makes this tool call:

{
  "name": "aow_age",
  "arguments": {
    "birthDate": "1975-05-12",
    "today": "2026-08-28"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/aow-age-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthDate":"1975-05-12","today":"2026-08-28"}'

const response = await fetch("https://toolforte.com/api/v1/tools/aow-age-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthDate": "1975-05-12",
    "today": "2026-08-28"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/aow-age-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthDate":"1975-05-12","today":"2026-08-28"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_notice_period (Dutch Notice Period) with givenBy: employee, startDate: 2019-03-01, noticeDate: 2026-09-12, contractMonths: 1.

The assistant then makes this tool call:

{
  "name": "dutch_notice_period",
  "arguments": {
    "givenBy": "employee",
    "startDate": "2019-03-01",
    "noticeDate": "2026-09-12",
    "contractMonths": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-notice-period-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"givenBy":"employee","startDate":"2019-03-01","noticeDate":"2026-09-12","contractMonths":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-notice-period-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "givenBy": "employee",
    "startDate": "2019-03-01",
    "noticeDate": "2026-09-12",
    "contractMonths": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-notice-period-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"givenBy":"employee","startDate":"2019-03-01","noticeDate":"2026-09-12","contractMonths":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_school_holidays (Dutch School Holidays) with schoolYear: 2026-2027, region: midden, today: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "dutch_school_holidays",
  "arguments": {
    "schoolYear": "2026-2027",
    "region": "midden",
    "today": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-school-holidays \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"schoolYear":"2026-2027","region":"midden","today":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-school-holidays", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "schoolYear": "2026-2027",
    "region": "midden",
    "today": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-school-holidays",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"schoolYear":"2026-2027","region":"midden","today":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool date_add_subtract (Date) with amount: 90, unit: days, operation: add, startDate: 2026-03-15.

The assistant then makes this tool call:

{
  "name": "date_add_subtract",
  "arguments": {
    "amount": 90,
    "unit": "days",
    "operation": "add",
    "startDate": "2026-03-15"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/date-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":90,"unit":"days","operation":"add","startDate":"2026-03-15"}'

const response = await fetch("https://toolforte.com/api/v1/tools/date-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 90,
    "unit": "days",
    "operation": "add",
    "startDate": "2026-03-15"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/date-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":90,"unit":"days","operation":"add","startDate":"2026-03-15"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool military_time (Military Time) with time: 1:30 PM, from: auto.

The assistant then makes this tool call:

{
  "name": "military_time",
  "arguments": {
    "time": "1:30 PM",
    "from": "auto"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/military-time-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"time":"1:30 PM","from":"auto"}'

const response = await fetch("https://toolforte.com/api/v1/tools/military-time-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "time": "1:30 PM",
    "from": "auto"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/military-time-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"time":"1:30 PM","from":"auto"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool bmi (BMI) with height: 175, weight: 70, units: metric.

The assistant then makes this tool call:

{
  "name": "bmi",
  "arguments": {
    "height": 175,
    "weight": 70,
    "units": "metric"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/bmi-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"height":175,"weight":70,"units":"metric"}'

const response = await fetch("https://toolforte.com/api/v1/tools/bmi-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "height": 175,
    "weight": 70,
    "units": "metric"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/bmi-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"height":175,"weight":70,"units":"metric"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool macros (Macro) with age: 30, sex: male, heightCm: 178, weightKg: 75, activity: moderate, goal: maintain.

The assistant then makes this tool call:

{
  "name": "macros",
  "arguments": {
    "age": 30,
    "sex": "male",
    "heightCm": 178,
    "weightKg": 75,
    "activity": "moderate",
    "goal": "maintain"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/macro-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"age":30,"sex":"male","heightCm":178,"weightKg":75,"activity":"moderate","goal":"maintain"}'

const response = await fetch("https://toolforte.com/api/v1/tools/macro-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "age": 30,
    "sex": "male",
    "heightCm": 178,
    "weightKg": 75,
    "activity": "moderate",
    "goal": "maintain"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/macro-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"age":30,"sex":"male","heightCm":178,"weightKg":75,"activity":"moderate","goal":"maintain"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool sleep_times (Sleep) with time: 07:00, mode: wake.

The assistant then makes this tool call:

{
  "name": "sleep_times",
  "arguments": {
    "time": "07:00",
    "mode": "wake"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sleep-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"time":"07:00","mode":"wake"}'

const response = await fetch("https://toolforte.com/api/v1/tools/sleep-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "time": "07:00",
    "mode": "wake"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sleep-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"time":"07:00","mode":"wake"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool water_intake (Water Intake) with weightKg: 75, exerciseMinutes: 30, climate: normal.

The assistant then makes this tool call:

{
  "name": "water_intake",
  "arguments": {
    "weightKg": 75,
    "exerciseMinutes": 30,
    "climate": "normal"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/water-intake-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"weightKg":75,"exerciseMinutes":30,"climate":"normal"}'

const response = await fetch("https://toolforte.com/api/v1/tools/water-intake-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "weightKg": 75,
    "exerciseMinutes": 30,
    "climate": "normal"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/water-intake-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"weightKg":75,"exerciseMinutes":30,"climate":"normal"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool body_fat (Body Fat) with sex: male, heightCm: 178, neckCm: 38, waistCm: 85, hipCm: 95, weightKg: 80.

The assistant then makes this tool call:

{
  "name": "body_fat",
  "arguments": {
    "sex": "male",
    "heightCm": 178,
    "neckCm": 38,
    "waistCm": 85,
    "hipCm": 95,
    "weightKg": 80
  }
}

curl -X POST https://toolforte.com/api/v1/tools/body-fat-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sex":"male","heightCm":178,"neckCm":38,"waistCm":85,"hipCm":95,"weightKg":80}'

const response = await fetch("https://toolforte.com/api/v1/tools/body-fat-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sex": "male",
    "heightCm": 178,
    "neckCm": 38,
    "waistCm": 85,
    "hipCm": 95,
    "weightKg": 80
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/body-fat-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sex":"male","heightCm":178,"neckCm":38,"waistCm":85,"hipCm":95,"weightKg":80},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool bmr (BMR) with sex: male, age: 30, heightCm: 178, weightKg: 75.

The assistant then makes this tool call:

{
  "name": "bmr",
  "arguments": {
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75
  }
}

curl -X POST https://toolforte.com/api/v1/tools/bmr-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sex":"male","age":30,"heightCm":178,"weightKg":75}'

const response = await fetch("https://toolforte.com/api/v1/tools/bmr-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/bmr-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sex":"male","age":30,"heightCm":178,"weightKg":75},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool ideal_weight (Ideal Weight) with heightCm: 178, sex: male.

The assistant then makes this tool call:

{
  "name": "ideal_weight",
  "arguments": {
    "heightCm": 178,
    "sex": "male"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/ideal-weight-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"heightCm":178,"sex":"male"}'

const response = await fetch("https://toolforte.com/api/v1/tools/ideal-weight-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "heightCm": 178,
    "sex": "male"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/ideal-weight-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"heightCm":178,"sex":"male"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool daily_calories (Calorie) with sex: male, age: 30, heightCm: 178, weightKg: 75, activity: moderate.

The assistant then makes this tool call:

{
  "name": "daily_calories",
  "arguments": {
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75,
    "activity": "moderate"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/calorie-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sex":"male","age":30,"heightCm":178,"weightKg":75,"activity":"moderate"}'

const response = await fetch("https://toolforte.com/api/v1/tools/calorie-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75,
    "activity": "moderate"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/calorie-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sex":"male","age":30,"heightCm":178,"weightKg":75,"activity":"moderate"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool running_pace (Running Pace) with solve: pace, unit: km, distance: 10, time: 55:00, pace: 5:30.

The assistant then makes this tool call:

{
  "name": "running_pace",
  "arguments": {
    "solve": "pace",
    "unit": "km",
    "distance": 10,
    "time": "55:00",
    "pace": "5:30"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/running-pace-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"solve":"pace","unit":"km","distance":10,"time":"55:00","pace":"5:30"}'

const response = await fetch("https://toolforte.com/api/v1/tools/running-pace-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "solve": "pace",
    "unit": "km",
    "distance": 10,
    "time": "55:00",
    "pace": "5:30"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/running-pace-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"solve":"pace","unit":"km","distance":10,"time":"55:00","pace":"5:30"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool tdee (TDEE) with sex: male, age: 30, heightCm: 178, weightKg: 75, activityFactor: 1.55.

The assistant then makes this tool call:

{
  "name": "tdee",
  "arguments": {
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75,
    "activityFactor": 1.55
  }
}

curl -X POST https://toolforte.com/api/v1/tools/tdee-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sex":"male","age":30,"heightCm":178,"weightKg":75,"activityFactor":1.55}'

const response = await fetch("https://toolforte.com/api/v1/tools/tdee-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sex": "male",
    "age": 30,
    "heightCm": 178,
    "weightKg": 75,
    "activityFactor": 1.55
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/tdee-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sex":"male","age":30,"heightCm":178,"weightKg":75,"activityFactor":1.55},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool pregnancy_due_date (Due Date) with date: 2026-01-01, method: lmp, today: 2026-03-01.

The assistant then makes this tool call:

{
  "name": "pregnancy_due_date",
  "arguments": {
    "date": "2026-01-01",
    "method": "lmp",
    "today": "2026-03-01"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/due-date-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-01-01","method":"lmp","today":"2026-03-01"}'

const response = await fetch("https://toolforte.com/api/v1/tools/due-date-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "date": "2026-01-01",
    "method": "lmp",
    "today": "2026-03-01"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/due-date-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"date":"2026-01-01","method":"lmp","today":"2026-03-01"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool ovulation_window (Ovulation) with lastPeriod: 2026-03-01, cycleLength: 28, today: 2026-03-10.

The assistant then makes this tool call:

{
  "name": "ovulation_window",
  "arguments": {
    "lastPeriod": "2026-03-01",
    "cycleLength": 28,
    "today": "2026-03-10"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/ovulation-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lastPeriod":"2026-03-01","cycleLength":28,"today":"2026-03-10"}'

const response = await fetch("https://toolforte.com/api/v1/tools/ovulation-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "lastPeriod": "2026-03-01",
    "cycleLength": 28,
    "today": "2026-03-10"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/ovulation-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"lastPeriod":"2026-03-01","cycleLength":28,"today":"2026-03-10"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool one_rep_max (One Rep Max) with weight: 100, reps: 5.

The assistant then makes this tool call:

{
  "name": "one_rep_max",
  "arguments": {
    "weight": 100,
    "reps": 5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/one-rep-max-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"weight":100,"reps":5}'

const response = await fetch("https://toolforte.com/api/v1/tools/one-rep-max-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "weight": 100,
    "reps": 5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/one-rep-max-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"weight":100,"reps":5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dog_age (Dog Age) with age: 5, species: dog, size: medium.

The assistant then makes this tool call:

{
  "name": "dog_age",
  "arguments": {
    "age": 5,
    "species": "dog",
    "size": "medium"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dog-age-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"age":5,"species":"dog","size":"medium"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dog-age-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "age": 5,
    "species": "dog",
    "size": "medium"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dog-age-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"age":5,"species":"dog","size":"medium"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool px_to_rem (PX to REM) with value: 24, direction: px-to-rem, rootFontSize: 16.

The assistant then makes this tool call:

{
  "name": "px_to_rem",
  "arguments": {
    "value": 24,
    "direction": "px-to-rem",
    "rootFontSize": 16
  }
}

curl -X POST https://toolforte.com/api/v1/tools/px-rem-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":24,"direction":"px-to-rem","rootFontSize":16}'

const response = await fetch("https://toolforte.com/api/v1/tools/px-rem-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 24,
    "direction": "px-to-rem",
    "rootFontSize": 16
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/px-rem-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":24,"direction":"px-to-rem","rootFontSize":16},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_units (Unit) with value: 10, from: km, to: mi, category: length.

The assistant then makes this tool call:

{
  "name": "convert_units",
  "arguments": {
    "value": 10,
    "from": "km",
    "to": "mi",
    "category": "length"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/unit-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":10,"from":"km","to":"mi","category":"length"}'

const response = await fetch("https://toolforte.com/api/v1/tools/unit-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 10,
    "from": "km",
    "to": "mi",
    "category": "length"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/unit-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":10,"from":"km","to":"mi","category":"length"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool fractions (Fraction) with a: {"numerator":1,"denominator":2}, b: {"numerator":1,"denominator":3}, operation: +.

The assistant then makes this tool call:

{
  "name": "fractions",
  "arguments": {
    "a": {
      "numerator": 1,
      "denominator": 2
    },
    "b": {
      "numerator": 1,
      "denominator": 3
    },
    "operation": "+"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/fraction-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":{"numerator":1,"denominator":2},"b":{"numerator":1,"denominator":3},"operation":"+"}'

const response = await fetch("https://toolforte.com/api/v1/tools/fraction-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "a": {
      "numerator": 1,
      "denominator": 2
    },
    "b": {
      "numerator": 1,
      "denominator": 3
    },
    "operation": "+"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/fraction-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"a":{"numerator":1,"denominator":2},"b":{"numerator":1,"denominator":3},"operation":"+"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool ratio (Ratio) with mode: simplify, a: 1920, b: 1080, c: 9, d: 12, factor: 1.5.

The assistant then makes this tool call:

{
  "name": "ratio",
  "arguments": {
    "mode": "simplify",
    "a": 1920,
    "b": 1080,
    "c": 9,
    "d": 12,
    "factor": 1.5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/ratio-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"simplify","a":1920,"b":1080,"c":9,"d":12,"factor":1.5}'

const response = await fetch("https://toolforte.com/api/v1/tools/ratio-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "simplify",
    "a": 1920,
    "b": 1080,
    "c": 9,
    "d": 12,
    "factor": 1.5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/ratio-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"simplify","a":1920,"b":1080,"c":9,"d":12,"factor":1.5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool aspect_ratio (Aspect Ratio) with width: 1920, height: 1080, ratioWidth: 16, ratioHeight: 9.

The assistant then makes this tool call:

{
  "name": "aspect_ratio",
  "arguments": {
    "width": 1920,
    "height": 1080,
    "ratioWidth": 16,
    "ratioHeight": 9
  }
}

curl -X POST https://toolforte.com/api/v1/tools/aspect-ratio-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"width":1920,"height":1080,"ratioWidth":16,"ratioHeight":9}'

const response = await fetch("https://toolforte.com/api/v1/tools/aspect-ratio-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "width": 1920,
    "height": 1080,
    "ratioWidth": 16,
    "ratioHeight": 9
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/aspect-ratio-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"width":1920,"height":1080,"ratioWidth":16,"ratioHeight":9},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool gpa (GPA) with courses: [{"name":"Calculus I","grade":"A","credits":4},{"name":"English Composition","grade":"A-","credits":3},{"name":"Introduction to CS","grade":"B+","credits":3}], scale: 4.0.

The assistant then makes this tool call:

{
  "name": "gpa",
  "arguments": {
    "courses": [
      {
        "name": "Calculus I",
        "grade": "A",
        "credits": 4
      },
      {
        "name": "English Composition",
        "grade": "A-",
        "credits": 3
      },
      {
        "name": "Introduction to CS",
        "grade": "B+",
        "credits": 3
      }
    ],
    "scale": "4.0"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/gpa-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"courses":[{"name":"Calculus I","grade":"A","credits":4},{"name":"English Composition","grade":"A-","credits":3},{"name":"Introduction to CS","grade":"B+","credits":3}],"scale":"4.0"}'

const response = await fetch("https://toolforte.com/api/v1/tools/gpa-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "courses": [
      {
        "name": "Calculus I",
        "grade": "A",
        "credits": 4
      },
      {
        "name": "English Composition",
        "grade": "A-",
        "credits": 3
      },
      {
        "name": "Introduction to CS",
        "grade": "B+",
        "credits": 3
      }
    ],
    "scale": "4.0"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/gpa-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"courses":[{"name":"Calculus I","grade":"A","credits":4},{"name":"English Composition","grade":"A-","credits":3},{"name":"Introduction to CS","grade":"B+","credits":3}],"scale":"4.0"},
)
result = response.json()  # {"ok": true, "data": {...}}