@recombine-ai/bosun 0.16.0 → 0.16.2-cloud-1

package/dist/types/backend/tests/router.d.ts

@@ -0,0 +1,347 @@
+import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import';
+import { type TrpcContext } from '../lib/trpc-context';
+export declare function createTestsRouter(t: TRPCRootObject<TrpcContext, any, any>): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../lib/bosun-context").BosunContext;
+    meta: any;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+        };
+        output: import("./data").TestTable;
+        meta: any;
+    }>;
+    latestResult: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+        };
+        output: Record<string, import("./data").TestResult>;
+        meta: any;
+    }>;
+    runProgress: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+        };
+        output: import("./academy").PromptTestsProgress | null;
+        meta: any;
+    }>;
+    historyList: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+        };
+        output: import("./data").TestRunHistorySummary[];
+        meta: any;
+    }>;
+    historyRun: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+            timestamp: string;
+        };
+        output: import("./data").TestRunHistoryDetail;
+        meta: any;
+    }>;
+    resultEntry: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+            testId: string;
+            resultKey: string;
+            index?: number | undefined;
+            timestamp?: string | undefined;
+        };
+        output: string;
+        meta: any;
+    }>;
+    analyzeRun: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            testId: string;
+            index: number;
+            timestamp?: string | undefined;
+        };
+        output: import("./analyze").AnalyzeRunResult;
+        meta: any;
+    }>;
+    findPromptIssues: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            step: string;
+            prompt: string;
+        };
+        output: import("./prompt-issues").FindPromptIssuesResult;
+        meta: any;
+    }>;
+    suite: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agent: string;
+        };
+        output: {
+            tests: {
+                id: string;
+                order: number;
+                pinned: "TRUE" | "FALSE";
+                scenario: string;
+                assertion_type: string;
+                assertion_value: string;
+                conversation: string;
+                expected_output: string;
+                timeout: string;
+                similarity_threshold: string;
+                context: Record<string, unknown>;
+                step?: string | undefined;
+                author?: string | undefined;
+                category?: string | undefined;
+                evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+                case_sensitive?: boolean | undefined;
+                context_mode?: "replace" | "merge" | undefined;
+                mocks?: Record<string, unknown> | undefined;
+            }[];
+        };
+        meta: any;
+    }>;
+    addTest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            seed: {
+                conversation?: string | undefined;
+                pinned?: "TRUE" | "FALSE" | undefined;
+                scenario?: string | undefined;
+                step?: string | undefined;
+                author?: string | undefined;
+                category?: string | undefined;
+                assertion_type?: string | undefined;
+                assertion_value?: string | undefined;
+                expected_output?: string | undefined;
+                evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+                case_sensitive?: boolean | undefined;
+                context_mode?: "replace" | "merge" | undefined;
+                timeout?: string | undefined;
+                similarity_threshold?: string | undefined;
+                context?: Record<string, unknown> | undefined;
+                mocks?: Record<string, unknown> | undefined;
+            };
+        };
+        output: {
+            id: string;
+            order: number;
+            pinned: "TRUE" | "FALSE";
+            scenario: string;
+            assertion_type: string;
+            assertion_value: string;
+            conversation: string;
+            expected_output: string;
+            timeout: string;
+            similarity_threshold: string;
+            context: Record<string, unknown>;
+            step?: string | undefined;
+            author?: string | undefined;
+            category?: string | undefined;
+            evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+            case_sensitive?: boolean | undefined;
+            context_mode?: "replace" | "merge" | undefined;
+            mocks?: Record<string, unknown> | undefined;
+        };
+        meta: any;
+    }>;
+    createPIISanitizedTestDraft: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            seed: {
+                pinned: "TRUE";
+                evaluation_mode: "assertion" | "json-deep-equal";
+                context_mode: "replace";
+                assertion_type: "llm-rubric";
+                assertion_value: string;
+                conversation: string;
+                expected_output: string;
+                similarity_threshold: string;
+                timeout: string;
+                context: Record<string, unknown>;
+                step?: string | undefined;
+                mocks?: Record<string, unknown> | undefined;
+            };
+        };
+        output: {
+            draftId: `${string}-${string}-${string}-${string}-${string}`;
+            seed: {
+                pinned: "TRUE";
+                evaluation_mode: "assertion" | "json-deep-equal";
+                context_mode: "replace";
+                assertion_type: "llm-rubric";
+                assertion_value: string;
+                conversation: string;
+                expected_output: string;
+                similarity_threshold: string;
+                timeout: string;
+                context: Record<string, unknown>;
+                step?: string | undefined;
+                mocks?: Record<string, unknown> | undefined;
+            };
+            findings: {
+                category: "person" | "contact" | "address" | "date_of_birth" | "account_identifier" | "vehicle_identifier" | "financial" | "special_category" | "other";
+                paths: string[];
+            }[];
+            expiresAt: number;
+            model: string;
+            status: "ready";
+            message?: undefined;
+            aiResponse?: undefined;
+        } | {
+            status: "sanitizer-error";
+            message: string;
+            aiResponse: string;
+        };
+        meta: any;
+    }>;
+    createTestFromPIISanitizedTestDraft: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            draftId: string;
+            reviewed: {
+                conversation: string;
+                expected_output: string;
+                context: Record<string, unknown>;
+                mocks?: Record<string, unknown> | undefined;
+            };
+        };
+        output: {
+            status: "created";
+            test: import("./suite").TestRow;
+        };
+        meta: any;
+    }>;
+    patchTest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            id: string;
+            patch: {
+                conversation?: string | undefined;
+                pinned?: "TRUE" | "FALSE" | undefined;
+                scenario?: string | undefined;
+                step?: string | undefined;
+                author?: string | undefined;
+                category?: string | undefined;
+                assertion_type?: string | undefined;
+                assertion_value?: string | undefined;
+                expected_output?: string | undefined;
+                evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+                case_sensitive?: boolean | undefined;
+                context_mode?: "replace" | "merge" | undefined;
+                timeout?: string | undefined;
+                similarity_threshold?: string | undefined;
+                context?: Record<string, unknown> | undefined;
+                mocks?: Record<string, unknown> | undefined;
+            };
+        };
+        output: {
+            id: string;
+            order: number;
+            pinned: "TRUE" | "FALSE";
+            scenario: string;
+            assertion_type: string;
+            assertion_value: string;
+            conversation: string;
+            expected_output: string;
+            timeout: string;
+            similarity_threshold: string;
+            context: Record<string, unknown>;
+            step?: string | undefined;
+            author?: string | undefined;
+            category?: string | undefined;
+            evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+            case_sensitive?: boolean | undefined;
+            context_mode?: "replace" | "merge" | undefined;
+            mocks?: Record<string, unknown> | undefined;
+        } | null;
+        meta: any;
+    }>;
+    patchTestsBatch: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            updates: {
+                id: string;
+                patch: {
+                    conversation?: string | undefined;
+                    pinned?: "TRUE" | "FALSE" | undefined;
+                    scenario?: string | undefined;
+                    step?: string | undefined;
+                    author?: string | undefined;
+                    category?: string | undefined;
+                    assertion_type?: string | undefined;
+                    assertion_value?: string | undefined;
+                    expected_output?: string | undefined;
+                    evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+                    case_sensitive?: boolean | undefined;
+                    context_mode?: "replace" | "merge" | undefined;
+                    timeout?: string | undefined;
+                    similarity_threshold?: string | undefined;
+                    context?: Record<string, unknown> | undefined;
+                    mocks?: Record<string, unknown> | undefined;
+                };
+            }[];
+        };
+        output: {
+            id: string;
+            order: number;
+            pinned: "TRUE" | "FALSE";
+            scenario: string;
+            assertion_type: string;
+            assertion_value: string;
+            conversation: string;
+            expected_output: string;
+            timeout: string;
+            similarity_threshold: string;
+            context: Record<string, unknown>;
+            step?: string | undefined;
+            author?: string | undefined;
+            category?: string | undefined;
+            evaluation_mode?: "assertion" | "json-deep-equal" | undefined;
+            case_sensitive?: boolean | undefined;
+            context_mode?: "replace" | "merge" | undefined;
+            mocks?: Record<string, unknown> | undefined;
+        }[];
+        meta: any;
+    }>;
+    deleteTest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            id: string;
+        };
+        output: boolean;
+        meta: any;
+    }>;
+    reorder: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            order: string[];
+        };
+        output: void;
+        meta: any;
+    }>;
+    runTests: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+            step: string;
+            repeats: number;
+            concurrency: number;
+            scope?: "pinned" | "all" | undefined;
+            promptOverrides?: Record<string, string> | undefined;
+        } | {
+            agent: string;
+            testId: string;
+            repeats: number;
+            concurrency: number;
+            promptOverrides?: Record<string, string> | undefined;
+        };
+        output: import("./academy").WrittenRunReport;
+        meta: any;
+    }>;
+    cancelRun: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agent: string;
+        };
+        output: boolean;
+        meta: any;
+    }>;
+}>>;

