TypeScript SDK

import {OutCallerAI} from "@outcallerai/sdk";

const client = new OutCallerAI({
	apiKey: process.env.OUTCALLERAI_API_KEY!,
});

const workspace = await client.workspace.getWorkspace();
console.log(workspace.name);

const client = new OutCallerAI({
	apiKey: process.env.OUTCALLERAI_API_KEY!,
	baseUrl: "https://api.outcallerai.com",
	timeoutMs: 60_000,
	maxRetries: 3,
	onResponse: ({method, path, status, requestId, durationMs}) => {
		console.log(`${method} ${path} -> ${status} (${durationMs}ms)`);
	},
});

// Get workspace
const workspace = await client.workspace.getWorkspace();
console.log(workspace.id, workspace.name);

// Update workspace name
const updated = await client.workspace.updateWorkspace({
	workspaceUpdateRequest: {name: "Acme Corp"},
});

// List usecases
const usecases = await client.usecases.listUsecases();

// Get usecase by ID
const usecase = await client.usecases.getUsecase({useCaseId: "uc_abc123"});

// Create usecase
const created = await client.usecases.createUsecase({
	useCaseWriteRequest: {name: "Q4 Outreach", description: "Quarterly sales push"},
});

// Update usecase
const updated = await client.usecases.updateUsecase({
	useCaseId: "uc_abc123",
	useCaseWriteRequest: {name: "Updated Usecase"},
});

// Delete usecase
await client.usecases.deleteUsecase({useCaseId: "uc_abc123"});

// List agents
const agents = await client.agents.listAgents({limit: 50});

// Get agent by ID
const agent = await client.agents.getAgent({agentId: "ag_abc123"});

// Create agent
const created = await client.agents.createAgent({
	agentCreateRequest: {name: "Sales Agent", gender: "female"},
});

// Update agent
const updated = await client.agents.updateAgent({
	agentId: "ag_abc123",
	agentUpdateRequest: {name: "Updated Name", gender: "male"},
});

// Delete agent
await client.agents.deleteAgent({agentId: "ag_abc123"});

// List leads for an agent
const leads = await client.leads.listLeads({
	agentId: "ag_abc123",
	limit: 50,
});

// Get lead by ID
const lead = await client.leads.getLead({agentId: "ag_abc123", leadId: "ld_xyz789"});

// Create lead
const newLeads = await client.leads.createLead({
	agentId: "ag_abc123",
	body: {
		name: "Jane Doe",
		email: "jane@example.com",
		phone: "+911234567890",
		description: "Interested in pricing",
	},
});

// Update lead
const updatedLead = await client.leads.updateLead({
	agentId: "ag_abc123",
	leadId: "ld_xyz789",
	leadUpdateRequest: {name: "Jane Smith"},
});

// Delete lead
await client.leads.deleteLead({agentId: "ag_abc123", leadId: "ld_xyz789"});

// List calls for an agent
const calls = await client.calls.listCalls({agentId: "ag_abc123", limit: 50});

// Get call by ID
const call = await client.calls.getCall({agentId: "ag_abc123", callId: "cl_xyz789"});

// Create call (initiate outbound call to a lead)
const newCalls = await client.calls.createCall({
	agentId: "ag_abc123",
	callCreateRequest: {leadId: "ld_xyz789"},
});
console.log(newCalls[0].id, newCalls[0].status);

// Bulk call creation (initiate calls to multiple leads at once)
const bulkCalls = await client.calls.createCall({
	agentId: "ag_abc123",
	callCreateRequest: {leadIds: ["ld_xyz789", "ld_abc456", "ld_def012"]},
});
console.log(`Created ${bulkCalls.length} calls`);
bulkCalls.forEach((call) => console.log(call.id, call.status));

// Create call export job
const job = await client.jobs.createCallExportJob({
	callExportJobRequest: {agentId: "ag_abc123", limit: 100},
	idempotencyKey: crypto.randomUUID(),
});

// Get job status
const jobStatus = await client.jobs.getJob({jobHandle: job.handle});

// Cancel job
await client.jobs.cancelJob({jobHandle: job.handle});

import {paginate} from "@outcallerai/sdk";

for await (const lead of paginate(
	async (cursor) =>
		client.leads.listLeads({
			agentId: "ag_abc123",
			cursor,
			limit: 50,
		}),
	{maxPages: 1_000},
)) {
	console.log(lead.id, lead.name);
}

const lead = await client.leads.createLead({
	agentId: "ag_abc123",
	body: {
		name: "Jane",
		email: "jane@example.com",
		phone: "+911234567890",
		description: "Interested in pricing",
	},
	idempotencyKey: crypto.randomUUID(),
});

const controller = new AbortController();
setTimeout(() => controller.abort(), 5_000);

const agents = await client.agents.listAgents({}, {signal: controller.signal});

import {
	AuthenticationError,
	OutCallerAIError,
	RateLimitError,
} from "@outcallerai/sdk";

try {
	const agent = await client.agents.createAgent({ ... });
} catch (error) {
	if (error instanceof AuthenticationError) {
		// The API key is invalid or has been revoked
	} else if (error instanceof RateLimitError) {
		// Back off - the SDK already retried when safe
	} else if (error instanceof OutCallerAIError) {
		console.error(error.code, error.requestId, error.category);
	}
	throw error;
}

const client = new OutCallerAI({
	apiKey: process.env.OUTCALLERAI_API_KEY!,
	onResponse: ({method, path, status, requestId, durationMs, rateLimit}) => {
		console.log(`${method} ${path} -> ${status} (${durationMs}ms)`);
		console.log("Rate limit:", rateLimit.remaining, "/", rateLimit.limit);
	},
});