Use the Streaming Feature of the Kimi API

const OpenAI = require('openai')
 
const client = new OpenAI({
    apiKey: process.env.MOONSHOT_API_KEY, // Set the MOONSHOT_API_KEY environment variable before running this example
    baseURL: "https://api.moonshot.ai/v1",
})

async function main() {
    const stream = await client.chat.completions.create({
        model: "kimi-k3",
        messages: [
            {role: "system", content: "You are Kimi, an artificial intelligence assistant provided by Moonshot AI, who is better at conversing in Chinese and English. You provide users with safe, helpful, and accurate answers. At the same time, you refuse to answer any questions related to terrorism, racism, pornography, and violence. Moonshot AI is a proper noun and should not be translated into other languages."},
            {role: "user", content: "Hello, my name is Li Lei, what is 1+1?"}
        ],
        stream: true, // <-- Note here, we enable streaming output mode by setting stream=True
    })
     
    // When streaming output mode is enabled (stream=True), the content returned by the SDK also changes. We no longer directly access the choice in the return value
    // Instead, we access each individual chunk in the return value through a for loop
     
    for await (chunk of stream) {
        // Here, the structure of each chunk is similar to the previous completion, but the message field is replaced with the delta field
        delta = chunk.choices[0].delta // <-- The message field is replaced with the delta field
     
        if (delta.content) {
            // When printing the content, since it is streaming output, to ensure the coherence of the sentence, we do not add
            // line breaks manually, so we set end="" to cancel the line break of print.
            console.log(delta.content, end="")
        }
    }
}

main()

const axios = require('axios');
const OpenAI = require('openai');
 
client = new OpenAI({
    apiKey: process.env.MOONSHOT_API_KEY,
    baseURL: "https://api.moonshot.ai/v1",
})
 
 
async function estimate_token_count(input_messages) {
    /*
    Implement your token calculation logic here, or directly call our token calculation interface to compute tokens.
 
    https://api.moonshot.ai/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.ai/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: "You are Kimi, an AI assistant provided by Moonshot AI, who excels in Chinese and English conversations. You provide users with safe, helpful, and accurate answers while rejecting any questions related to terrorism, racism, or explicit content. Moonshot AI is a proper noun and should not be translated."},
            {role: "user", content: "Hello, my name is Li Lei. What is 1+1?"}
        ],
        stream: true, // <-- Note here, we enable streaming output mode by setting 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'); // Use the axios library to make HTTP requests

let data = {
    "model": "kimi-k3",
    "messages": [
        // Specific messages
    ],
    "stream": true,
};

// Use axios to send a chat request to the Kimi large language model and get the response r
axios.post("https://api.moonshot.ai/v1/chat/completions", data, {
    responseType: 'stream'
}).then(response => {
    let data = '';
    response.data.on('data', chunk => {
        // Remove leading and trailing spaces from each line to better handle data chunks
        let line = chunk.toString().trim();

        // Next, we need to handle three different cases:
        //   1. If the current line is empty, it indicates that the previous data chunk has been received (as mentioned earlier, the data chunk transmission ends with two newline characters), we can deserialize the data chunk and print the corresponding content;
        //   2. If the current line is not empty and starts with data:, it indicates the start of a data chunk transmission, we remove the data: prefix and first check if it is the end symbol [DONE], if not, save the data content to the data variable;
        //   3. If the current line is not empty but does not start with data:, it indicates that the current line still belongs to the previous data chunk being transmitted, we append the content of the current line to the end of the data variable;

        if (line === '') {
            try {
                let chunk = JSON.parse(data);
                // The processing logic here can be replaced with your business logic, printing is just to demonstrate the process
                let choice = chunk.choices[0];
                let usage = choice.usage;
                if (usage) {
                    console.log("total_tokens:", usage.total_tokens);
                }
                let delta = choice.delta;
                let role = delta.role;
                if (role) {
                    console.log("role:", role);
                }
                let content = delta.content;
                if (content) {
                    console.log(content);
                }
            } catch (error) {
                console.error("Error parsing JSON:", error);
            }
            data = ''; // Reset data
        } else if (line.startsWith('data: ')) {
            data = line.substring(6);
            // When the data chunk content is [DONE], it indicates that all data chunks have been sent, and the network connection can be disconnected
            if (data === '[DONE]') {
                response.data.destroy();
            }
        } else {
            data += '\n' + line; // We still add a newline character when appending content, as this data chunk may intentionally format the data in separate lines
        }
    });
}).catch(error => {
    console.error("Error in request:", error);
});