@openbeam/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,497 @@
+//#region src/errors.ts
+var OpenBeamError = class extends Error {
+	status;
+	code;
+	constructor(message, status, code) {
+		super(message);
+		this.name = "OpenBeamError";
+		this.status = status;
+		this.code = code;
+	}
+};
+var AuthenticationError = class extends OpenBeamError {
+	constructor(message = "Invalid or missing API key") {
+		super(message, 401, "authentication_error");
+		this.name = "AuthenticationError";
+	}
+};
+var PermissionError = class extends OpenBeamError {
+	constructor(message = "Insufficient permissions") {
+		super(message, 403, "permission_error");
+		this.name = "PermissionError";
+	}
+};
+var NotFoundError = class extends OpenBeamError {
+	constructor(message = "Resource not found") {
+		super(message, 404, "not_found");
+		this.name = "NotFoundError";
+	}
+};
+var RateLimitError = class extends OpenBeamError {
+	retryAfter;
+	constructor(message = "Rate limit exceeded", retryAfter = null) {
+		super(message, 429, "rate_limit_error");
+		this.name = "RateLimitError";
+		this.retryAfter = retryAfter;
+	}
+};
+var ServerError = class extends OpenBeamError {
+	constructor(message = "Internal server error") {
+		super(message, 500, "server_error");
+		this.name = "ServerError";
+	}
+};
+var ToolError = class extends OpenBeamError {
+	constructor(message) {
+		super(message, 422, "tool_error");
+		this.name = "ToolError";
+	}
+};
+
+//#endregion
+//#region src/client.ts
+const DEFAULT_BASE_URL = "https://api.openbeam.work";
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_STATUS_CODES = new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const INITIAL_RETRY_DELAY = 500;
+const TRAILING_SLASHES = /\/+$/;
+var HttpClient = class {
+	apiKey;
+	baseUrl;
+	timeout;
+	maxRetries;
+	requestId = 0;
+	constructor(config) {
+		if (!config.apiKey) throw new AuthenticationError("apiKey is required");
+		this.apiKey = config.apiKey;
+		this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(TRAILING_SLASHES, "");
+		this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+		this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+	}
+	async callTool(toolName, args, options) {
+		const body = {
+			jsonrpc: "2.0",
+			id: this.nextId(),
+			method: "tools/call",
+			params: {
+				name: toolName,
+				arguments: args
+			}
+		};
+		const response = await this.fetchWithRetry(`${this.baseUrl}/mcp`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json, text/event-stream",
+				Authorization: `Bearer ${this.apiKey}`
+			},
+			body: JSON.stringify(body),
+			signal: this.buildSignal(options)
+		}, 0);
+		await this.handleHttpError(response);
+		const json = await response.json();
+		if (json.error) throw new OpenBeamError(json.error.message, json.error.code, "mcp_error");
+		if (json.result?.isError) throw new ToolError(json.result.content[0]?.text ?? "Tool execution failed");
+		return json.result?.structuredContent ?? json.result;
+	}
+	nextId() {
+		this.requestId += 1;
+		return this.requestId;
+	}
+	buildSignal(options) {
+		const timeout = options?.timeout ?? this.timeout;
+		const signals = [AbortSignal.timeout(timeout)];
+		if (options?.signal) signals.push(options.signal);
+		return AbortSignal.any(signals);
+	}
+	async fetchWithRetry(url, init, attempt) {
+		try {
+			const response = await fetch(url, init);
+			if (RETRY_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+				await sleep(this.retryDelay(attempt, response));
+				return this.fetchWithRetry(url, init, attempt + 1);
+			}
+			return response;
+		} catch (error) {
+			if (attempt < this.maxRetries && isRetryableError(error)) {
+				await sleep(INITIAL_RETRY_DELAY * 2 ** attempt);
+				return this.fetchWithRetry(url, init, attempt + 1);
+			}
+			throw error;
+		}
+	}
+	retryDelay(attempt, response) {
+		const retryAfter = response.headers.get("Retry-After");
+		if (retryAfter) {
+			const seconds = Number.parseInt(retryAfter, 10);
+			if (!Number.isNaN(seconds)) return seconds * 1e3;
+		}
+		return INITIAL_RETRY_DELAY * 2 ** attempt;
+	}
+	async handleHttpError(response) {
+		if (response.ok) return;
+		let message;
+		try {
+			const body = await response.json();
+			message = body.error_description ?? body.error ?? response.statusText;
+		} catch {
+			message = response.statusText;
+		}
+		switch (response.status) {
+			case 401: throw new AuthenticationError(message);
+			case 403: throw new PermissionError(message);
+			case 404: throw new NotFoundError(message);
+			case 429: {
+				const retryAfter = response.headers.get("Retry-After");
+				const seconds = retryAfter ? Number.parseInt(retryAfter, 10) : null;
+				throw new RateLimitError(message, Number.isNaN(seconds) ? null : seconds);
+			}
+			default:
+				if (response.status >= 500) throw new ServerError(message);
+				throw new OpenBeamError(message, response.status, "api_error");
+		}
+	}
+};
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function isRetryableError(error) {
+	if (error instanceof Error) return error.name === "TypeError" || error.message.includes("fetch failed") || error.message.includes("ECONNRESET");
+	return false;
+}
+
+//#endregion
+//#region src/resources/actions.ts
+var ActionsResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async list(options) {
+		return await this.client.callTool("connector_actions_list", {
+			connectorType: options?.connectorType,
+			category: options?.category
+		}, options);
+	}
+	async execute(connectorId, actionId, params, options) {
+		return await this.client.callTool("connector_action_execute", {
+			connectorId,
+			actionId,
+			params
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/resources/agents.ts
+var AgentsResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async list(options) {
+		return await this.client.callTool("agent_list", { category: options?.category }, options);
+	}
+	async run(agentName, input, options) {
+		return await this.client.callTool("agent_run", {
+			agentName,
+			input,
+			maxSources: options?.maxSources
+		}, options);
+	}
+	async ask(question, options) {
+		return await this.client.callTool("ask_question", {
+			question,
+			connectorTypes: options?.connectorTypes,
+			maxSources: options?.maxSources
+		}, options);
+	}
+	async contextSearch(query, options) {
+		return await this.client.callTool("context_search", {
+			query,
+			contextType: options?.contextType,
+			category: options?.category,
+			limit: options?.limit
+		}, options);
+	}
+	async contextRead(uri, options) {
+		return await this.client.callTool("context_read", {
+			uri,
+			level: options?.level
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/resources/apikeys.ts
+var ApiKeysResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async list(options) {
+		return (await this.client.callTool("apikey_list", {}, options)).keys ?? [];
+	}
+	async create(name, scopes, options) {
+		return await this.client.callTool("apikey_create", {
+			name,
+			...scopes ? { scopes } : {}
+		}, options);
+	}
+	async revoke(apiKeyId, options) {
+		return await this.client.callTool("apikey_revoke", { apiKeyId }, options);
+	}
+};
+
+//#endregion
+//#region src/resources/connectors.ts
+var ConnectorsResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async list(options) {
+		return await this.client.callTool("connector_list", {
+			status: options?.status,
+			type: options?.type,
+			cursor: options?.cursor,
+			pageSize: options?.pageSize
+		}, options);
+	}
+	async get(id, options) {
+		return await this.client.callTool("connector_get", { id }, options);
+	}
+	async health(id, options) {
+		return await this.client.callTool("connector_health", { id }, options);
+	}
+	async available(options) {
+		return await this.client.callTool("connector_available", {
+			authType: options?.authType,
+			category: options?.category
+		}, options);
+	}
+	async disconnect(connectorId, options) {
+		return await this.client.callTool("connector_disconnect", { connectorId }, options);
+	}
+};
+
+//#endregion
+//#region src/resources/knowledge.ts
+var KnowledgeResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async searchEntities(query, options) {
+		return await this.client.callTool("entity_search", {
+			query,
+			type: options?.type,
+			limit: options?.limit
+		}, options);
+	}
+	async getEntity(entityId, options) {
+		return await this.client.callTool("entity_get", { entityId }, options);
+	}
+	async getRelations(entityId, opts) {
+		return await this.client.callTool("entity_relations", {
+			entityId,
+			direction: opts?.direction,
+			relationType: opts?.relationType,
+			limit: opts?.limit
+		}, opts);
+	}
+	async topicExperts(topicId, options) {
+		return await this.client.callTool("topic_experts", {
+			topicId,
+			limit: options?.limit
+		}, options);
+	}
+	async personExpertise(personId, options) {
+		return await this.client.callTool("person_expertise", {
+			personId,
+			limit: options?.limit
+		}, options);
+	}
+	async topics(options) {
+		return await this.client.callTool("topic_list", {
+			parentId: options?.parentId,
+			limit: options?.limit
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/resources/search.ts
+var SearchResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async documents(query, options) {
+		return await this.client.callTool("search_documents", {
+			query,
+			limit: options?.limit,
+			cursor: options?.cursor,
+			connectorTypes: options?.connectorTypes,
+			documentTypes: options?.documentTypes,
+			authorIds: options?.authorIds,
+			ranking: options?.ranking,
+			dateFrom: options?.dateFrom,
+			dateTo: options?.dateTo
+		}, options);
+	}
+	async people(query, options) {
+		return await this.client.callTool("search_people", {
+			query,
+			limit: options?.limit,
+			connectorTypes: options?.connectorTypes
+		}, options);
+	}
+	async recent(options) {
+		return await this.client.callTool("search_recent", {
+			hours: options?.hours,
+			connectorTypes: options?.connectorTypes,
+			limit: options?.limit
+		}, options);
+	}
+	async semantic(query, options) {
+		return await this.client.callTool("search_semantic", {
+			query,
+			limit: options?.limit,
+			connectorTypes: options?.connectorTypes
+		}, options);
+	}
+	async similar(documentId, options) {
+		return await this.client.callTool("search_similar", {
+			documentId,
+			limit: options?.limit
+		}, options);
+	}
+	async byAuthor(authorId, options) {
+		return await this.client.callTool("search_by_author", {
+			authorId,
+			query: options?.query,
+			limit: options?.limit
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/resources/sync.ts
+var SyncResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async trigger(connectorId, type = "incremental", options) {
+		return await this.client.callTool("sync_trigger", {
+			connectorId,
+			type
+		}, options);
+	}
+	async triggerAll(options) {
+		return await this.client.callTool("sync_trigger_all", {
+			type: options?.type,
+			connectorTypes: options?.connectorTypes
+		}, options);
+	}
+	async status(connectorId, options) {
+		return await this.client.callTool("sync_status", { connectorId }, options);
+	}
+	async history(connectorId, options) {
+		return await this.client.callTool("sync_history", {
+			connectorId,
+			limit: options?.limit,
+			offset: options?.offset
+		}, options);
+	}
+	async progress(connectorId, options) {
+		return await this.client.callTool("sync_progress", { connectorId }, options);
+	}
+	async health(options) {
+		return await this.client.callTool("sync_health", {}, options);
+	}
+	async errors(options) {
+		return await this.client.callTool("sync_errors", {
+			connectorId: options?.connectorId,
+			limit: options?.limit
+		}, options);
+	}
+	async cancel(connectorId, options) {
+		return await this.client.callTool("sync_cancel", { connectorId }, options);
+	}
+	async pause(connectorId, options) {
+		return await this.client.callTool("sync_pause", { connectorId }, options);
+	}
+	async resume(connectorId, options) {
+		return await this.client.callTool("sync_resume", { connectorId }, options);
+	}
+};
+
+//#endregion
+//#region src/resources/team.ts
+var TeamResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	async info(options) {
+		return await this.client.callTool("team_info", {}, options);
+	}
+	async members(options) {
+		return await this.client.callTool("team_members", {}, options);
+	}
+	async inviteMember(email, role = "MEMBER", options) {
+		return await this.client.callTool("team_invite_member", {
+			email,
+			role
+		}, options);
+	}
+	async removeMember(userId, options) {
+		return await this.client.callTool("team_remove_member", { userId }, options);
+	}
+	async updateRole(userId, role, options) {
+		return await this.client.callTool("team_update_role", {
+			userId,
+			role
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+var OpenBeam = class {
+	search;
+	connectors;
+	sync;
+	actions;
+	team;
+	knowledge;
+	agents;
+	apiKeys;
+	constructor(config) {
+		const client = new HttpClient(config);
+		this.search = new SearchResource(client);
+		this.connectors = new ConnectorsResource(client);
+		this.sync = new SyncResource(client);
+		this.actions = new ActionsResource(client);
+		this.team = new TeamResource(client);
+		this.knowledge = new KnowledgeResource(client);
+		this.agents = new AgentsResource(client);
+		this.apiKeys = new ApiKeysResource(client);
+	}
+};
+var src_default = OpenBeam;
+
+//#endregion
+export { AuthenticationError, NotFoundError, OpenBeam, OpenBeamError, PermissionError, RateLimitError, ServerError, ToolError, src_default as default };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@openbeam/sdk",
+  "version": "0.1.0",
+  "description": "OpenBeam TypeScript SDK — enterprise search, knowledge graph, and AI agents across 103+ connectors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "openbeam",
+    "enterprise-search",
+    "knowledge-graph",
+    "ai-agents",
+    "rag",
+    "mcp",
+    "connectors",
+    "sdk",
+    "typescript"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicholasgriffintn/openbeam.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://openbeam.work",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false
+}