LLM

import { Socket, text, type Schemas } from "@stream-io/calypso";

const model = await Socket.open(
  client.backend,
  await client.backend.socketURL("/v1/llm/stream"),
);
try {
  model.send({
    type: "start",
    config_id: "support",
    llm: { reasoning_effort: "low" } satisfies Schemas["LlmOptions"],
  });

  model.send({
    type: "respond",
    instructions: "You are a friendly support agent. Keep replies short.",
    messages: [{ role: "user", content: "Can I change my plan mid-month?" }],
  });
  for await (const answer of model.messages()) {
    if (answer instanceof Uint8Array) continue;
    if (answer.type === "error")
      throw new Error(`answering: ${text(answer, "error")}`);
    if (answer.type === "delta") process.stdout.write(text(answer, "text"));
    if (answer.type === "complete") break;
  }
} finally {
  model.close();
}

from vision_agents.core.llm.llm import LLMResponseDelta
from vision_agents.plugins import stream

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

async with router.llm.realtime(reasoning_effort="low") as model:
    model.set_instructions("You are a friendly support agent. Keep replies short.")
    async for answer in model.simple_response("Can I change my plan mid-month?"):
        if isinstance(answer, LLMResponseDelta):
            print(answer.delta, end="", flush=True)

router = api.router("support")

router.llm.realtime(reasoning_effort: "low") do |model|
  model.respond("Can I change my plan mid-month?",
                instructions: "You are a friendly support agent. Keep replies short.") do |delta|
    print delta
  end
end

use GetStream\VisionAgents\Generated\LlmOptions;

$model = $client->router('support')->llm->realtime(new LlmOptions(reasoningEffort: 'low'));
try {
    $model->respond('plan', [
        'instructions' => 'You are a friendly support agent. Keep replies short.',
        'messages' => [['role' => 'user', 'content' => 'Can I change my plan mid-month?']],
    ]);
    foreach ($model->frames() as $frame) {
        if (!is_array($frame)) {
            continue;
        }
        if ($frame['type'] === 'delta') {
            echo $frame['text'];
        }
        if ($frame['type'] === 'complete') {
            break;
        }
    }
} finally {
    $model->close();
}

effort := acceleration.LlmOptionsReasoningEffortLow
model, err := client.Router("support").LLM().Realtime(ctx, &acceleration.LlmOptions{
	ReasoningEffort: &effort,
})
if err != nil {
	return err
}
defer model.Close()

if err := model.Ask(stream.Question{
	Instructions: "You are a friendly support agent. Keep replies short.",
	Messages:     []stream.Said{{Role: "user", Content: "Can I change my plan mid-month?"}},
}); err != nil {
	return err
}
for answer := range model.Answers() {
	if answer.Error != "" {
		return fmt.Errorf("answering: %s", answer.Error)
	}
	fmt.Print(answer.Delta)
	if answer.Done {
		break
	}
}

await using var model = await client.Router("support").Llm.RealtimeAsync(new LlmOptions { ReasoningEffort = "low" });

await model.AskAsync(new Question
{
    Instructions = "You are a friendly support agent. Keep replies short.",
    Messages = [new Said("user", "Can I change my plan mid-month?")],
});
await foreach (var answer in model.ReadAllAsync())
{
    if (answer.Error != "")
    {
        throw new InvalidOperationException($"answering: {answer.Error}");
    }
    Console.Write(answer.Delta);
    if (answer.Done)
    {
        break;
    }
}

use serde_json::json;
use vision_agents::types::{LlmOptions, LlmOptionsReasoningEffort};
use vision_agents::Ask;

let mut model = client
    .router("support")
    .completions(LlmOptions {
        reasoning_effort: Some(LlmOptionsReasoningEffort::Low),
        ..Default::default()
    })
    .await?;

let ask = Ask {
    instructions: "You are a friendly support agent. Keep replies short.".into(),
    messages: vec![json!({"role": "user", "content": "Can I change my plan mid-month?"})],
    ..Default::default()
};
model.respond(&ask, |delta| print!("{delta}")).await?;
model.close().await;