# Streaming with automatic tracing
stream = client.chat_stream(
    model="command-r-plus",
    messages=[
        {"role": "user", "content": "Write a poem about AI"}
    ]
)

for event in stream:
    if event.type == "content-delta":
        print(event.delta.message.content.text, end="", flush=True)

// Streaming with automatic tracing
const stream = await client.chatStream({
  model: 'command-r-plus',
  messages: [
    { role: 'user', content: 'Write a poem about AI' }
  ]
});

for await (const event of stream) {
  if (event.type === 'content-delta') {
    process.stdout.write(event.delta?.message?.content?.text || '');
  }
}

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat(
    model="command-r-plus",
    messages=[
        {"role": "user", "content": "What's the weather in Paris?"}
    ],
    tools=tools
)

# Tool calls are captured in traces
if response.message.tool_calls:
    for tool_call in response.message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Args: {tool_call.function.arguments}")

const tools = [
  {
    type: 'function',
    function: {
      name: 'get_weather',
      description: 'Get weather for a location',
      parameters: {
        type: 'object',
        properties: {
          location: {
            type: 'string',
            description: 'City name'
          }
        },
        required: ['location']
      }
    }
  }
];

const response = await client.chat({
  model: 'command-r-plus',
  messages: [
    { role: 'user', content: "What's the weather in Paris?" }
  ],
  tools
});

// Tool calls are captured in traces
if (response.message.toolCalls) {
  response.message.toolCalls.forEach(toolCall => {
    console.log('Tool:', toolCall.function.name);
    console.log('Args:', toolCall.function.arguments);
  });
}

response = client.embed(
    model="embed-english-v3.0",
    texts=["Hello world", "Goodbye world"],
    input_type="search_document"
)

for i, embedding in enumerate(response.embeddings):
    print(f"Text {i}: {len(embedding)} dimensions")

# Traces include:
# - Input text count
# - Model used
# - Embedding dimensions
# - Billed units

const response = await client.embed({
  model: 'embed-english-v3.0',
  texts: ['Hello world', 'Goodbye world'],
  inputType: 'search_document'
});

response.embeddings.forEach((embedding, i) => {
  console.log(`Text ${i}: ${embedding.length} dimensions`);
});

documents = [
    "Python is a programming language",
    "Paris is the capital of France",
    "Machine learning is a subset of AI"
]

response = client.rerank(
    model="rerank-english-v3.0",
    query="What is Python?",
    documents=documents,
    top_n=2
)

for result in response.results:
    print(f"Index: {result.index}, Score: {result.relevance_score}")
    print(f"Document: {documents[result.index]}")

# Traces include:
# - Query text
# - Document count
# - Rerank scores
# - Search units billed

const documents = [
  'Python is a programming language',
  'Paris is the capital of France',
  'Machine learning is a subset of AI'
];

const response = await client.rerank({
  model: 'rerank-english-v3.0',
  query: 'What is Python?',
  documents,
  topN: 2
});

response.results.forEach(result => {
  console.log(`Index: ${result.index}, Score: ${result.relevanceScore}`);
  console.log(`Document: ${documents[result.index]}`);
});

documents = [
    {"title": "Python", "text": "Python is a programming language..."},
    {"title": "AI", "text": "Artificial Intelligence is..."}
]

response = client.chat(
    model="command-r-plus",
    messages=[
        {"role": "user", "content": "What is Python?"}
    ],
    documents=documents
)

# RAG traces include:
# - Documents provided
# - Citations in response
# - Source references
print(response.message.content[0].text)

if response.message.citations:
    for citation in response.message.citations:
        print(f"Citation: {citation}")

const documents = [
  { title: 'Python', text: 'Python is a programming language...' },
  { title: 'AI', text: 'Artificial Intelligence is...' }
];

const response = await client.chat({
  model: 'command-r-plus',
  messages: [
    { role: 'user', content: 'What is Python?' }
  ],
  documents
});

console.log(response.message.content[0].text);

if (response.message.citations) {
  response.message.citations.forEach(citation => {
    console.log('Citation:', citation);
  });
}