import os
from meibel import MeibelClient
from meibel.models import CreateSessionRequest

client = MeibelClient(api_key=os.environ["MEIBEL_API_KEY"])

session = client.agents.sessions.create(
    agent_id="agent_123",
    body=CreateSessionRequest(),
)

print(session.session_id)

import { MeibelClient } from 'meibel';

const client = new MeibelClient({ apiKey: process.env.MEIBEL_API_KEY });

const session = await client.agents.sessions.create('agent_123');

console.log(session.sessionId);

import (
    "context"
    "fmt"
    "os"

    meibel "github.com/meibel-ai/meibel-go"
)

client := meibel.NewClient(meibel.WithAPIKey(os.Getenv("MEIBEL_API_KEY")))
ctx := context.Background()

session, err := client.Agents.CreateSession(ctx, "agent_123", nil)
if err != nil {
    log.Fatal(err)
}

fmt.Println(session.ID)
fmt.Println(session.AgentID)

meibel agents create-session agent_123

from meibel.models import ChatMessageRequest

response = client.agents.sessions.send_chat_message(
    session_id=session.session_id,
    body=ChatMessageRequest(
        user_message="What are the key findings in the Q4 report?",
    ),
)

print(response.assistant_response)
print(response.response.sources)

const response = await client.agents.sessions.sendChatMessage(session.sessionId, {
  userMessage: 'What are the key findings in the Q4 report?',
});

console.log(response.assistantResponse);
console.log(response.response.sources);

response, err := client.Sessions.SendChatMessage(ctx, session.ID, meibel.ChatMessageRequest{
    UserMessage: "What are the key findings in the Q4 report?",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(response.Message)
fmt.Println(response.Citations)

meibel sessions send-chat-message "$SESSION_ID" --data '{
  "user_message": "What are the key findings in the Q4 report?"
}'

import io

stream = client.agents.sessions.send_chat_message_stream(
    session_id=session.session_id,
    file=io.BytesIO(b""),
    file_name="empty.txt",
    user_message="Summarize the revenue trends over the last 3 quarters.",
)

shown = 0
for event in stream:
    if event.event == "partial_response":
        message = event.json()["data"]["message"]
        print(message[shown:], end="", flush=True)
        shown = len(message)
    elif event.event == "completion":
        print("\n\n[Stream complete]")

const stream = client.agents.sessions.sendChatMessageStream(
  session.sessionId,
  undefined,
  undefined,
  { userMessage: 'Summarize the revenue trends over the last 3 quarters.' },
);

let shown = 0;
for await (const event of stream) {
  const e = event as { type?: string; data?: { message?: string } };
  if (e.type === 'partial_response') {
    const message = e.data?.message ?? '';
    process.stdout.write(message.slice(shown));
    shown = message.length;
  } else if (e.type === 'completion') {
    console.log('\n\n[Stream complete]');
  }
}

stream, err := client.Sessions.SendChatMessageStream(ctx, session.ID, meibel.ChatMessageRequest{
    UserMessage: "Summarize the revenue trends over the last 3 quarters.",
})
if err != nil {
    log.Fatal(err)
}

for event := range stream.Events {
    switch e := event.(type) {
    case *meibel.ContentEvent:
        fmt.Print(e.Delta)
    case *meibel.CitationsEvent:
        fmt.Println("\n\nCitations:", e.Citations)
    case *meibel.DoneEvent:
        fmt.Println("\n\n[Stream complete]")
    }
}
if err := stream.Err(); err != nil {
    log.Fatal(err)
}

meibel sessions send-chat-message-stream "$SESSION_ID" --data '{
  "user_message": "Summarize the revenue trends over the last 3 quarters."
}'

messages = client.sessions.get_messages(session_id=session.session_id)

for msg in messages.messages:
    print(f"[{msg.type}] {msg.message}")

const messages = await client.sessions.getMessages(session.sessionId);

for (const msg of messages.messages) {
  console.log(`[${msg.type}] ${msg.message}`);
}

messages, err := client.Sessions.GetSessionMessages(ctx, session.ID)
if err != nil {
    log.Fatal(err)
}

for _, msg := range messages {
    fmt.Printf("[%s] %s\n", msg.Role, msg.Message)
}

meibel sessions get-session-messages "$SESSION_ID"

session = client.sessions.get(session_id="session_456")

print(session.agent_id)
print(session.agent_name)
print(session.status)

const session = await client.sessions.get('session_456');

console.log(session.agentId);
console.log(session.agentName);
console.log(session.status);

session, err := client.Sessions.GetSession(ctx, "session_456")
if err != nil {
    log.Fatal(err)
}

fmt.Println(session.ID)
fmt.Println(session.AgentID)
fmt.Println(session.CreatedAt)

meibel sessions get-session session_456