Thanks for the work EveripediaNetwork! For anyone who needs this really well working script but as nodejs. Maybe you can open a repo for nodejs as well EveripediaNetwork?
//grokit.js
const { EventEmitter } = require('events');
const GrokModels = Object.freeze({
GROK_2: 'grok-2',
GROK_2_MINI: 'grok-2-mini',
});
class Grokit {
static BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
/**
* Initializes the Grokit instance.
* @param {Object} options
* @param {string} options.auth_token - Authentication token.
* @param {string} options.csrf_token - CSRF token.
*/
constructor({ auth_token = process.env.X_AUTH_TOKEN, csrf_token = process.env.X_CSRF_TOKEN } = {}) {
this.auth_token = auth_token;
this.csrf_token = csrf_token;
this._validateTokens();
this.cookie = this._createCookie();
this.headers = this._createHeaders();
}
_validateTokens() {
if (!this.auth_token || !this.csrf_token) {
throw new Error('X_AUTH_TOKEN and X_CSRF_TOKEN must be provided');
}
}
_createCookie() {
return `auth_token=${this.auth_token}; ct0=${this.csrf_token};`;
}
_createHeaders() {
return {
'X-Csrf-Token': this.csrf_token,
'Authorization': `Bearer ${Grokit.BEARER_TOKEN}`,
'Content-Type': 'application/json',
'Cookie': this.cookie,
};
}
async createConversation() {
const url = 'https://x.com/i/api/graphql/UBIjqHqsA5aixuibXTBheQ/CreateGrokConversation';
const payload = {
variables: {},
queryId: 'UBIjqHqsA5aixuibXTBheQ',
};
const response = await this._makeRequest(url, payload);
if (response && response.data && response.data.create_grok_conversation) {
return response.data.create_grok_conversation.conversation_id;
}
return null;
}
/**
* Generates a response based on the input message.
* @param {string} message - The input message.
* @param {Object} options
* @param {string} [options.conversation_id] - Existing conversation ID.
* @param {string} [options.system_prompt_name] - System prompt name.
* @param {string} [options.model_id] - Model ID.
* @returns {Promise<string>} - The generated response.
*/
async generate(message, { conversation_id = null, system_prompt_name = '', model_id = GrokModels.GROK_2_MINI } = {}) {
const convoId = await this._ensureConversationId(conversation_id);
const response = await this._streamResponse(convoId, message, system_prompt_name, model_id);
return response.join('');
}
/**
* Streams the response based on the input message.
* @param {string} message - The input message.
* @param {Object} options
* @param {string} [options.conversation_id] - Existing conversation ID.
* @param {string} [options.system_prompt_name] - System prompt name.
* @param {string} [options.model_id] - Model ID.
* @returns {EventEmitter} - An event emitter that emits 'data' and 'error' events.
*/
async stream(message, { conversation_id = null, system_prompt_name = '', model_id = GrokModels.GROK_2_MINI } = {}) {
const emitter = new EventEmitter();
try {
const convoId = await this._ensureConversationId(conversation_id);
this._streamResponse(convoId, message, system_prompt_name, model_id, emitter);
} catch (error) {
emitter.emit('error', error);
}
return emitter;
}
/**
* Generates an image based on the prompt.
* @param {string} prompt - The image prompt.
* @returns {Promise<Buffer>} - The image data.
*/
async image(prompt) {
const imageUrl = await this.image_url(prompt);
const imageResponse = await fetch(imageUrl);
if (imageResponse.ok) {
return await imageResponse.arrayBuffer().then(buffer => Buffer.from(buffer));
}
throw new Error('Failed to download the image');
}
/**
* Retrieves the image URL based on the prompt.
* @param {string} prompt - The image prompt.
* @returns {Promise<string>} - The image URL.
*/
async image_url(prompt) {
const conversation_id = await this.createConversation();
if (!conversation_id) {
throw new Error('Failed to create conversation');
}
const imagePrompt = `Generate an image of "${prompt}"`;
const response = await this._streamResponse(conversation_id, imagePrompt, '', GrokModels.GROK_2_MINI);
for (const chunk of response) {
try {
const data = JSON.parse(chunk);
if (data.result && data.result.imageAttachment && data.result.imageAttachment.imageUrl) {
return data.result.imageAttachment.imageUrl;
}
} catch (e) {
continue;
}
}
throw new Error('Failed to generate the image');
}
async _ensureConversationId(conversation_id) {
if (!conversation_id) {
conversation_id = await this.createConversation();
if (!conversation_id) {
throw new Error('Failed to create conversation');
}
}
return conversation_id;
}
async _streamResponse(conversation_id, message, system_prompt_name, model_id, emitter = null) {
const url = 'https://api.x.com/2/grok/add_response.json';
const payload = this._createAddResponsePayload(conversation_id, message, system_prompt_name, model_id);
try {
const response = await fetch(url, {
method: 'POST',
headers: this.headers,
body: JSON.stringify(payload),
});
if (!response.ok) {
const errorText = await response.text();
if (emitter) {
emitter.emit('error', new Error(`Error adding response: ${errorText}`));
} else {
console.error(`Error adding response: ${errorText}`);
}
return [];
}
const reader = response.body.getReader();
const decoder = new TextDecoder('utf-8');
let doneReading = false;
const result = [];
while (!doneReading) {
const { value, done } = await reader.read();
if (done) {
doneReading = true;
break;
}
const chunk = decoder.decode(value, { stream: true });
const lines = chunk.split('\n').filter(line => line.trim() !== '');
for (const line of lines) {
try {
const parsed = JSON.parse(line);
if (parsed.result) {
if (parsed.result.message) {
result.push(parsed.result.message);
if (emitter) emitter.emit('data', parsed.result.message);
} else if (parsed.result.imageAttachment) {
const jsonString = JSON.stringify(parsed);
result.push(jsonString);
if (emitter) emitter.emit('data', jsonString);
}
}
} catch (e) {
continue;
}
}
}
return result;
} catch (error) {
if (emitter) {
emitter.emit('error', error);
} else {
console.error(`Error adding response: ${error.message}`);
}
return [];
}
}
async _makeRequest(url, payload) {
try {
const response = await fetch(url, {
method: 'POST',
headers: this.headers,
body: JSON.stringify(payload),
});
if (response.ok) {
return await response.json();
} else {
const errorText = await response.text();
console.error(`Error making request: ${errorText}`);
return null;
}
} catch (error) {
console.error(`Request failed: ${error.message}`);
return null;
}
}
_createAddResponsePayload(conversation_id, message, system_prompt_name, model_id) {
return {
responses: [
{
message: message,
sender: 1,
},
],
systemPromptName: system_prompt_name,
grokModelOptionId: typeof model_id === 'object' ? model_id.value : model_id,
conversationId: conversation_id,
};
}
}
module.exports = { Grokit, GrokModels };// app.js
const { Grokit, GrokModels } = require('./grokit');
// Extract tokens from cookies
const auth_token = "***";
const csrf_token = "***";
(async () => {
try {
// Initialize Grokit instance
const grok = new Grokit({
auth_token: auth_token,
csrf_token: csrf_token,
});
// Test with a sample question
const response = await grok.generate('Who are you?, { model_id: GrokModels.GROK_2_MINI });
console.log('Generated Response:', response);
} catch (error) {
console.error('Error:', error);
}
})();
Thanks for the work EveripediaNetwork! For anyone who needs this really well working script but as nodejs. Maybe you can open a repo for nodejs as well EveripediaNetwork?