from signalwire_agents import AgentBase
from signalwire_agents.core.function_result import SwaigFunctionResult

class SupportAgent(AgentBase):
    def __init__(self):
        super().__init__(name="Support Agent", route="/support")
        self.prompt_add_section("Instructions",
            body="You are a customer support agent. "
                 "Greet the caller and resolve their issue.")
        self.add_language("English", "en-US", "rime.spore:mistv2")

    @AgentBase.tool(name="check_order")
    def check_order(self, order_id: str):
        """Check the status of a customer order.

        Args:
            order_id: The order ID to look up
        """
        return SwaigFunctionResult(f"Order {order_id}: shipped, ETA April 2nd")

agent = SupportAgent()
agent.run()

import { AgentBase, FunctionResult } from '@signalwire/sdk';

const agent = new AgentBase({
  name: 'Support Agent',
  route: '/support',
});

agent.promptAddSection('Instructions',
  'You are a customer support agent. Greet the caller and resolve their issue.');

agent.addLanguage({ name: 'English', code: 'en-US', voice: 'rime.spore:mistv2' });

agent.defineTool({
  name: 'check_order',
  description: 'Check the status of a customer order',
  parameters: {
    type: 'object',
    properties: {
      order_id: { type: 'string', description: 'The order ID to look up' },
    },
    required: ['order_id'],
  },
  handler: (args) => {
    return new FunctionResult(`Order ${args.order_id}: shipped, ETA April 2nd`);
  },
});

agent.run();

package main

import (
	"fmt"

	"github.com/signalwire/signalwire-go/pkg/agent"
	"github.com/signalwire/signalwire-go/pkg/swaig"
)

func main() {
	a := agent.NewAgentBase(
		agent.WithName("Support Agent"),
		agent.WithRoute("/support"),
	)

	a.PromptAddSection("Instructions",
		"You are a customer support agent. Greet the caller and resolve their issue.")

	a.AddLanguage(map[string]any{
		"name": "English", "code": "en-US", "voice": "rime.spore:mistv2",
	})

	a.DefineTool(agent.ToolDefinition{
		Name:        "check_order",
		Description: "Check the status of a customer order",
		Parameters: map[string]any{
			"type": "object",
			"properties": map[string]any{
				"order_id": map[string]any{
					"type": "string", "description": "The order ID to look up",
				},
			},
			"required": []string{"order_id"},
		},
		Handler: func(args map[string]any, rawData map[string]any) *swaig.FunctionResult {
			orderID := args["order_id"]
			return swaig.NewFunctionResult(
				fmt.Sprintf("Order %v: shipped, ETA April 2nd", orderID),
			)
		},
	})

	a.Run()
}

import com.signalwire.sdk.agent.AgentBase;
import com.signalwire.sdk.swaig.FunctionResult;

import java.util.List;
import java.util.Map;

public class SupportAgent {
    public static void main(String[] args) throws Exception {
        var agent = AgentBase.builder()
                .name("Support Agent")
                .route("/support")
                .build();

        agent.promptAddSection("Instructions",
                "You are a customer support agent. "
              + "Greet the caller and resolve their issue.");

        agent.addLanguage("English", "en-US", "rime.spore:mistv2");

        agent.defineTool(
                "check_order",
                "Check the status of a customer order",
                Map.of("type", "object",
                       "properties", Map.of(
                           "order_id", Map.of(
                               "type", "string",
                               "description", "The order ID to look up")),
                       "required", List.of("order_id")),
                (toolArgs, rawData) -> {
                    var orderId = toolArgs.get("order_id");
                    return new FunctionResult(
                        "Order " + orderId + ": shipped, ETA April 2nd");
                }
        );

        agent.run();
    }
}

# frozen_string_literal: true

require 'signalwire'

agent = SignalWire::AgentBase.new(name: 'Support Agent', route: '/support')

agent.prompt_add_section('Instructions',
  'You are a customer support agent. Greet the caller and resolve their issue.')

agent.add_language(name: 'English', code: 'en-US', voice: 'rime.spore:mistv2')

agent.define_tool(
  name:        'check_order',
  description: 'Check the status of a customer order',
  parameters:  {
    'order_id' => { 'type' => 'string', 'description' => 'The order ID to look up' }
  }
) do |args, _raw|
  SignalWire::Swaig::FunctionResult.new(
    "Order #{args['order_id']}: shipped, ETA April 2nd"
  )
