Bitfab TypeScript SDK

Bitfab client for provider-based API calls.

Monorepo Setup

This package is part of a pnpm workspace monorepo. The workspace structure separates concerns:

• Root package.json: Contains only shared dev dependencies (Biome, TypeScript, Vitest, Knip)
• Package package.json: Contains runtime dependencies specific to this package
• You can run tests and validation from the root directory: pnpm test or pnpm validate
• No need to manually update shared dev tooling versions across packages

Installing Dependencies

Always install dependencies from the root directory:

# From the root directory
pnpm install

Updating pnpm

To update pnpm across the monorepo:

# From the root directory
pnpm pnpm:update

This automatically updates pnpm and syncs the version in package.json and CI/CD workflows.

Running Commands

You can run commands from this directory or from the root:

# From this directory
pnpm test
pnpm build
pnpm validate

# From the root directory (runs across all packages)
pnpm test          # Run all tests
pnpm validate      # Run lint + tsc + test

Available Development Tools

This package includes the following shared development tools:

Run individual tools:

# Run tests with coverage
pnpm test

# Lint and format code
pnpm lint

# Type check without building
pnpm tsc

# Find unused dependencies
pnpm knip

# Run all validation checks
pnpm validate

Installation

Basic Installation

npm install @bitfab/sdk
# or
pnpm add @bitfab/sdk
# or
yarn add @bitfab/sdk

Automatic subtree transform adapters are included under @bitfab/sdk/transform/*; no second package is required.

With OpenAI Agents SDK Tracing

If you want to use the OpenAI Agents SDK tracing integration:

npm install @bitfab/sdk @openai/agents
# or
pnpm add @bitfab/sdk @openai/agents

The @openai/agents package is an optional peer dependency - the SDK works fine without it unless you need tracing functionality.

Local Development

cd bitfab-typescript-sdk
pnpm build

To link for local development:

# In this directory
pnpm link --global

# In your app directory
pnpm link --global bitfab

To switch back to npm version:

pnpm unlink bitfab
pnpm add bitfab

Usage

Basic Usage (Local Execution)

By default, the SDK executes BAML functions locally on the client by fetching the BAML prompt from the server and running it with your own API keys:

import { Bitfab } from "bitfab";

const client = new Bitfab({
  apiKey: "bf_your_api_key_here", // Required: Your Bitfab API key
  serviceUrl: "https://bitfab.ai", // Optional
  envVars: {
    OPENAI_API_KEY: process.env.OPENAI_API_KEY, // Your LLM provider API keys
  },
  executeLocally: true, // Default: true
});

const result = await client.call("method_name", {
  arg1: "value1",
  arg2: "value2",
});

Server-Side Execution

If you prefer to execute BAML on the server (using the server's API keys), set executeLocally: false:

const client = new Bitfab({
  apiKey: "bf_your_api_key_here",
  executeLocally: false, // Execute on server instead of locally
});

const result = await client.call("method_name", {
  arg1: "value1",
  arg2: "value2",
});

With TypeScript Generics

You can specify the return type for type safety:

interface MyResponse {
  answer: string;
  confidence: number;
}

const result = await client.call<MyResponse>("analyze", {
  text: "Hello world",
});

console.log(result.answer); // TypeScript knows this is a string

Error Handling

import { Bitfab, BitfabError } from "bitfab";

const client = new Bitfab({
  apiKey: "bf_your_api_key_here",
  serviceUrl: "https://your-bitfab-instance.com",
});

try {
  const result = await client.call("method_name", { input: "value" });
} catch (error) {
  if (error instanceof BitfabError) {
    console.error("Bitfab error:", error.message);
    if (error.url) {
      console.error("Configure at:", error.url);
    }
  }
}

Configuration

Execution Modes

Local Execution (Default)

When executeLocally: true (default), the SDK:

1. Fetches the BAML function definition from the Bitfab server
2. Executes the BAML locally using the @boundaryml/baml runtime
3. Uses your own LLM provider API keys (passed via envVars)
4. Returns the result directly to you

Benefits:

• Full control over API keys and costs
• Lower latency (no server round-trip for execution)
• Privacy: Your data doesn't go through the Bitfab server

Requirements:

• You must provide LLM provider API keys via envVars
• The BAML runtime runs in your environment (Node.js, browser with polyfills, etc.)

Server-Side Execution

When executeLocally: false, the SDK:

1. Sends the function name and inputs to the Bitfab server
2. The server executes the BAML using its own API keys
3. Returns the result to you

Benefits:

• No need to manage LLM provider API keys
• Simpler setup
• Works in any environment

Requirements:

• The Bitfab server must have the necessary API keys configured

Environment Variables

• BITFAB_API_KEY: the API key used when apiKey is omitted or resolves empty, read at first use
• BITFAB_CAPTURE_ENABLED: the capture switch for a client that does not pass captureEnabled. 1, true, or yes captures; 0, false, or no does not. Unset captures, and captureEnabled in code always wins
• OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.: LLM provider API keys (required for local execution)
• BITFAB_OTEL_MAX_REQUEST_BYTES: request-size target for exports (positive integer up to 3000000)
• BITFAB_OTEL_EXPORT_CONCURRENCY: concurrent direct requests per export window (1-64, default 32)
• BITFAB_COMMIT_SHA: the commit recorded as commit_ref.sha on every root trace, for a container built without a deploy platform's build variables or a git checkout
• BITFAB_DISABLE_COMMIT_REF: set to send no commit_ref at all

Testing

A test script is provided to verify both local and server-side execution:

# Set up environment variables
export BITFAB_API_KEY="bf_your_api_key"
export OPENAI_API_KEY="your_openai_key"

# Run the test script
pnpm tsx test-local-execution.ts [function-name] [query]

# Example
pnpm tsx test-local-execution.ts extract-entities "What is the capital of France?"

The test script will:

1. Test local execution with your API keys
2. Test server-side execution
3. Compare results and performance

Publishing

pnpm build
npm publish --access public