使用 Kimi API 的流式输出功能

const OpenAI = require('openai')

const client = new OpenAI({
    apiKey: process.env.MOONSHOT_API_KEY, // 运行前请设置 MOONSHOT_API_KEY 环境变量
    baseURL: "https://api.moonshot.cn/v1",
})

async function main() {
    const stream = await client.chat.completions.create({
        model: "kimi-k3",
        messages: [
            {role: "system", content: "你是 Kimi，由 Moonshot AI 提供的人工智能助手，你更擅长中文和英文的对话。你会为用户提供安全，有帮助，准确的回答。同时，你会拒绝一切涉及恐怖主义，种族歧视，黄色暴力等问题的回答。Moonshot AI 为专有名词，不可翻译成其他语言。"},
            {role: "user", content: "你好，我叫李雷，1+1等于多少？"}
        ],
        stream: true, // <-- 注意这里，我们通过设置 stream=True 开启流式输出模式
        stream_options: {include_usage: true}, // <-- 请求最后的 usage 数据块
    })

    // 当启用流式输出模式（stream=True），SDK 返回的内容也发生了变化，我们不再直接访问返回值中的 choice
    // 而是通过 for 循环逐个访问返回值中每个单独的块（chunk）

    let usage;
    for await (const chunk of stream) {
        const chunkUsage = chunk.usage ?? chunk.choices[0]?.usage;
        if (chunkUsage) usage = chunkUsage;
        if (chunk.choices.length === 0) continue;
        // 在这里，每个 chunk 的结构都与之前的 completion 相似，但 message 字段被替换成了 delta 字段
        const delta = chunk.choices[0].delta // <-- message 字段被替换成了 delta 字段

        if (delta.content) {
            // 我们在打印内容时，由于是流式输出，为了保证句子的连贯性，我们不人为地添加
            // 换行符，因此使用 process.stdout.write 连续写入内容。
            process.stdout.write(delta.content)
        }
    }

    if (usage) console.log("\ntotal_tokens:", usage.total_tokens);
}

main()

const axios = require('axios');
const OpenAI = require('openai');

client = new OpenAI({
    apiKey: process.env.MOONSHOT_API_KEY,
    baseURL: "https://api.moonshot.cn/v1",
})


async function estimate_token_count(input_messages) {
    /*
    在这里实现你的 Tokens 计算逻辑，或是直接调用我们的 Tokens 计算接口计算 Tokens

    https://api.moonshot.cn/v1/tokenizers/estimate-token-count
    */
    header = {
        "Authorization": `Bearer ${process.env.MOONSHOT_API_KEY}`,
    }
    data = {
        "model": "kimi-k3",
        "messages": input_messages,
    }
    r = await axios.post("https://api.moonshot.cn/v1/tokenizers/estimate-token-count", data, {headers: header})
    .catch(function (error) {
        console.log(error)
    })
    return r.data.data.total_tokens
}

async function main() {

    const stream = await client.chat.completions.create({
        model: "kimi-k3",
        messages: [
            {role: "system", content: "你是 Kimi，由 Moonshot AI 提供的人工智能助手，你更擅长中文和英文的对话。你会为用户提供安全，有帮助，准确的回答。同时，你会拒绝一切涉及恐怖主义，种族歧视，黄色暴力等问题的回答。Moonshot AI 为专有名词，不可翻译成其他语言。"},
            {role: "user", content: "你好，我叫李雷，1+1等于多少？"}
        ],
        stream: true, // <-- 注意这里，我们通过设置 stream=True 开启流式输出模式
    })

    const completion = [];
    for await (chunk of stream) {
        const delta = chunk.choices[0].delta
        if (delta.content) {
            completion.push(delta.content)
        }
    }

    console.log("completion_tokens:", await estimate_token_count(completion.join("")))
}

main()

const axios = require('axios'); // 使用 axios 库来执行 HTTP 请求

const requestData = {
    "model": "kimi-k3",
    "messages": [
        // 具体的 messages
    ],
    "stream": true,
    "stream_options": {"include_usage": true},
};

// 使用 axios 向 Kimi 大模型发出 chat 请求，并获得响应 r
axios.post("https://api.moonshot.cn/v1/chat/completions", requestData, {
    headers: {
        "Authorization": `Bearer ${process.env.MOONSHOT_API_KEY}`,
    },
    responseType: 'stream',
}).then(response => {
    let buffer = '';
    let usage;
    response.data.on('data', rawChunk => {
        buffer += rawChunk.toString();
        const events = buffer.split(/\r?\n\r?\n/);
        buffer = events.pop() ?? '';

        for (const event of events) {
            const dataLines = event
                .split(/\r?\n/)
                .filter(line => line.startsWith('data: '))
                .map(line => line.slice(6));
            if (dataLines.length === 0) continue;

            const payload = dataLines.join('\n');
            if (payload === '[DONE]') {
                if (usage) console.log("\ntotal_tokens:", usage.total_tokens);
                response.data.destroy();
                return;
            }

            try {
                const chunk = JSON.parse(payload);
                const choices = chunk.choices || [];
                const chunkUsage = chunk.usage ?? choices[0]?.usage;
                if (chunkUsage) usage = chunkUsage;
                if (choices.length === 0) {
                    continue;
                }
                const choice = choices[0];
                const delta = choice.delta;
                const role = delta.role;
                if (role) {
                    console.log("role:", role);
                }
                const content = delta.content;
                if (content) {
                    process.stdout.write(content);
                }
            } catch (error) {
                console.error("Error parsing JSON:", error);
            }
        }
    });
}).catch(error => {
    console.error("Error in request:", error);
});