Tool calling and dispatch

import { Client, Tools } from "@stream-io/stream-agents";
import { z } from "zod";

const tools = new Tools()
  .register({
    name: "get_local_context",
    description: "The person's current date, local time and timezone.",
    parameters: z.object({}),
    run: () => ({
      now: new Date().toISOString(),
      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
    }),
  })
  .register({
    name: "get_location",
    description:
      "Where the person is. Only call it when the answer depends on it.",
    parameters: z.object({
      reason: z.string().describe("why you need it, in a few words"),
    }),
    displayTitle: "Checking where you are",
    approval: {
      title: "Share your location?",
      reasonArgument: "reason",
      allowTitle: "Share",
      declineTitle: "Not now",
    },
    run: () =>
      new Promise((resolve, reject) =>
        navigator.geolocation.getCurrentPosition(
          ({ coords }) =>
            resolve({ latitude: coords.latitude, longitude: coords.longitude }),
          reject,
        ),
      ),
  });

// `client` holds your apiKey and a user from setUser.
const session = await client.agent("support").sessions.create({ tools });

// A session opened before, such as after a reload, gets them back with its id.
const resumed = await client
  .agent("support")
  .sessions.resume(sessionId, { tools });

import { z } from "zod";

agent.tools.register({
  name: "book_flight",
  description: "Book a flight for the caller",
  parameters: z.object({
    flight_id: z
      .string()
      .regex(/^[A-Z]{2}\d{1,4}$/)
      .describe("e.g. LH400"),
    seats: z.number().int().min(1).max(9),
    cabin: z.enum(["economy", "business", "first"]).default("economy"),
  }),
  run: async ({ flight_id, seats, cabin }) =>
    bookings.book(flight_id, seats, cabin),
});

from typing import Literal

from pydantic import BaseModel, Field


class BookFlight(BaseModel):
    flight_id: str = Field(pattern=r"^[A-Z]{2}\d{1,4}$", description="e.g. LH400")
    seats: int = Field(ge=1, le=9)
    cabin: Literal["economy", "business", "first"] = "economy"


# A function that takes a single model gets the model's fields as the tool's
# arguments, and is handed the parsed model.
@agent.llm.register_function(description="Book a flight for the caller")
async def book_flight(booking: BookFlight) -> str:
    return await bookings.book(booking.flight_id, booking.seats, booking.cabin)

// Tags: schema (the description), enum, minimum, maximum, exclusiveMinimum,
// exclusiveMaximum, multipleOf, minLength, maxLength, minItems, maxItems,
// pattern, format, default and example. An invopop-style
// `jsonschema:"description=...,minLength=1"` tag works too.
// default is only told to the model: a field left out arrives as its zero value.
type BookFlight struct {
	FlightID string `json:"flight_id" schema:"e.g. LH400" pattern:"^[A-Z]{2}[0-9]{1,4}$"`
	Seats    int    `json:"seats" minimum:"1" maximum:"9"`
	Cabin    string `json:"cabin,omitempty" enum:"economy,business,first" default:"economy"`
}

err := tools.Register(agent.Tools(), "book_flight", "Book a flight for the caller",
	func(ctx context.Context, in BookFlight) (any, error) {
		return airline.Book(ctx, in.FlightID, in.Seats, cmp.Or(in.Cabin, "economy"))
	})

agent.tools.register({
  name: "search_flights",
  description: "Search for flights",
  parameters: SearchFlights,
  interruptible: true,
  // signal is aborted when the user talks over the agent
  run: async (args, signal) => airline.search(args, { signal }),
});

@agent.llm.register_function(description="Search for flights", interruptible=True)
async def search_flights(destination: str) -> list[Flight]:
    # the task is cancelled when the user talks over the agent
    return await airline.search(destination)

err = tools.Register(agent.Tools(), "search_flights", "Search for flights",
	func(ctx context.Context, args SearchFlights) (any, error) {
		// ctx is cancelled when the user talks over the agent
		return airline.Search(ctx, args)
	},
	tools.Interruptible(true),
)

