TypeScript SDK

npm install @coherenceos/sdk

import { CoherenceClient } from '@coherenceos/sdk';
 
const coherence = new CoherenceClient({ apiKey: process.env.COHERENCE_API_KEY! });
 
// Who am I? (identity + scopes — a good key health check)
const me = await coherence.me();
 
// List records, with pagination preserved
const { records, total } = await coherence.records.list('contacts', { pageSize: 50 });
 
// Create a record — resolves to the record itself
const contact = await coherence.records.create('contacts', {
  displayName: 'Jane Doe',
  fields: { email: '[email protected]', status: 'active' },
});
 
// Cross-module semantic + keyword search
const hits = await coherence.search({ query: 'acme', limit: 10 });

const result = await coherence.agents.message({
  message: 'How many open deals do we have over $50k, and who owns them?',
});
 
console.log(result.response); // final answer
console.log(result.toolCalls, result.durationMs);

let answer = '';
 
for await (const event of coherence.agents.stream({ message: 'Summarize my pipeline' })) {
  switch (event.type) {
    case 'open':
      // Stream established. event.agentId is the resolved agent, or null for the default.
      break;
    case 'token':
      answer += event.text; // concatenate token chunks for the full answer
      process.stdout.write(event.text);
      break;
    case 'tool_call':
      console.error(`\n[${event.label}]`); // e.g. "Searching records"
      break;
    case 'done':
      // Terminal success — same shape as the synchronous response.
      console.error(`\n(${event.toolCalls} tools, ${event.durationMs}ms)`);
      break;
    case 'error':
      throw new Error(event.message); // terminal failure
  }
}

import { CoherenceClient, CoherenceError } from '@coherenceos/sdk';
 
try {
  await coherence.records.get('contacts', 'missing-id');
} catch (err) {
  if (err instanceof CoherenceError) {
    switch (err.code) {
      case 'not_found':
        console.error('No such record');
        break;
      case 'validation_error':
        console.error(err.issues); // one entry per failed field
        break;
      case 'rate_limit_exceeded':
        console.error(`Retry after ${err.retryAfter}s`);
        break;
      default:
        console.error(err.code, err.statusCode, err.message);
    }
  }
}

async function withRetry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
  for (let i = 0; ; i++) {
    try {
      return await fn();
    } catch (err) {
      if (!(err instanceof CoherenceError) || !err.isRetryable || i >= attempts - 1) throw err;
      const waitMs = err.retryAfter ? err.retryAfter * 1000 : 2 ** i * 1000;
      await new Promise((r) => setTimeout(r, waitMs));
    }
  }
}
 
const contacts = await withRetry(() => coherence.records.list('contacts'));

new CoherenceClient({
  apiKey: 'sk_live_...',
  baseUrl: 'https://api.getcoherence.io/v1', // default
  timeoutMs: 60_000,                         // per-request; 0 disables. Streams are exempt.
  fetch: customFetch,                        // optional custom fetch
});

const controller = new AbortController();
setTimeout(() => controller.abort(), 5_000);
 
const records = await coherence.records.list('contacts', { pageSize: 100 }, controller.signal);