end

agent.run

<?php
require 'vendor/autoload.php';

use SignalWire\Agent\AgentBase;
use SignalWire\SWAIG\FunctionResult;

$agent = new AgentBase(['name' => 'Support Agent', 'route' => '/support']);

$agent->promptAddSection('Instructions',
    'You are a customer support agent. Greet the caller and resolve their issue.');

$agent->addLanguage('English', 'en-US', 'rime.spore:mistv2');

$agent->defineTool(
    name: 'check_order',
    description: 'Check the status of a customer order',
    parameters: [
        'order_id' => ['type' => 'string', 'description' => 'The order ID to look up'],
    ],
    handler: function (array $args): FunctionResult {
        return new FunctionResult("Order {$args['order_id']}: shipped, ETA April 2nd");
    }
);

$agent->run();

#!/usr/bin/env perl
use strict;
use warnings;
use lib 'lib';
use SignalWire::Agent::AgentBase;
use SignalWire::SWAIG::FunctionResult;

my $agent = SignalWire::Agent::AgentBase->new(
    name  => 'Support Agent',
    route => '/support',
);

$agent->prompt_add_section('Instructions',
    'You are a customer support agent. Greet the caller and resolve their issue.');

$agent->add_language(name => 'English', code => 'en-US', voice => 'rime.spore:mistv2');

$agent->define_tool(
    name        => 'check_order',
    description => 'Check the status of a customer order',
    parameters  => {
        order_id => { type => 'string', description => 'The order ID to look up' },
    },
    handler => sub {
        my ($args, $raw) = @_;
        return SignalWire::SWAIG::FunctionResult->new(
            response => "Order $args->{order_id}: shipped, ETA April 2nd"
        );
    },
);

$agent->run;

#include <signalwire/agent/agent_base.hpp>

using namespace signalwire;
using json = nlohmann::json;

class SupportAgent : public agent::AgentBase {
public:
    SupportAgent() : AgentBase("Support Agent", "/support") {
        prompt_add_section("Instructions",
            "You are a customer support agent. "
            "Greet the caller and resolve their issue.");

        add_language({"English", "en-US", "rime.spore:mistv2"});

        define_tool({
            .name = "check_order",
            .description = "Check the status of a customer order",
            .parameters = {
                {"order_id", {{"type", "string"},
                              {"description", "The order ID to look up"}}}
            },
            .handler = [](const json& args, const json&) {
                auto order_id = args.value("order_id", "unknown");
                return swaig::FunctionResult(
                    "Order " + order_id + ": shipped, ETA April 2nd");
            }
        });
    }
};

int main() {
    SupportAgent().run();
}

using SignalWire.Agent;
using SignalWire.SWAIG;

var agent = new AgentBase(new AgentOptions { Name = "Support Agent", Route = "/support" });

agent.PromptAddSection("Instructions",
    "You are a customer support agent. Greet the caller and resolve their issue.");

agent.AddLanguage("English", "en-US", "rime.spore:mistv2");

agent.DefineTool("check_order", "Check the status of a customer order",
    new { type = "object", properties = new {
        order_id = new { type = "string", description = "The order ID to look up" }
    }, required = new[] { "order_id" } },
    (args, rawData) =>
    {
        var orderId = args.TryGetValue("order_id", out var id) ? id : "unknown";
        return new FunctionResult($"Order {orderId}: shipped, ETA April 2nd");
    });

agent.Run();

use signalwire::agent::AgentBase;
use signalwire::swaig::FunctionResult;
use serde_json::json;

fn main() {
    let mut agent = AgentBase::builder()
        .name("Support Agent")
        .route("/support")
        .build();

    agent
        .prompt_add_section("Instructions",
            "You are a customer support agent. Greet the caller and resolve their issue.", &[])
        .add_language("English", "en-US", "rime.spore:mistv2");

    agent.define_tool(
        "check_order",
        "Check the status of a customer order",
        json!({"type": "object", "properties": {
            "order_id": {"type": "string", "description": "The order ID to look up"}
        }, "required": ["order_id"]}),
        Box::new(|args, _raw| {
            let order_id = args.get("order_id").and_then(|v| v.as_str()).unwrap_or("unknown");
            FunctionResult::with_response(&format!("Order {order_id}: shipped, ETA April 2nd"))
        }),
    );

    agent.run();
}