JavaScript SDK

import { Sazabi } from "@sazabi/sdk";

const client = new Sazabi({
  secretKey: process.env.SAZABI_SECRET_KEY,
});

// List threads
const threads = await client.threads.list();
console.log(threads);

// Create a thread and send a message
const thread = await client.threads.create({
  title: "Investigating API latency",
});

const message = await client.messages.create(thread.id, {
  content: "Show me p99 latency for the last hour",
});
console.log(message);

const client = new Sazabi({
  // Required: Your secret API key
  secretKey: process.env.SAZABI_SECRET_KEY,

  // Optional: Override the base URL (for testing or self-hosted)
  baseUrl: "https://api.sazabi.com",

  // Optional: Request timeout in milliseconds
  timeout: 30000,

  // Optional: Custom fetch implementation
  fetch: customFetch,
});

// List all threads
const threads = await client.threads.list();

// With pagination
const threads = await client.threads.list({
  limit: 20,
  cursor: "eyJpZCI6InRocl9hYmMxMjMifQ",
});

// Filter by status
const archivedThreads = await client.threads.list({
  status: "archived",
});

const thread = await client.threads.get("thr_abc123");
console.log(thread.title);
console.log(thread.createdAt);

const thread = await client.threads.create({
  title: "Production errors investigation",
});

const updated = await client.threads.update("thr_abc123", {
  title: "Resolved: Production errors",
});

await client.threads.archive("thr_abc123");

// Send to existing thread
const message = await client.messages.create("thr_abc123", {
  content: "What errors are happening in production?",
});

// Create thread and send message in one call
const { thread, message } = await client.messages.send({
  content: "What errors are happening in production?",
});

const messages = await client.messages.list("thr_abc123", {
  limit: 50,
});

// Send message and wait for response
const message = await client.messages.create("thr_abc123", {
  content: "Analyze the error patterns",
});

// Poll for completion
const response = await client.runs.waitForCompletion(message.runId, {
  timeout: 60000, // 60 seconds
  pollInterval: 2000, // Check every 2 seconds
});

console.log(response.content);

// Single log
await client.logs.send({
  message: "User signed in",
  level: "info",
  service: "auth-service",
  attributes: {
    userId: "usr_123",
  },
});

// Batch logs
await client.logs.sendBatch([
  { message: "Request started", level: "info" },
  { message: "Request completed", level: "info" },
]);

import { Sazabi, SazabiError, RateLimitError, AuthenticationError } from "@sazabi/sdk";

try {
  const thread = await client.threads.get("thr_invalid");
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Invalid API key");
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limited. Retry after ${error.retryAfter} seconds`);
  } else if (error instanceof SazabiError) {
    console.error(`API error: ${error.code} - ${error.message}`);
  } else {
    throw error;
  }
}

import type { Thread, Message, LogEntry } from "@sazabi/sdk";

// All responses are fully typed
const thread: Thread = await client.threads.get("thr_abc123");

// Type inference works with async/await
const messages = await client.messages.list(thread.id);
// messages is typed as Message[]

// Cloudflare Worker
export default {
  async fetch(request: Request, env: Env) {
    const client = new Sazabi({
      secretKey: env.SAZABI_SECRET_KEY,
    });

    const threads = await client.threads.list();
    return Response.json(threads);
  },
};