TypeScript SDK

npm install @flowra/sdk
# or: pnpm add @flowra/sdk

pnpm --dir typescript install
pnpm --dir typescript build

import { Flowra } from '@flowra/sdk';

const flowra = new Flowra({
  apiKey: process.env.FLOWRA_API_KEY!,
  // baseUrl: 'https://flowra.dev',
  // username: 'customer_alice',
  // throwOnError: true,
});

const alice = flowra.asUser('customer_alice');
await alice.connections.list();
await alice.knowledge.list();

const profile = await flowra.getProfile();

const tools = await flowra.tools.list({
  limit: 10,
  toolkitSlug: 'slack',
  q: 'send message',
});

const tool = await flowra.tools.get(tools.items?.[0]?.id ?? 'TOOL_ID');

const slug = tools.data?.[0]?.slug ?? tools.items?.[0]?.slug ?? 'SLACK_SEND_MESSAGE';
const result = await flowra.tools.execute(slug, {
  arguments: {
    channel: '#general',
    text: 'Hello from @flowra/sdk',
  },
  // connectedAccountId: '...',
});

const logs = await flowra.tools.executionLogs({ limit: 20 });

const kits = await flowra.toolkits.listWithTools({ q: 'slack', limit: 5 });
const channels = await flowra.toolkits.messagingChannels();
const categories = await flowra.toolkits.listCategories();

const list = await flowra.workflows.list({ limit: 10, q: 'support' });
const workflowId = list.items?.[0]?.id ?? 'WORKFLOW_ID';

const run = await flowra.workflows.run(workflowId, {
  input: { message: 'Summarize open tickets' },
});

const threadId = run.threadId as string;

// Poll until completed, failed, or paused
let status = await flowra.workflows.status(threadId);
while (status.status === 'running') {
  await new Promise((r) => setTimeout(r, 1500));
  status = await flowra.workflows.status(threadId);
}

if (status.status === 'paused') {
  await flowra.workflows.resume(threadId, {
    resumeValue: { approved: true },
  });
}

const detail = await flowra.workflows.execution(run.executionId);
const stats = await flowra.workflows.statistics(workflowId);

const configs = await flowra.authConfigs.list({ toolkitSlug: 'slack' });
const authConfigId = configs.items?.[0]?.id ?? 'AUTH_CONFIG_ID';

const link = await flowra.connections.createLink({
  toolkitSlug: 'slack',
  authConfigId,
});
// Open link.url (or equivalent) in a browser for OAuth

const accounts = await flowra.connections.list();
const grouped = await flowra.connections.listGrouped();

const alice = flowra.asUser('customer_alice');
await alice.connections.createLink({ toolkitSlug: 'slack', authConfigId });

await flowra.users.create({ username: 'customer_alice' });
const user = await flowra.users.getByUsername('customer_alice');

await flowra.triggers.list();
await flowra.triggers.upsert('SOME_TRIGGER_SLUG', {
  // UpsertTriggerInstanceDto fields
});
const logs = await flowra.triggers.invocationLogs({ limit: 10 });

const thread = await flowra.chat.createThread({
  metadata: { ticketId: 'T-100' },
});
const threadId = thread.thread_id as string;

await flowra.chat.stream(threadId, {
  input: {
    messages: [{ role: 'user', content: 'What can you help with?' }],
  },
});

const history = await flowra.chat.history(threadId, {});
const state = await flowra.chat.state(threadId);
const runs = await flowra.chat.listRuns(threadId);

const skills = await flowra.skills.list();
await flowra.skills.registrySearch({ q: 'pdf' });
await flowra.skills.addToLibrary(skillId);

const servers = await flowra.mcp.list();
const server = await flowra.mcp.create({
  // CreateMcpServerDto
});
const installConfig = await flowra.mcp.config(server.id);

const alice = flowra.asUser('customer_alice');

const collection = await alice.knowledge.create({ name: 'Help center' });
await alice.knowledge.ingestUrl(collection.id, {
  url: 'https://docs.yoursite.com/faq',
});
const collections = await alice.knowledge.list();
const collectionId = collections[0]?.id ?? collection.id;
await alice.knowledge.search(collectionId, { query: 'refund policy' });
await alice.knowledge.chunks(collectionId, { limit: 20 });

const tables = await alice.database.list();
const tableId = tables[0]?.id ?? 'TABLE_ID';
await alice.database.documents(tableId, { limit: 50 });
await alice.database.createDocument(tableId, {
  // document fields
});

const files = await flowra.files.list({ limit: 20 });
// Upload uses multipart; pass the body shape expected by the generated client
await flowra.files.upload('document', formDataBody as never);
const bytes = await flowra.files.download(fileId);
const storage = await flowra.files.storageBreakdown();

const preview = await flowra.sandbox.runEphemeral({
  language: 'javascript',
  source: 'return { ok: true, n: 1 + 1 };',
  timeoutMs: 8000,
});

const session = await flowra.sandbox.createSession({});
await flowra.sandbox.execute(session.id, {
  language: 'python',
  source: 'print(2 + 2)',
});
await flowra.sandbox.releaseSession(session.id);

await flowra.browser.status(sessionId);
await flowra.browser.touch(sessionId);
await flowra.browser.view(sessionId, { /* query */ });
await flowra.browser.close(sessionId);

const models = await flowra.llm.models();
const chat = await flowra.llm.chat({
  messages: [{ role: 'user', content: 'Say hello in one sentence.' }],
});
const text = await flowra.llm.generate({
  // GenerateDto
});

const balance = await flowra.usage.balance();
const ledger = await flowra.usage.list({
  threadId,
  from: '2026-08-01T00:00:00.000Z',
});
const runUsage = await flowra.usage.forExecution(executionId);

const res = await flowra.raw.toolsControllerGetTools({
  client: flowra.client,
  query: { limit: 5 },
});

try {
  await flowra.getProfile();
} catch (err) {
  console.error(err);
}