from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
)

messages = [
    {"role": "system", "content": "You are Kimi."},
    {"role": "user", "content": "The first question..."},
    {
        "role": "assistant",
        "reasoning_content": "<reasoning_content returned by the previous API call>",
        "content": "<content returned by the previous API call>",
    },
    {"role": "user", "content": "Please continue the deduction based on the previous analysis."},
]

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    stream=True,
    extra_body={"thinking": {"type": "enabled", "keep": "all"}},
)

for chunk in response:
    delta = chunk.choices[0].delta
    if getattr(delta, "reasoning_content", None):
        print(delta.reasoning_content, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)
print()

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://tokenhub-intl.tencentcloudmaas.com/v1',
});

const messages = [
  { role: 'system', content: 'You are Kimi.' },
  { role: 'user', content: 'The first question...' },
  {
    role: 'assistant',
    reasoning_content: '<reasoning_content returned by the previous API call>',
    content: '<content returned by the previous API call>',
  },
  { role: 'user', content: 'Please continue the deduction based on the previous analysis.' },
];

const stream = await client.chat.completions.create({
  model: 'kimi-k2.6',
  messages,
  stream: true,
  thinking: { type: 'enabled', keep: 'all' },
});

for await (const chunk of stream) {
  const delta = chunk.choices?.[0]?.delta;
  if (!delta) continue;
  if (delta.reasoning_content) process.stdout.write(delta.reasoning_content);
  if (delta.content) process.stdout.write(delta.content);
}
console.log();

import okhttp3.*;
import com.google.gson.Gson;
import java.util.*;

public class MultiTurnWithThinking {
    public static void main(String[] args) {
        Map<String, Object> body = new HashMap<>();
        body.put("model", "kimi-k2.6");
        body.put("stream", true);
        body.put("thinking", Map.of("type", "enabled", "keep", "all"));
        body.put("messages", List.of(
            Map.of("role", "system", "content", "You are Kimi."),
            Map.of("role", "user", "content", "The first question..."),
            Map.of(
                "role", "assistant",
                "reasoning_content", "<reasoning_content returned by the previous API call>",
                "content", "<content returned by the previous API call>"
            ),
            Map.of("role", "user", "content", "Please continue the deduction based on the previous analysis.")
        ));

        Request request = new Request.Builder()
            .url("https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions")
            .header("Authorization", "Bearer YOUR_API_KEY")
            .post(RequestBody.create(new Gson().toJson(body), MediaType.parse("application/json")))
            .build();

        try (Response response = new OkHttpClient().newCall(request).execute();
             java.io.BufferedReader r = new java.io.BufferedReader(
                 new java.io.InputStreamReader(response.body().byteStream()))) {
            String line;
            while ((line = r.readLine()) != null) {
                if (line.startsWith("data: ")) System.out.println(line.substring(6));
            }
        }
    }
}

package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "strings"
)

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "model":    "kimi-k2.6",
        "stream":   true,
        "thinking": map[string]string{"type": "enabled", "keep": "all"},
        "messages": []map[string]interface{}{
            {"role": "system", "content": "You are Kimi."},
            {"role": "user", "content": "The first question..."},
            {
                "role":              "assistant",
                "reasoning_content": "<reasoning_content returned by the previous API call>",
                "content": "<content returned by the previous API call>",
            },
            {"role": "user", "content": "Please continue the deduction based on the previous analysis."},
        },
    })

    req, _ := http.NewRequest("POST",
        "https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if strings.HasPrefix(line, "data: ") {
            fmt.Println(strings.TrimPrefix(line, "data: "))
        }
    }
}

import base64
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
)

with open("image.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Please describe this picture"},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}},
        ],
    }],
)
print(response.choices[0].message.content)

import fs from 'node:fs';
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://tokenhub-intl.tencentcloudmaas.com/v1',
});

const imageB64 = fs.readFileSync('image.jpg').toString('base64');

const response = await client.chat.completions.create({
  model: 'kimi-k2.6',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'Please describe this picture' },
      { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${imageB64}` } },
    ],
  }],
});
console.log(response.choices[0].message.content);

import okhttp3.*;
import com.google.gson.Gson;
import java.nio.file.*;
import java.util.*;

public class ImageBase64Chat {
    public static void main(String[] args) throws Exception {
        byte[] bytes = Files.readAllBytes(Paths.get("image.jpg"));
        String imageB64 = Base64.getEncoder().encodeToString(bytes);

        Map<String, Object> body = new HashMap<>();
        body.put("model", "kimi-k2.6");
        body.put("messages", List.of(Map.of(
            "role", "user",
            "content", List.of(
                Map.of("type", "text", "text", "Please describe this picture"),
                Map.of("type", "image_url", "image_url", Map.of(
                    "url", "data:image/jpeg;base64," + imageB64
                ))
            )
        )));

        Request request = new Request.Builder()
            .url("https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions")
            .header("Authorization", "Bearer YOUR_API_KEY")
            .post(RequestBody.create(new Gson().toJson(body), MediaType.parse("application/json")))
            .build();

        try (Response response = new OkHttpClient().newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    img, _ := os.ReadFile("image.jpg")
    imageB64 := base64.StdEncoding.EncodeToString(img)

    body, _ := json.Marshal(map[string]interface{}{
        "model": "kimi-k2.6",
        "messages": []map[string]interface{}{
            {
                "role": "user",
                "content": []map[string]interface{}{
                    {"type": "text", "text": "Please describe this picture"},
                    {
                        "type": "image_url",
                        "image_url": map[string]string{
                            "url": "data:image/jpeg;base64," + imageB64,
                        },
                    },
                },
            },
        },
    })

    req, _ := http.NewRequest("POST",
        "https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    data, _ := io.ReadAll(resp.Body)
    fmt.Println(string(data))
}

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Please describe this picture"},
            {"type": "image_url", "image_url": {"url": "https://www.gstatic.com/webp/gallery/1.jpg"}},
        ],
    }],
)
print(response.choices[0].message.content)