@sensu-ai/sdk 0.1.6 → 0.5.2

package/src/index.ts

@@ -1,24 +0,0 @@
-export { SensuClient, RunHandle, StepHandle } from './client.ts';
-export type {
-  SensuClientOptions,
-  StartRunOptions,
-  StartStepOptions,
-  TrackLlmOptions,
-  TrackToolOptions,
-  RawLlmCallOptions,
-  ContextBreakdown,
-  TrackRetrievalOptions,
-  RawRetrievalOptions,
-  TrackEmbeddingOptions,
-  RawEmbeddingOptions,
-  RecordFeedbackOptions,
-  RecordEvalScoreOptions,
-  SpawnRunOptions,
-  HandoffOptions,
-  TrackGuardrailOptions,
-  RawGuardrailOptions,
-  RecordPromptRenderOptions,
-  DeployPromptVersionOptions,
-  StartSessionOptions,
-  ResumeSessionOptions,
-} from './types.ts';

package/src/integrations/langchain.ts

@@ -1,175 +0,0 @@
-/**
- * LangChain callback handler for Sensu telemetry.
- *
- * Usage:
- *   import { SensuCallbackHandler } from '@sensu-ai/sdk/integrations/langchain';
- *   const handler = new SensuCallbackHandler({ client: sensu });
- *   const chain = new LLMChain({ ..., callbacks: [handler] });
- */
-
-import { randomUUID } from 'crypto';
-import type { SensuClient } from '../client.ts';
-
-interface LangChainCallbackHandlerOptions {
-  client: SensuClient;
-  sessionId?: string;
-  runId?: string;
-}
-
-interface LangChainLlmStartInput {
-  name?: string;
-  [key: string]: unknown;
-}
-
-interface LangChainLlmEndOutput {
-  generations?: Array<Array<{ text?: string; generationInfo?: Record<string, unknown> }>>;
-  llmOutput?: Record<string, unknown>;
-}
-
-export class SensuCallbackHandler {
-  private readonly client: SensuClient;
-  private readonly sessionId: string;
-  private runId: string;
-  private traceId: string;
-  private startTimes: Map<string, number> = new Map();
-  private toolStartTimes: Map<string, number> = new Map();
-  private stepIds: Map<string, string> = new Map();
-
-  constructor(opts: LangChainCallbackHandlerOptions) {
-    this.client = opts.client;
-    this.sessionId = opts.sessionId ?? randomUUID();
-    this.runId = opts.runId ?? randomUUID();
-    this.traceId = randomUUID();
-  }
-
-  private base(spanId?: string) {
-    return {
-      event_id: randomUUID(),
-      timestamp: new Date().toISOString(),
-      org_id: (this.client as unknown as { orgId: string }).orgId,
-      agent_id: (this.client as unknown as { agentId: string }).agentId,
-      session_id: this.sessionId,
-      run_id: this.runId,
-      trace_id: this.traceId,
-      span_id: spanId ?? randomUUID(),
-    };
-  }
-
-  // Called when a chain starts
-  async handleChainStart(_chain: unknown, _inputs: unknown, runId: string) {
-    const stepId = randomUUID();
-    this.stepIds.set(runId, stepId);
-    this.client.enqueue({
-      ...this.base(randomUUID()),
-      step_id: stepId,
-      event_type: 'agent.step.started',
-      step_type: 'chain',
-      sequence: 0,
-    });
-  }
-
-  // Called when a chain ends
-  async handleChainEnd(_outputs: unknown, runId: string) {
-    const stepId = this.stepIds.get(runId);
-    this.client.enqueue({
-      ...this.base(),
-      step_id: stepId,
-      event_type: 'agent.step.completed',
-    });
-    this.stepIds.delete(runId);
-  }
-
-  // Called when an LLM starts
-  async handleLLMStart(
-    llm: LangChainLlmStartInput,
-    _prompts: string[],
-    runId: string,
-  ) {
-    this.startTimes.set(runId, Date.now());
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'llm.request.started',
-      provider: 'langchain',
-      model: llm.name ?? 'unknown',
-    });
-  }
-
-  // Called when an LLM ends
-  async handleLLMEnd(output: LangChainLlmEndOutput, runId: string) {
-    const startMs = this.startTimes.get(runId);
-    const latencyMs = startMs ? Date.now() - startMs : undefined;
-    this.startTimes.delete(runId);
-
-    // Extract token usage from llmOutput if available
-    const usage = output.llmOutput?.['tokenUsage'] as Record<string, number> | undefined;
-
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'llm.request.completed',
-      provider: 'langchain',
-      model: 'unknown',
-      latency_ms: latencyMs,
-      status: 'success',
-      input_tokens: usage?.['promptTokens'],
-      output_tokens: usage?.['completionTokens'],
-      total_tokens: usage?.['totalTokens'],
-    });
-  }
-
-  // Called when an LLM errors
-  async handleLLMError(err: Error, runId: string) {
-    const startMs = this.startTimes.get(runId);
-    const latencyMs = startMs ? Date.now() - startMs : undefined;
-    this.startTimes.delete(runId);
-
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'llm.request.completed',
-      provider: 'langchain',
-      model: 'unknown',
-      latency_ms: latencyMs,
-      status: 'error',
-    });
-  }
-
-  // Called when a tool starts
-  async handleToolStart(_tool: unknown, _input: string, runId: string) {
-    this.toolStartTimes.set(runId, Date.now());
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'tool.call.started',
-      tool_name: 'unknown',
-    });
-  }
-
-  // Called when a tool ends
-  async handleToolEnd(output: string, runId: string) {
-    const startMs = this.toolStartTimes.get(runId);
-    const latencyMs = startMs ? Date.now() - startMs : undefined;
-    this.toolStartTimes.delete(runId);
-
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'tool.call.completed',
-      tool_name: 'unknown',
-      latency_ms: latencyMs,
-      status: 'success',
-      output_size_bytes: Buffer.byteLength(output ?? '', 'utf8'),
-    });
-  }
-
-  // Called when a tool errors
-  async handleToolError(err: Error, runId: string) {
-    const startMs = this.toolStartTimes.get(runId);
-    const latencyMs = startMs ? Date.now() - startMs : undefined;
-    this.toolStartTimes.delete(runId);
-
-    this.client.enqueue({
-      ...this.base(),
-      event_type: 'tool.call.completed',
-      tool_name: 'unknown',
-      latency_ms: latencyMs,
-      status: 'error',
-    });
-  }
-}