agent.tools.register({
  name: "book_flight",
  description: "Book the flight the user picked",
  parameters: BookFlight,
  interruptible: true,
  run: async ({ flight_id }, signal, toolCallContext) => {
    const seat = await airline.holdSeat(flight_id, { signal });
    // from here on, talking over the agent doesn't abort the booking
    const held = await toolCallContext.disallowInterruptions();
    return airline.book({ flightId: flight_id, seat, signal: held });
  },
});

from vision_agents.core.llm import get_tool_call_context


@agent.llm.register_function(description="Book the flight the user picked", interruptible=True)
async def book_flight(flight_id: str) -> str:
    seat = await airline.hold_seat(flight_id)
    # from here on, talking over the agent doesn't cancel the booking
    await get_tool_call_context().disallow_interruptions()
    booking = await airline.book(flight_id=flight_id, seat=seat)
    return f"Booked. Confirmation number {booking.id}."

err = tools.Register(agent.Tools(), "book_flight", "Book the flight the user picked",
	func(ctx context.Context, args BookFlight) (any, error) {
		seat, err := airline.HoldSeat(ctx, args.FlightID)
		if err != nil {
			return nil, err
		}
		// from here on, talking over the agent doesn't cancel ctx
		ctx = tools.ToolCallContextFrom(ctx).DisallowInterruptions(ctx)
		return airline.Book(ctx, airline.BookRequest{FlightID: args.FlightID, Seat: seat})
	},
	tools.Interruptible(true),
)

agent.tools.register({
  name: "book_flight",
  description: "Book the flight the user picked",
  parameters: BookFlight,
  timeoutMs: 60_000,
  run: async ({ flight_id }, signal) =>
    airline.book({ flightId: flight_id, signal }),
});

@agent.llm.register_function(description="Book the flight the user picked", timeout=60)
async def book_flight(flight_id: str) -> str:
    return await airline.book(flight_id=flight_id)

err = tools.Register(agent.Tools(), "book_flight", "Book the flight the user picked",
	func(ctx context.Context, args BookFlight) (any, error) {
		return airline.Book(ctx, airline.BookRequest{FlightID: args.FlightID})
	},
	tools.Timeout(60*time.Second),
)

err = tools.Register(agent.Tools(), "book_flight", "Book the flight the user picked", bookFlight,
	tools.Concurrency(2),
)

agent.tools.register({
  name: "book_flight",
  description: "Book the flight the user picked",
  parameters: BookFlight,
  run: async ({ flight_id }, signal, toolCallContext) => {
    toolCallContext.update("Checking seats on the flight");
    const booking = await airline.book({ flightId: flight_id, signal });
    return `Booked. Confirmation number ${booking.id}.`;
  },
});

from vision_agents.core.llm import get_tool_call_context


@agent.llm.register_function(description="Book the flight the user picked")
async def book_flight(flight_id: str) -> str:
    await get_tool_call_context().update("Checking seats on the flight")
    booking = await airline.book(flight_id=flight_id)
    return f"Booked. Confirmation number {booking.id}."

err = tools.Register(agent.Tools(), "book_flight", "Book the flight the user picked",
	func(ctx context.Context, args BookFlight) (any, error) {
		tools.ToolCallContextFrom(ctx).Update(ctx, "Checking seats on the flight")
		booking, err := airline.Book(ctx, airline.BookRequest{FlightID: args.FlightID})
		if err != nil {
			return nil, err
		}
		return fmt.Sprintf("Booked. Confirmation number %s.", booking.ID), nil
	},
)

agent.tools.register({
  name: "book_flight",
  description: "Book the flight the user picked",
  parameters: BookFlight,
  run: async ({ flight_id }, signal, toolCallContext) => {
    const booking = await airline.book({
      flightId: flight_id,
      userId: toolCallContext.user.id,
      idempotencyKey: toolCallContext.id,
    });
    return `Booked. Confirmation number ${booking.id}.`;
  },
});

