import { state as anthropicTools } from "rice-node-sdk/tools/anthropic";
import { execute } from "rice-node-sdk/tools/execute";
import { Client } from "rice-node-sdk";

const client = new Client();
await client.connect();

// 1. Pass tools to your LLM
const response = await anthropic.messages.create({
  model: "claude-3-opus-20240229",
  tools: anthropicTools,
  // ...
});

// 2. Execute tools invoked by the LLM
for (const toolUse of response.content.filter((c) => c.type === "tool_use")) {
  const result = await execute(toolUse.name, toolUse.input, client.state);
  console.log("Tool result:", result);
}

from rice_sdk.tools.anthropic import tools as anthropic_tools
from rice_sdk.tools.execute import execute
from rice_sdk import Client

client = Client()
client.connect()

# 1. Pass tools to your LLM
response = anthropic.messages.create(
    model="claude-3-opus-20240229",
    tools=anthropic_tools,
    # ...
)

# 2. Execute tools invoked by the LLM
for block in response.content:
    if block.type == "tool_use":
        result = execute(block.name, block.input, client.state)
        print(f"Tool result: {result}")

import { state as openaiTools } from "rice-node-sdk/tools/openai";
import { execute } from "rice-node-sdk/tools/execute";
import { Client } from "rice-node-sdk";

const client = new Client();
await client.connect();

// 1. Pass tools to OpenAI
const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [
    /* ... */
  ],
  tools: openaiTools,
});

// 2. Execute tools
const toolCalls = response.choices[0].message.tool_calls;
if (toolCalls) {
  for (const toolCall of toolCalls) {
    const args = JSON.parse(toolCall.function.arguments);
    const result = await execute(toolCall.function.name, args, client.state);
    console.log("Tool result:", result);
  }
}

from rice_sdk.tools.openai import tools as openai_tools
from rice_sdk.tools.execute import execute
from rice_sdk import Client
import json

client = Client()
client.connect()

# 1. Pass tools to OpenAI
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        # ...
    ],
    tools=openai_tools,
)

# 2. Execute tools
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    for tool_call in tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = execute(tool_call.function.name, args, client.state)
        print(f"Tool result: {result}")

import { state as googleTools } from "rice-node-sdk/tools/google";
import { execute } from "rice-node-sdk/tools/execute";
import { Client } from "rice-node-sdk";

const client = new Client();
await client.connect();

// 1. Pass tools to Gemini
const model = genAI.getGenerativeModel({
  model: "gemini-2.5-flash",
  tools: [{ functionDeclarations: googleTools }],
});

// 2. Execute tools
const chat = model.startChat();
const result = await chat.sendMessage("Remember that I like pizza.");
const call = result.response.functionCalls()?.[0];

if (call) {
  const result = await execute(call.name, call.args, client.state);
  console.log("Tool result:", result);
}

from rice_sdk.tools.google import tools as google_tools
from rice_sdk.tools.execute import execute
from rice_sdk import Client

client = Client()
client.connect()

# 1. Pass tools to Gemini
model = genai.GenerativeModel(
    model_name="gemini-1.5-flash",
    tools=[google_tools]
)

# 2. Execute tools
chat = model.start_chat()
result = chat.send_message("Remember that I like pizza.")
# (Function call handling varies by library version)