JavaScript & TypeScript SDK

npm install rsflowhub
# yarn add rsflowhub · pnpm add rsflowhub · bun add rsflowhub
# Deno: import { RSFlowHub } from 'npm:rsflowhub'

RSFLOWHUB_API_KEY=rfh_your_api_key

import { RSFlowHub } from 'rsflowhub';
// CommonJS: const { RSFlowHub } = require('rsflowhub');

const client = new RSFlowHub();   // reads process.env.RSFLOWHUB_API_KEY

const res = await client.ai.sentimentAnalysis({
  text: 'Setup took two minutes and support answered right away.',
});

console.log(res.result.sentiment);  // "positive"
console.log(res.result);            // the whole AI output
console.log(res.requestId);         // "req_..." quote it when you contact support

// The method name is the endpoint slug in camelCase
await client.ai.translation({ text: 'Hello', target_language: 'French' });
await client.ai.piiRedaction({ text: 'Call me on 555-0100' });
await client.ai.ticketAnalyze({ ticket: 'My order never arrived' });

// An AI API released after you installed the SDK works the same way
await client.ai.brandNewEndpoint({ text: '...' });
// ...and always type-checks this way (also under noUncheckedIndexedAccess)
await client.call('ai', 'brandNewEndpoint', { text: '...' });

// A resource the SDK does not know yet
await client.resource('webhooks').list!();

// Any route: method, path, body, query, options
const usage = await client.request('GET', '/account/usage', undefined, { page: 2 });

import { openAsBlob } from 'node:fs';

// Ids in the URL come first, then the body, then per-call options
await client.knowledgeBases.ask(12, { question: 'Refund policy?' });
await client.chatbots.getConversation(3, 'conv_abc123');

// A Blob, File, Uint8Array / Buffer or ArrayBuffer makes it a file upload
await client.knowledgeBases.createDocument(12, {
  file: await openAsBlob('refund-policy.pdf'),   // Node 20+; or a File from an <input> upload
  metadata: { source: 'help-center' },           // sent as metadata[source]
});

// 1. A knowledge base for your help center
const kb = await client.knowledgeBases.create({ name: 'Help center' });
const kbId = kb.get<number>('knowledge_base.id');

// 2. Add content: a document, or a single FAQ item
await client.knowledgeBases.createDocument(kbId, { file: await openAsBlob('refund-policy.pdf') });
await client.knowledgeBases.createItem(kbId, {
  content: 'How long do refunds take?',
  answer: 'Refunds reach your card in 5 to 7 business days.',
});

// 3. Ask questions grounded in that content
const answer = await client.knowledgeBases.ask(kbId, { question: 'When will I get my money back?' });
console.log(answer.result);

// A chatbot (created in the dashboard or with client.chatbots.create({...}))
const reply = await client.chatbots.sendMessage(chatbotId, { message: 'Where is my order?' });
const conversationId = reply.data.conversation_id;

import {
  APIError, ConnectionError, InsufficientCreditsError, RateLimitError, ValidationError,
} from 'rsflowhub';

try {
  await client.ai.textSummarize({ text: article });
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(error.errors);                      // { text: ['The text field is required.'] }
  } else if (error instanceof InsufficientCreditsError) {
    console.log(error.requiredCredits, error.availableCredits);
  } else if (error instanceof RateLimitError) {
    console.log(error.retryAfter);                  // already retried maxRetries times
  } else if (error instanceof APIError) {
    console.log(error.status, error.code, error.message, error.requestId);
  } else if (error instanceof ConnectionError) {
    console.log('network problem or timeout');
  } else {
    throw error;
  }
}

const client = new RSFlowHub({
  apiKey: process.env.RSFLOWHUB_API_KEY,   // default
  baseURL: 'https://rsflowhub.com/api/v1', // or RSFLOWHUB_BASE_URL
  timeout: 60_000,                         // ms per attempt
  maxRetries: 2,                           // for 429, 502, 503, 504 and network errors
  headers: {},                             // extra headers on every request
  fetch: customFetch,                      // proxies, logging, tests
  liveSpec: true,                          // look up unknown non-AI methods in the OpenAPI document
});

// Per call: the last argument
const controller = new AbortController();
await client.ai.chat({ message: 'Hi' }, { signal: controller.signal, timeout: 10_000, maxRetries: 0 });
await client.knowledgeBases.get(12, { signal: controller.signal });

res.rateLimit;   // { limit: 60, remaining: 59, reset: null }

// app/api/moderate/route.ts  (Next.js App Router, runs on the server)
import { RSFlowHub, APIError } from 'rsflowhub';

const client = new RSFlowHub();

export async function POST(request: Request) {
  const { comment } = await request.json();

  try {
    const res = await client.ai.commentModerate({ comment });
    return Response.json(res.result);
  } catch (error) {
    if (error instanceof APIError) {
      return Response.json({ error: error.message }, { status: error.status });
    }
    throw error;
  }
}

import express from 'express';
import { RSFlowHub, APIError } from 'rsflowhub';

const app = express();
const client = new RSFlowHub();
app.use(express.json());

app.post('/api/ask', async (req, res) => {
  try {
    const answer = await client.knowledgeBases.ask(process.env.KB_ID!, { question: req.body.question });
    res.json(answer.data);
  } catch (error) {
    if (error instanceof APIError) return res.status(error.status).json({ error: error.message });
    res.status(500).json({ error: 'Something went wrong' });
  }
});

app.listen(3001);

// Cloudflare Workers / Vercel Edge: the SDK only needs fetch
import { RSFlowHub } from 'rsflowhub';

export default {
  async fetch(request: Request, env: { RSFLOWHUB_API_KEY: string }) {
    const client = new RSFlowHub({ apiKey: env.RSFLOWHUB_API_KEY });
    const { text } = (await request.json()) as { text: string };
    const res = await client.ai.spamDetection({ text });
    return Response.json(res.result);
  },
};