from vision_agents.core.llm import get_tool_call_context


@agent.llm.register_function(description="Book the flight the user picked")
async def book_flight(flight_id: str) -> str:
    tool_call_context = get_tool_call_context()
    booking = await airline.book(
        flight_id=flight_id,
        user_id=tool_call_context.user.id,
        idempotency_key=tool_call_context.id,
    )
    return f"Booked. Confirmation number {booking.id}."

err = tools.Register(agent.Tools(), "book_flight", "Book the flight the user picked",
	func(ctx context.Context, args BookFlight) (any, error) {
		toolCallContext := tools.ToolCallContextFrom(ctx)
		booking, err := airline.Book(ctx, airline.BookRequest{
			FlightID:       args.FlightID,
			UserID:         toolCallContext.User.ID,
			IdempotencyKey: toolCallContext.ID,
		})
		if err != nil {
			return nil, err
		}
		return fmt.Sprintf("Booked. Confirmation number %s.", booking.ID), nil
	},
)

import { ToolOutput } from "@stream-io/stream-agents";

agent.tools.register({
  name: "seat_map",
  description: "Show the seat map for a flight",
  parameters: SeatMap,
  run: async ({ flight_id }) =>
    new ToolOutput({
      text: `Seat map for ${flight_id}`,
      images: [{ url: await airline.seatMapUrl(flight_id) }],
    }),
});

from vision_agents.core.llm import ImageContent


@agent.llm.register_function(description="Show the seat map for a flight")
async def seat_map(flight_id: str) -> list[str | ImageContent]:
    png = await airline.seat_map(flight_id)
    return [f"Seat map for {flight_id}", ImageContent(data=png, mime="image/png")]

err = tools.Register(agent.Tools(), "seat_map", "Show the seat map for a flight",
	func(ctx context.Context, args SeatMap) (any, error) {
		url, err := airline.SeatMapURL(ctx, args.FlightID)
		if err != nil {
			return nil, err
		}
		return tools.Output{Text: "Seat map for " + args.FlightID, Images: []tools.Image{{URL: url}}}, nil
	},
)

import { Agent, Dispatch } from "@stream-io/stream-agents";

const dispatch = new Dispatch({ capacity: 8 });
const support = () =>
  new Agent({ name: "support", pipeline: { config: "support" } });

dispatch.onMessage(async (message) => {
  if (message.sessionId) {
    await dispatch.answer(message);
    return;
  }
  const session = await dispatch.sessionFor(message, support);
  await session.responses.create(message.text);
});

await dispatch.run();

from vision_agents.core import Agent
from vision_agents.plugins import stream

dispatch = stream.Dispatch(capacity=8)


@dispatch.wait_for_message()
async def written(message: stream.InboundMessage) -> None:
    if message.session_id:
        await dispatch.answer(message)
        return
    agent = await dispatch.get_or_create_agent(message, lambda: Agent(config="support"))
    await agent.responses.create(message.text)


await dispatch.run()

dispatch = GetStream::VisionAgents::Dispatch.new(capacity: 8)

dispatch.wait_for_message do |message|
  next dispatch.answer(message) unless message.session_id.empty?

  dispatch.get_or_create_agent(message) { GetStream::VisionAgents::Agent.new(config: "support") }
          .reply(message)
          .responses.create(message.text)
end

dispatch.run

use GetStream\VisionAgents\Agent;
use GetStream\VisionAgents\Inbound\InboundMessage;
use GetStream\VisionAgents\Worker\Dispatch;

$dispatch = new Dispatch(capacity: 8);
$support = fn (): Agent => new Agent(config: 'support');

$dispatch->waitForMessage(function (InboundMessage $message) use ($dispatch, $support): void {
    if ($message->sessionId !== '') {
        $dispatch->answer($message);
        return;
    }
    $dispatch->getOrCreateAgent($message, $support)->responses->create($message->text);
});

