@beforequery/sdk - BeforeQuery

Install

npm install @beforequery/sdk

Quickstart

Browser (public key)
Node.js (client credentials)
React (streaming)

import { BeforeQuery } from "@beforequery/sdk";

const bq = new BeforeQuery({
  projectId: "proj_xxx",
  clientKey: "bq_pk_your_public_key",   // safe to ship client-side
});

const { answer, citations, threadId } = await bq.chat(
  "How do I set up authentication?",
);

import { BeforeQuery } from "@beforequery/sdk";

const bq = new BeforeQuery({
  projectId: "proj_xxx",
  clientId: "bq_ci_your_client_id",
  clientSecret: "bq_cs_your_client_secret",
});

const { answer, citations } = await bq.chat("Summarise the rate-limiting strategy");
const { results } = await bq.search("pgvector cosine", { limit: 5 });
await bq.feedback({ messageId: "msg_xxx", rating: 5, comment: "Spot on!" });

const result = await bq.chat(query, {
  threadId,                               // continue the conversation
  onToken: (t) => setAnswer((p) => p + t),
  onCitations: (c) => setCitations(c),
});
setThreadId(result.threadId);             // persist for follow-ups

React Native

Streaming fetch needs a polyfill for incremental onToken callbacks:

npm install react-native-fetch-api web-streams-polyfill

// index.js — before any SDK calls
import "web-streams-polyfill/polyfill";
import "react-native-fetch-api/polyfill";

Without the polyfill the SDK degrades gracefully: the resolved ChatResult is still correct, but tokens arrive all at once.

Transport

Default transport: "auto" uses WebSocket with automatic SSE fallback:

new BeforeQuery({ projectId, clientKey });                    // auto (default)
new BeforeQuery({ projectId, clientKey, transport: "ws" });   // WS only — throws on failure
new BeforeQuery({ projectId, clientKey, transport: "sse" });  // SSE only

One WebSocket connection is reused across sequential chat() calls and re-established if closed. A 5-second connect timeout triggers permanent SSE fallback in auto mode. React Native and Node 22+ have global WebSocket; earlier Node versions fall back to SSE automatically.

Constructor options

Option	Type	Required	Description
`projectId`	`string`	Yes	Your project ID
`clientKey`	`string`	Browser/RN	Public key (`bq_pk_...`)
`clientId`	`string`	Server	Client ID (`bq_ci_...`)
`clientSecret`	`string`	Server	Client secret (`bq_cs_...`)
`baseUrl`	`string`	No	Override API base URL (default `https://api.agents.beforequery.com`)
`transport`	`"auto" \| "ws" \| "sse"`	No	Chat transport (default `"auto"`)

`bq.chat(query, opts?)` → `Promise<ChatResult>`

Option	Type	Description
`threadId`	`string`	Continue an existing conversation
`user`	`{ email?, id? }`	End-user identity
`signal`	`AbortSignal`	Cancel the request
`onToken`	`(token: string) => void`	Streaming token callback
`onCitations`	`(citations: Citation[]) => void`	Citations callback
`groupIds`	`string[]`	Restrict retrieval to these source-group IDs

`bq.search(query, opts?)` → `Promise<SearchResponse>`

Option	Type	Description
`limit`	`number`	Max results to return
`groupIds`	`string[]`	Restrict search to these source-group IDs

`bq.feedback(payload)` → `Promise<void>`

Field	Type	Description
`messageId`	`string`	Message to rate
`rating`	`1\|2\|3\|4\|5`	Score
`comment`	`string`	Optional free-text

Error handling

import { BeforeQueryError } from "@beforequery/sdk";

try {
  await bq.chat("...");
} catch (err) {
  if (err instanceof BeforeQueryError) {
    console.error(err.status, err.message);
  }
}

Local testing

const bq = new BeforeQuery({
  projectId: "…",
  clientKey: "bq_pk_…",
  baseUrl: "http://localhost:8280",   // WS URL derived automatically: ws://localhost:8280
});

​Install

​Quickstart

​React Native

​Transport

​Constructor options

​bq.chat(query, opts?) → Promise<ChatResult>

​bq.search(query, opts?) → Promise<SearchResponse>

​bq.feedback(payload) → Promise<void>

​Error handling

​Local testing