package/dist/types/backend/tests/suite.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { BosunContext } from '../lib/bosun-context';
+export declare const TestRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodNumber;
+    pinned: z.ZodEnum<{
+        TRUE: "TRUE";
+        FALSE: "FALSE";
+    }>;
+    scenario: z.ZodString;
+    step: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    assertion_type: z.ZodString;
+    assertion_value: z.ZodString;
+    conversation: z.ZodString;
+    expected_output: z.ZodString;
+    evaluation_mode: z.ZodOptional<z.ZodEnum<{
+        assertion: "assertion";
+        "json-deep-equal": "json-deep-equal";
+    }>>;
+    case_sensitive: z.ZodOptional<z.ZodBoolean>;
+    context_mode: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        merge: "merge";
+    }>>;
+    timeout: z.ZodString;
+    similarity_threshold: z.ZodString;
+    context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    mocks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const TestSuiteSchema: z.ZodObject<{
+    tests: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        order: z.ZodNumber;
+        pinned: z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>;
+        scenario: z.ZodString;
+        step: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        assertion_type: z.ZodString;
+        assertion_value: z.ZodString;
+        conversation: z.ZodString;
+        expected_output: z.ZodString;
+        evaluation_mode: z.ZodOptional<z.ZodEnum<{
+            assertion: "assertion";
+            "json-deep-equal": "json-deep-equal";
+        }>>;
+        case_sensitive: z.ZodOptional<z.ZodBoolean>;
+        context_mode: z.ZodOptional<z.ZodEnum<{
+            replace: "replace";
+            merge: "merge";
+        }>>;
+        timeout: z.ZodString;
+        similarity_threshold: z.ZodString;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        mocks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TestRow = z.infer<typeof TestRowSchema>;
+export type TestSuite = z.infer<typeof TestSuiteSchema>;
+export declare function getSuiteDirectory(ctx: BosunContext, suiteKey: string): string;
+export declare function withSuiteMutationLock<T>(suiteKey: string, fn: () => Promise<T>): Promise<T>;
+export declare function readSuite(ctx: BosunContext, suiteKey: string): Promise<TestSuite>;
+export declare function writeSuite(ctx: BosunContext, suiteKey: string, suite: TestSuite): Promise<void>;
+export declare function normalizeRow(r: any): TestRow;

package/dist/types/lib/api-telescope/types.d.ts

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+export declare const TranscriptSegmentSchema: z.ZodObject<{
+    text: z.ZodString;
+    role: z.ZodString;
+    time: z.ZodString;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ConversationSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    medium: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+    phoneNumber: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    audioUrl: z.ZodOptional<z.ZodString>;
+    transcript: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        role: z.ZodString;
+        time: z.ZodString;
+        duration: z.ZodNumber;
+    }, z.core.$strip>>]>>;
+    createdAt: z.ZodNumber;
+}, z.core.$loose>;
+export type Conversation = z.infer<typeof ConversationSchema>;
+export declare const PaginatedConversationsResponseSchema: z.ZodObject<{
+    limit: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        conversationId: z.ZodString;
+        medium: z.ZodString;
+        agentId: z.ZodOptional<z.ZodString>;
+        phoneNumber: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        audioUrl: z.ZodOptional<z.ZodString>;
+        transcript: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            role: z.ZodString;
+            time: z.ZodString;
+            duration: z.ZodNumber;
+        }, z.core.$strip>>]>>;
+        createdAt: z.ZodNumber;
+    }, z.core.$loose>>;
+    lastConversationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PaginatedConversationsResponse = z.infer<typeof PaginatedConversationsResponseSchema>;
+export type GetConversationsRequest = {
+    phoneNumber?: string;
+    agentId?: string;
+    limit?: number;
+    lastConversationId?: string;
+};
+export declare const LlmUsageSchema: z.ZodObject<{
+    promptTokens: z.ZodOptional<z.ZodNumber>;
+    completionTokens: z.ZodOptional<z.ZodNumber>;
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    cachedPromptTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const StepTraceSchema: z.ZodObject<{
+    traceType: z.ZodLiteral<"STEP">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    workflowRunId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    renderedPrompt: z.ZodOptional<z.ZodString>;
+    receivedContext: z.ZodOptional<z.ZodAny>;
+    receivedPrompt: z.ZodOptional<z.ZodAny>;
+    stringifiedConversation: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    llmUsage: z.ZodOptional<z.ZodObject<{
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        cachedPromptTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>;
+export declare const ApiCallTraceSchema: z.ZodObject<{
+    traceType: z.ZodLiteral<"API_CALL">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    operationName: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodAny>;
+    response: z.ZodOptional<z.ZodAny>;
+    status: z.ZodOptional<z.ZodNumber>;
+    ok: z.ZodOptional<z.ZodBoolean>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>;
+export declare const ConversationalTraceSchema: z.ZodObject<{
+    traceType: z.ZodLiteral<"CONVERSATIONAL">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodString;
+    role: z.ZodString;
+    medium: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>;
+export declare const LatencyTraceSchema: z.ZodObject<{
+    traceType: z.ZodLiteral<"LATENCY">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    seq: z.ZodNumber;
+    atMs: z.ZodNumber;
+    eventType: z.ZodString;
+    payload: z.ZodOptional<z.ZodAny>;
+    createdAt: z.ZodNumber;
+}, z.core.$loose>;
+export declare const TraceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    traceType: z.ZodLiteral<"STEP">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    workflowRunId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    renderedPrompt: z.ZodOptional<z.ZodString>;
+    receivedContext: z.ZodOptional<z.ZodAny>;
+    receivedPrompt: z.ZodOptional<z.ZodAny>;
+    stringifiedConversation: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    llmUsage: z.ZodOptional<z.ZodObject<{
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        completionTokens: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        cachedPromptTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>, z.ZodObject<{
+    traceType: z.ZodLiteral<"API_CALL">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    operationName: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodAny>;
+    response: z.ZodOptional<z.ZodAny>;
+    status: z.ZodOptional<z.ZodNumber>;
+    ok: z.ZodOptional<z.ZodBoolean>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>, z.ZodObject<{
+    traceType: z.ZodLiteral<"CONVERSATIONAL">;
+    traceId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodString;
+    role: z.ZodString;
+    medium: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>], "traceType">;
+export type StepTrace = z.infer<typeof StepTraceSchema>;
+export type ApiCallTrace = z.infer<typeof ApiCallTraceSchema>;
+export type ConversationalTrace = z.infer<typeof ConversationalTraceSchema>;
+export type LatencyTrace = z.infer<typeof LatencyTraceSchema>;
+export type Trace = z.infer<typeof TraceSchema>;
+export declare const PaginatedTracesResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        traceType: z.ZodLiteral<"STEP">;
+        traceId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        scopeId: z.ZodOptional<z.ZodString>;
+        workflowId: z.ZodOptional<z.ZodString>;
+        workflowRunId: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        renderedPrompt: z.ZodOptional<z.ZodString>;
+        receivedContext: z.ZodOptional<z.ZodAny>;
+        receivedPrompt: z.ZodOptional<z.ZodAny>;
+        stringifiedConversation: z.ZodOptional<z.ZodString>;
+        response: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        llmUsage: z.ZodOptional<z.ZodObject<{
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            cachedPromptTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        createdAt: z.ZodNumber;
+        error: z.ZodOptional<z.ZodAny>;
+    }, z.core.$loose>, z.ZodObject<{
+        traceType: z.ZodLiteral<"API_CALL">;
+        traceId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        scopeId: z.ZodOptional<z.ZodString>;
+        operationName: z.ZodString;
+        method: z.ZodString;
+        path: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        request: z.ZodOptional<z.ZodAny>;
+        response: z.ZodOptional<z.ZodAny>;
+        status: z.ZodOptional<z.ZodNumber>;
+        ok: z.ZodOptional<z.ZodBoolean>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        error: z.ZodOptional<z.ZodAny>;
+    }, z.core.$loose>, z.ZodObject<{
+        traceType: z.ZodLiteral<"CONVERSATIONAL">;
+        traceId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        scopeId: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodString;
+        role: z.ZodString;
+        medium: z.ZodString;
+        content: z.ZodString;
+        createdAt: z.ZodNumber;
+        error: z.ZodOptional<z.ZodAny>;
+    }, z.core.$loose>], "traceType">>;
+    limit: z.ZodNumber;
+    lastTraceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PaginatedLatencyTracesResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        traceType: z.ZodLiteral<"LATENCY">;
+        traceId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        seq: z.ZodNumber;
+        atMs: z.ZodNumber;
+        eventType: z.ZodString;
+        payload: z.ZodOptional<z.ZodAny>;
+        createdAt: z.ZodNumber;
+    }, z.core.$loose>>;
+    limit: z.ZodNumber;
+    lastTraceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PaginatedTracesResponse = z.infer<typeof PaginatedTracesResponseSchema>;
+export type PaginatedLatencyTracesResponse = z.infer<typeof PaginatedLatencyTracesResponseSchema>;

package/dist/types/lib/conversation.d.ts

@@ -0,0 +1,33 @@
+import type { Message } from '@recombine-ai/engine';
+import type { ApiCallTrace, ConversationalTrace, StepTrace } from '@recombine-ai/telescope';
+import type { LogEntry } from './ws-message';
+export type ConversationMedium = 'phone' | 'whatsapp';
+interface Entry<Kind extends string, Payload> {
+    id: string;
+    turn: number;
+    kind: Kind;
+    createdAt: number;
+    payload: Payload;
+}
+export type ConversationEntry = Entry<'message', Message> | Entry<'conversational-trace', ConversationalTrace> | Entry<'step-trace', StepTrace> | Entry<'api-call-trace', ApiCallTrace> | Entry<'log', LogEntry>;
+export type ConversationEntryKind = ConversationEntry['kind'];
+export interface Conversation {
+    conversationId: string;
+    agentId: string;
+    medium: ConversationMedium;
+    createdAt: number;
+    context: Record<string, unknown>;
+    entries: ConversationEntry[];
+}
+export interface ConversationHeader {
+    conversationId: string;
+    agentId: string;
+    createdAt: number;
+    lastMessage: string | null;
+    lastMessageAt: number | null;
+}
+export declare function messageSummary(message: Message): string;
+export declare function lastTurn(conversation: Conversation): number;
+export declare function conversationMessages(conversation: Conversation): Message[];
+export declare function conversationHeader(conversation: Conversation): ConversationHeader;
+export {};