Chat Completions

const chat = await client.generateText({
  model: "openai/gpt-6-astra",
  messages: [
    { role: "system", content: "You are helpful." },
    { role: "user", content: "Write a limerick about lighthouses." },
  ],
});

console.log(chat.choices[0].message.content);

chat = client.generate_text({
    "model": "openai/gpt-6-astra",
    "messages": [
        {"role": "system", "content": "You are helpful."},
        {"role": "user", "content": "Write a limerick about lighthouses."},
    ],
})

print(chat["choices"][0]["message"]["content"])

import (
  "context"
  "fmt"

  phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"
)

client, err := phaseo.NewFromEnv()
if err != nil {
  panic(err)
}

resp, err := client.GenerateText(context.Background(), phaseo.ChatCompletionsRequest{
  Model: "openai/gpt-6-astra",
  Messages: []map[string]interface{}{
    {"role": "user", "content": "Write a one-line haiku."},
  },
})
if err != nil {
  panic(err)
}
fmt.Println(resp["choices"])

using PhaseoSdk;

var client = new Phaseo();

var response = await client.GenerateText(new Dictionary<string, object>
{
    ["model"] = "openai/gpt-6-astra",
    ["messages"] = new[]
    {
        new Dictionary<string, object>
        {
            ["role"] = "user",
            ["content"] = "Write a limerick about lighthouses.",
        },
    },
});

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

use Phaseo\Sdk\Phaseo;

$client = new Phaseo();

$response = $client->createChatCompletion([
    'model' => 'openai/gpt-6-astra',
    'messages' => [[
        'role' => 'user',
        'content' => 'Write a limerick about lighthouses.',
    ]],
]);

echo $response['choices'][0]['message']['content'];

require 'phaseo_sdk'

client = PhaseoSdk::Phaseo.new

response = client.create_chat_completion(
  model: 'openai/gpt-6-astra',
  messages: [{ role: 'user', content: 'Write a limerick about lighthouses.' }]
)

import app.phaseo.sdk.Phaseo;
import java.util.List;
import java.util.Map;

Phaseo client = new Phaseo(System.getenv("PHASEO_API_KEY"));

var response = client.createChatCompletion(Map.of(
    "model", "openai/gpt-6-astra",
    "messages", List.of(
        Map.of("role", "user", "content", "Write a one-line haiku.")
    )
));
System.out.println(response.path("choices").path(0).path("message").path("content").asText());

use phaseo::Phaseo;
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Phaseo::from_env()?;
    let response = client.chat_completions(&json!({
        "model": "openai/gpt-6-astra",
        "messages": [
            {
                "role": "system",
                "content": "Answer concisely."
            },
            {
                "role": "user",
                "content": "What is provider fallback?"
            }
        ]
    }))?;

    let text = response
        .body
        .pointer("/choices/0/message/content")
        .and_then(|value| value.as_str())
        .unwrap_or("");

    println!("{text}");
    Ok(())
}

for await (const chunk of client.streamChat({
  model: "openai/gpt-6-astra",
  messages: [{ role: "user", content: "Stream a story" }],
})) {
  if (chunk.text) process.stdout.write(chunk.text);
}

for chunk in client.stream_chat({
    "model": "openai/gpt-6-astra",
    "messages": [{"role": "user", "content": "Stream a story"}],
}):
    if chunk.get("text"):
        print(chunk["text"], end="", flush=True)

import app.phaseo.sdk.Phaseo;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.Map;

Phaseo client = new Phaseo(System.getenv("PHASEO_API_KEY"));
var payload = Map.of(
    "model", "openai/gpt-6-astra",
    "messages", List.of(Map.of("role", "user", "content", "Hello")),
    "stream", true
);
try (var lines = client.rawClient().requestLines(
    "POST", "/chat/completions", null, null,
    new ObjectMapper().writeValueAsString(payload)
)) {
    lines.forEach(System.out::println);
}