package/src/integrations/openai.ts

@@ -1,109 +0,0 @@
-/**
- * OpenAI SDK wrapper for Sensu telemetry.
- * Wraps the OpenAI client to automatically track all completions.
- *
- * Usage:
- *   import { wrapOpenAI } from '@sensu-ai/sdk/integrations/openai';
- *   const openai = wrapOpenAI(new OpenAI({ apiKey }), { client: sensu, runHandle });
- *   const resp = await openai.chat.completions.create({ ... }); // auto-tracked
- */
-
-import type { SensuClient, RunHandle } from '../client.ts';
-
-interface OpenAILike {
-  chat: {
-    completions: {
-      create: (params: unknown) => Promise<unknown>;
-    };
-  };
-}
-
-interface WrapOpenAIOptions {
-  client: SensuClient;
-  runHandle?: RunHandle;
-  defaultModel?: string;
-  defaultProvider?: string;
-}
-
-interface CompletionUsage {
-  prompt_tokens?: number;
-  completion_tokens?: number;
-  total_tokens?: number;
-}
-
-interface CompletionResponse {
-  usage?: CompletionUsage;
-  model?: string;
-}
-
-export function wrapOpenAI<T extends OpenAILike>(
-  openai: T,
-  opts: WrapOpenAIOptions,
-): T {
-  const { client, runHandle } = opts;
-
-  const originalCreate = openai.chat.completions.create.bind(
-    openai.chat.completions,
-  );
-
-  openai.chat.completions.create = async (params: unknown): Promise<unknown> => {
-    const p = params as Record<string, unknown>;
-    const model = (p['model'] as string | undefined) ?? opts.defaultModel ?? 'unknown';
-    const provider = opts.defaultProvider ?? 'openai';
-
-    let step: import('../client.js').StepHandle | undefined;
-    if (runHandle) {
-      step = runHandle.startStep({ name: 'openai-completion', stepType: 'llm' });
-    }
-
-    const startMs = Date.now();
-    let result: unknown;
-    let status: 'success' | 'error' = 'success';
-    let err: unknown;
-
-    try {
-      result = await originalCreate(params);
-    } catch (e) {
-      status = 'error';
-      err = e;
-    }
-
-    const latencyMs = Date.now() - startMs;
-    const r = result as CompletionResponse | undefined;
-    const usage = r?.usage;
-
-    const callOpts = {
-      provider,
-      model: r?.model ?? model,
-      input_tokens: usage?.prompt_tokens,
-      output_tokens: usage?.completion_tokens,
-      total_tokens: usage?.total_tokens,
-      latency_ms: latencyMs,
-      status,
-    };
-
-    if (step) {
-      step.recordLlm(callOpts);
-      void step.end();
-    } else {
-      // Emit standalone if no step context
-      client.enqueue({
-        event_id: crypto.randomUUID(),
-        event_type: 'llm.request.completed',
-        timestamp: new Date().toISOString(),
-        org_id: (client as unknown as { orgId: string }).orgId,
-        agent_id: (client as unknown as { agentId: string }).agentId,
-        session_id: crypto.randomUUID(),
-        run_id: crypto.randomUUID(),
-        trace_id: crypto.randomUUID(),
-        span_id: crypto.randomUUID(),
-        ...callOpts,
-      });
-    }
-
-    if (err) throw err;
-    return result;
-  };
-
-  return openai;
-}

