TypeScript SDKs

npm install @contextcompany/otel @opentelemetry/api

npm install @contextcompany/custom

const step = r.step({ stepId?: string, startTime?: Date });

step.prompt(text: string);
step.response(text: string);
step.model(config: string | { requested?: string; used?: string });
step.finishReason(reason: string);
step.tokens({
  uncached?: number,
  cached?: number,
  completion?: number
});
step.cost(amount: number);  // USD
step.toolDefinitions(defs: string | unknown[]);
step.status(code: number, message?: string);
step.endTime(date: Date);

step.end();        // Success
step.error(msg);   // Error

const tc = r.toolCall('tool_name' | { name?: string, toolCallId?: string });

tc.name(toolName: string);
tc.args(value: string | Record<string, unknown>);
tc.result(value: string | Record<string, unknown>);
tc.status(code: number, message?: string);
tc.endTime(date: Date);

tc.end();        // Success
tc.error(msg);   // Error

import { configure } from '@contextcompany/custom';

configure({
  apiKey?: string,      // Override TCC_API_KEY env var
  debug?: boolean,      // Enable debug logging
  url?: string,         // Custom ingestion endpoint
  runTimeout?: number   // Default auto-flush timeout (ms)
});

import type {
  RunOptions,
  StepOptions,
  ToolCallOptions,
  TokenUsage,
  ModelConfig,
  RunInput,
  StepInput,
  ToolCallInput,
  ClientConfig
} from '@contextcompany/custom';

npm install @contextcompany/claude @anthropic-ai/claude-agent-sdk

import { Agent } from '@anthropic-ai/claude-agent-sdk';
import { instrumentClaudeAgent, submitFeedback } from '@contextcompany/claude';

const agent = new Agent({
  model: 'claude-4-sonnet',
  tools: [/* ... */]
});

const instrumented = instrumentClaudeAgent(agent);

// Query with TCC metadata
for await (const message of instrumented.query({
  prompt: 'What is the weather in SF?',
  tcc: {
    runId: 'custom-run-id',
    sessionId: 'session-123',
    metadata: { user: 'alice' },
    debug: true
  }
})) {
  console.log(message);
}

// Submit feedback
await submitFeedback({
  runId: 'custom-run-id',
  score: 'thumbs_up'
});

export function instrumentClaudeAgent<T extends object>(
  sdk: T
): WrappedSDK<T>;

export type TCCConfig = {
  runId?: string;
  sessionId?: string;
  metadata?: Record<string, unknown>;
  debug?: boolean;
};

export type WrappedSDK<T> = T extends { query: infer Q }
  ? Omit<T, 'query'> & {
      query: (params: {
        prompt: Parameters<Q>[0]['prompt'];
        options?: Parameters<Q>[0]['options'];
        tcc?: TCCConfig;
      }) => ReturnType<Q>;
    }
  : T;

npm install @contextcompany/mastra @mastra/core

import { Mastra } from '@mastra/core';
import { TCCMastraExporter } from '@contextcompany/mastra';

const framework = new Mastra({
  tracing: {
    serviceName: 'my-mastra-agent',
    exporters: [
      new TCCMastraExporter({
        apiKey: process.env.TCC_API_KEY,
        debug: true
      })
    ]
  }
});

import type { TCCMastraExporterConfig } from '@contextcompany/mastra';

type TCCMastraExporterConfig = {
  apiKey?: string;
  endpoint?: string;
  debug?: boolean;
};

npm install @contextcompany/widget

export interface WidgetOptions {
  enabled?: boolean;      // Enable/disable widget (default: true)
  onMount?: () => void;   // Callback when widget mounts
}

export function initWidget(options?: WidgetOptions): () => void;
export function cleanup(): void;

npm install @contextcompany/api

export function submitFeedback(params: {
  runId: string;
  score?: 'thumbs_up' | 'thumbs_down';
  text?: string;
}): Promise<Response | undefined>;

export function getTCCApiKey(): string | undefined;

export function getTCCUrl(
  apiKey: string | undefined,
  prodUrl: string,
  devUrl: string
): string;

export function getTCCFeedbackUrl(): string;

import { submitFeedback } from '@contextcompany/otel';
// or '@contextcompany/custom'
// or '@contextcompany/claude'
// or '@contextcompany/mastra'
// or '@contextcompany/api'

await submitFeedback({
  runId: 'run_abc123',
  score: 'thumbs_up',
  text: 'Excellent response!'
});

import { run } from '@contextcompany/custom';

const r = run();

try {
  r.prompt('Process this data');
  // ... agent logic
  r.response(result);
  await r.end();
} catch (error) {
  await r.error(`Failed: ${error.message}`);
}

import { run } from '@contextcompany/custom';

const sessionId = 'session_' + userId;

// First turn
const r1 = run({ sessionId, conversational: true });
r1.prompt('Hello');
r1.response('Hi! How can I help?');
await r1.end();

// Second turn (same session)
const r2 = run({ sessionId, conversational: true });
r2.prompt('What is the weather?');
r2.response('It is sunny.');
await r2.end();