$dispatch->run();

dispatch, err := agents.NewDispatch(agents.DispatchOptions{Capacity: 8})
if err != nil {
	return err
}

support := func(ctx context.Context, message agents.InboundMessage) (*agents.Agent, error) {
	return agents.New(agents.Options{
		Name: "support",
		LLM:  stream.Accelerated(stream.Config{Agent: "support"}),
	})
}

dispatch.OnMessage(func(ctx context.Context, message agents.InboundMessage) error {
	if message.SessionID != "" {
		return dispatch.Answer(ctx, message)
	}
	conversation, err := dispatch.Conversation(ctx, message, support)
	if err != nil {
		return err
	}
	return conversation.Respond(message.Text)
})

return dispatch.Run(ctx)

var dispatch = new Dispatch(new DispatchOptions { Capacity = 8 });

dispatch.WaitForMessage(async message =>
{
    if (message.SessionId != "")
    {
        await dispatch.AnswerAsync(message);
        return;
    }
    var agent = await dispatch.GetOrCreateAgentAsync(message,
        () => new Agent(new AgentOptions { Config = "support" }));
    await agent.Responses.CreateAsync(message.Text);
});

await dispatch.RunAsync(cancellationToken);

use vision_agents::{Agent, Client, Dispatch, InboundMessage};

let dispatch = Dispatch::with_capacity(Client::from_env()?, 8);

let worker = dispatch.clone();
dispatch.wait_for_message(move |message: InboundMessage| {
    let dispatch = worker.clone();
    async move {
        if !message.session_id.is_empty() {
            dispatch.answer(&message).await?;
            return Ok(());
        }
        let session = dispatch
            .get_or_create_agent(&message, || async { Ok(Agent::new("support")) })
            .await?;
        session.responses.create(&message.text).await?;
        Ok(())
    }
});

dispatch.run().await

const agent = client.agent("support");
agent.tools.register({
  name: "lookup_order",
  description: "Look up an order",
  run: lookupOrder,
});
dispatch.host(agent, { toolTimeoutMs: 60_000 });

agent = stream.Client().agent("support")


@agent.register(description="Look up an order by its number")
async def lookup_order(order_id: str) -> Order:
    return await orders.find(order_id)


dispatch.host(agent, tool_timeout=60)

agent = client.agent("support")
agent.tools.register(
  "lookup_order",
  description: "Look up an order",
  parameters: {
    type: "object",
    properties: { order_id: { type: "string" } },
    required: ["order_id"],
  },
) { |args| Orders.find(args["order_id"]) }
dispatch.host(agent, tool_timeout: 60)

$agent = $client->agent('support');
$agent->tools->register('lookup_order', 'Look up an order', [
    'type' => 'object',
    'properties' => ['order_id' => ['type' => 'string']],
    'required' => ['order_id'],
], fn (array $args) => $orders->find($args['order_id']));
$dispatch->host($agent, toolTimeoutMs: 60_000);

agent := api.Agent("support")
err := tools.Register(agent.Tools(), "lookup_order", "Look up an order",
	func(ctx context.Context, args LookupOrder) (any, error) {
		return orders.Find(ctx, args.OrderID)
	})
dispatch.Host(agent, time.Minute)

var agent = client.Agent("support");
agent.Tools.Register<LookupOrder, Order>("lookup_order", "Look up an order",
    (args, cancellationToken) => orders.FindAsync(args.OrderId, cancellationToken));
dispatch.Host(agent, toolTimeout: TimeSpan.FromMinutes(1));

let agent = client.agent("support");
agent.tools.register("lookup_order", "Look up an order", lookup_order, |args| async move {
    orders::find(args["order_id"].as_str().unwrap_or_default()).await
});
dispatch.host(&agent, Some(Duration::from_secs(60)));