package/src/types.ts

@@ -1,240 +0,0 @@
-export interface SensuClientOptions {
-  apiKey?: string;
-  baseUrl?: string;
-  agentId?: string;
-  orgId?: string;
-  /** Read config from environment variables */
-  fromEnv?: boolean;
-  /** Flush buffer when this many events accumulate */
-  batchSize?: number;
-  /** Flush buffer every N milliseconds */
-  flushIntervalMs?: number;
-  /** Disable all telemetry (useful for tests) */
-  disabled?: boolean;
-}
-
-export interface StartRunOptions {
-  sessionId?: string;
-  runType?: string;
-  endUserId?: string;
-  runId?: string;
-}
-
-export interface StartStepOptions {
-  name?: string;
-  stepType?: string;
-  sequence?: number;
-  stepId?: string;
-}
-
-export interface ContextBreakdown {
-  system_tokens?: number;
-  user_tokens?: number;
-  assistant_tokens?: number;
-  tool_tokens?: number;
-  retrieval_tokens?: number;
-}
-
-export interface MessageSnapshotItem {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  tool_name?: string;
-  token_count: number;
-  content_hash: string;
-}
-
-export interface TrackLlmOptions {
-  provider: string;
-  model: string;
-  /** Wraps the LLM call and measures latency automatically */
-  fn: () => Promise<unknown>;
-  maxContextTokens?: number;
-  /**
-   * Optional callback to extract a context breakdown from the LLM response.
-   * Called with the raw response after fn() resolves.
-   */
-  extractContextBreakdown?: (result: unknown) => ContextBreakdown | undefined;
-  /** Stable ID for this LLM call — used to link eval scores. Generated if omitted. */
-  llmCallId?: string;
-  /** Snapshot of every message in the context window sent to this LLM call. */
-  messagesSnapshot?: MessageSnapshotItem[];
-  /** IDs of retrieval chunks whose content the model actually referenced in its output. */
-  referencedChunkIds?: string[];
-}
-
-export interface LlmResult {
-  inputTokens?: number;
-  outputTokens?: number;
-  cachedInputTokens?: number;
-  totalTokens?: number;
-  costUsdEstimate?: number;
-  result: unknown;
-}
-
-export interface TrackToolOptions {
-  toolName: string;
-  fn: () => Promise<unknown>;
-}
-
-export interface RawLlmCallOptions {
-  provider: string;
-  model: string;
-  inputTokens?: number;
-  outputTokens?: number;
-  cachedInputTokens?: number;
-  totalTokens?: number;
-  maxContextTokens?: number;
-  contextUsedTokens?: number;
-  latencyMs?: number;
-  ttftMs?: number;
-  costUsdEstimate?: number;
-  status?: 'success' | 'error' | 'timeout';
-  contextBreakdown?: ContextBreakdown;
-}
-
-// ---------------------------------------------------------------------------
-// Retrieval & Embedding
-// ---------------------------------------------------------------------------
-
-export interface TrackRetrievalOptions {
-  /** Wraps the retrieval call and measures latency automatically */
-  fn: () => Promise<unknown>;
-  vectorStoreId?: string;
-  topK?: number;
-}
-
-export interface RetrievalChunkInput {
-  chunk_id: string;
-  source?: string;
-  token_count: number;
-  similarity_score?: number;
-  content_preview?: string;
-}
-
-export interface RawRetrievalOptions {
-  vectorStoreId?: string;
-  topK?: number;
-  latencyMs?: number;
-  chunksReturned?: number;
-  tokensInjected?: number;
-  similarityScoreAvg?: number;
-  status?: 'success' | 'error';
-  /** Per-chunk detail for retrieval noise analysis. */
-  chunks?: RetrievalChunkInput[];
-}
-
-export interface TrackEmbeddingOptions {
-  model: string;
-  /** Wraps the embedding call and measures latency automatically */
-  fn: () => Promise<unknown>;
-  inputTextLength?: number;
-  batchSize?: number;
-}
-
-export interface RawEmbeddingOptions {
-  model: string;
-  inputTextLength?: number;
-  tokenCount?: number;
-  latencyMs?: number;
-  costUsdEstimate?: number;
-  batchSize?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Evaluation & Feedback
-// ---------------------------------------------------------------------------
-
-export interface RecordFeedbackOptions {
-  type: 'thumbs_up' | 'thumbs_down' | 'score' | 'correction';
-  score?: number;
-  comment?: string;
-  endUserId?: string;
-}
-
-export interface RecordEvalScoreOptions {
-  metric: string;
-  score: number;
-  evaluatorId?: string;
-  modelUsedForEval?: string;
-  /** Step ID this eval score is linked to — enables quality correlation view. */
-  stepId?: string;
-  /** LLM call ID this eval score is linked to — must match the llmCallId used in trackLlm(). */
-  llmCallId?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Multi-Agent
-// ---------------------------------------------------------------------------
-
-export interface SpawnRunOptions {
-  childAgentId: string;
-  childRunId?: string;
-  spawnReason?: string;
-  /** Options forwarded to the child RunHandle */
-  runType?: string;
-  sessionId?: string;
-}
-
-export interface HandoffOptions {
-  toAgentId: string;
-  reason?: string;
-  contextTokensTransferred?: number;
-}
-
-// ---------------------------------------------------------------------------
-// Guardrails
-// ---------------------------------------------------------------------------
-
-export interface TrackGuardrailOptions {
-  guardrailId: string;
-  guardrailType?: 'content' | 'pii' | 'jailbreak' | 'custom';
-  inputHash?: string;
-  /** Wraps the guardrail check and measures latency automatically */
-  fn: () => Promise<'pass' | 'fail' | 'modified'>;
-}
-
-export interface RawGuardrailOptions {
-  guardrailId: string;
-  guardrailType?: 'content' | 'pii' | 'jailbreak' | 'custom';
-  inputHash?: string;
-  result?: 'pass' | 'fail' | 'modified';
-  blockReason?: string;
-  severity?: 'low' | 'medium' | 'high';
-  latencyMs?: number;
-  blocked?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Prompt Management
-// ---------------------------------------------------------------------------
-
-export interface RecordPromptRenderOptions {
-  templateId: string;
-  templateVersion?: string;
-  renderedTokenCount?: number;
-  variableCount?: number;
-  latencyMs?: number;
-}
-
-export interface DeployPromptVersionOptions {
-  templateId: string;
-  newVersion: string;
-  oldVersion?: string;
-  deployedBy?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Session Lifecycle
-// ---------------------------------------------------------------------------
-
-export interface StartSessionOptions {
-  sessionId?: string;
-  channel?: 'web' | 'api' | 'mobile';
-  endUserId?: string;
-}
-
-export interface ResumeSessionOptions {
-  sessionId?: string;
-  resumedFromSessionId: string;
-  channel?: 'web' | 'api' | 'mobile';
-  endUserId?: string;
-}

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["node"]
-  },
-  "include": ["src"]
-}