import { DiminuendoClient } from "@igentai/diminuendo-client"

const client = new DiminuendoClient({
  url: "ws://localhost:8080/ws",
  token: "eyJ...",
})

await client.connect()

// Request-response: returns typed result
const sessions = await client.listSessions()
const session = await client.createSession("coding-agent", "My Session")
const snapshot = await client.joinSession(session.id)

// Fire-and-forget: streaming interaction
client.runTurn(session.id, "Explain the architecture")

// Typed event handlers with unsubscribe
const unsub = client.on("text_delta", (event) => {
  process.stdout.write(event.text)
})

client.on("turn_complete", (event) => {
  console.log("Done:", event.finalText.slice(0, 100))
  unsub() // unsubscribe from text_delta
})

// Wildcard handler
client.on("*", (event) => {
  console.log(`[${event.type}]`)
})

use diminuendo_sdk::{DiminuendoClient, ClientOptions, ServerEvent, ClientMessage};

let options = ClientOptions {
    url: "ws://localhost:8080/ws".into(),
    token: "eyJ...".into(),
};

let (client, mut events) = DiminuendoClient::connect(options).await?;

// Send messages
client.send(ClientMessage::ListSessions { include_archived: None }).await?;
client.send(ClientMessage::CreateSession {
    agent_type: "coding-agent".into(),
    name: Some("My Session".into()),
}).await?;

// Receive events
while let Some(event) = events.recv().await {
    match event {
        ServerEvent::SessionList { sessions } => {
            println!("Found {} sessions", sessions.len());
        }
        ServerEvent::TextDelta { text, .. } => {
            print!("{text}");
        }
        ServerEvent::TurnComplete { final_text, .. } => {
            println!("\nDone: {}", &final_text[..100]);
        }
        ServerEvent::Error { code, message } => {
            eprintln!("[{code}] {message}");
        }
        ServerEvent::Unknown => {
            // Future event types are gracefully ignored
        }
        _ => {}
    }
}

from diminuendo_sdk import DiminuendoClient, ClientOptions, ServerEvent

client = DiminuendoClient(ClientOptions(
    url="ws://localhost:8080/ws",
    token="eyJ...",
))

await client.connect()

# Request-response methods
sessions = await client.list_sessions()
session = await client.create_session("coding-agent", "My Session")
snapshot = await client.join_session(session.id)

# Fire-and-forget
await client.run_turn(session.id, "Explain the architecture")

# Event handlers with unsubscribe
def on_delta(event: ServerEvent):
    print(event.text, end="", flush=True)

unsub = client.on("text_delta", on_delta)

def on_complete(event: ServerEvent):
    print(f"\nDone: {event.final_text[:100]}")
    unsub()

client.on("turn_complete", on_complete)

# Wildcard
client.on("*", lambda e: print(f"[{e.type}]", e.data))

import DiminuendoSDK

let client = DiminuendoClient(options: .init(
    url: "ws://localhost:8080/ws",
    token: ""
))

try await client.connect()

Task {
    for await event in await client.events {
        if case let .textDelta(_, _, text, _, _) = event {
            print(text, terminator: "")
        }
    }
}

let session = try await client.createSession(agentType: "coding-agent", name: "My Session")
let snapshot = try await client.joinSession(sessionId: session.id)
try await client.runTurn(sessionId: session.id, text: "Explain this codebase")