ctxpkg 0.0.3 → 0.0.4

package/dist/agent/agent.test-runner.schemas.d.ts

@@ -0,0 +1,382 @@
+import * as z from 'zod';
+/**
+ * Validation modes for test assertions
+ */
+export declare const validationModeSchema: z.ZodEnum<["semantic", "llm", "keywords"]>;
+export type ValidationMode = z.infer<typeof validationModeSchema>;
+/**
+ * Individual test case
+ */
+export declare const testCaseSchema: z.ZodObject<{
+    /** Unique identifier for the test */
+    id: z.ZodString;
+    /** The question to ask the agent */
+    query: z.ZodString;
+    /** Use case context for the question */
+    useCase: z.ZodString;
+    /** Expected answer description or reference answer */
+    expected: z.ZodString;
+    /** Keywords that should appear in the answer (for keywords mode) */
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Override validation mode for this specific test */
+    validationMode: z.ZodOptional<z.ZodEnum<["semantic", "llm", "keywords"]>>;
+    /** Custom validation instructions for LLM mode */
+    validationInstructions: z.ZodOptional<z.ZodString>;
+    /** Override pass threshold for this specific test (0-1) */
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    /** Whether this test is currently skipped */
+    skip: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    expected: string;
+    id: string;
+    query: string;
+    useCase: string;
+    keywords?: string[] | undefined;
+    validationMode?: "semantic" | "llm" | "keywords" | undefined;
+    validationInstructions?: string | undefined;
+    passThreshold?: number | undefined;
+    skip?: boolean | undefined;
+}, {
+    expected: string;
+    id: string;
+    query: string;
+    useCase: string;
+    keywords?: string[] | undefined;
+    validationMode?: "semantic" | "llm" | "keywords" | undefined;
+    validationInstructions?: string | undefined;
+    passThreshold?: number | undefined;
+    skip?: boolean | undefined;
+}>;
+export type TestCase = z.infer<typeof testCaseSchema>;
+/**
+ * Collection specification (same as context.json format)
+ */
+export declare const collectionSpecSchema: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export type CollectionSpec = z.infer<typeof collectionSpecSchema>;
+/**
+ * Test suite options
+ */
+export declare const testOptionsSchema: z.ZodObject<{
+    /** Default validation mode (default: semantic) */
+    validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["semantic", "llm", "keywords"]>>>;
+    /** Pass threshold for semantic similarity (0-1, default: 0.75) */
+    passThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /** Default validation instructions for LLM mode */
+    validationInstructions: z.ZodOptional<z.ZodString>;
+    /** Maximum time per test in milliseconds (default: 60000) */
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    validationMode: "semantic" | "llm" | "keywords";
+    passThreshold: number;
+    timeoutMs: number;
+    validationInstructions?: string | undefined;
+}, {
+    validationMode?: "semantic" | "llm" | "keywords" | undefined;
+    validationInstructions?: string | undefined;
+    passThreshold?: number | undefined;
+    timeoutMs?: number | undefined;
+}>;
+export type TestOptions = z.infer<typeof testOptionsSchema>;
+/**
+ * Complete test suite file structure
+ */
+export declare const testSuiteSchema: z.ZodObject<{
+    /** Name of the test suite */
+    name: z.ZodString;
+    /** Description of what this test suite covers */
+    description: z.ZodOptional<z.ZodString>;
+    /** Collections to sync before running tests */
+    collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>>;
+    /** Test suite options */
+    options: z.ZodOptional<z.ZodObject<{
+        /** Default validation mode (default: semantic) */
+        validationMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["semantic", "llm", "keywords"]>>>;
+        /** Pass threshold for semantic similarity (0-1, default: 0.75) */
+        passThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /** Default validation instructions for LLM mode */
+        validationInstructions: z.ZodOptional<z.ZodString>;
+        /** Maximum time per test in milliseconds (default: 60000) */
+        timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        validationMode: "semantic" | "llm" | "keywords";
+        passThreshold: number;
+        timeoutMs: number;
+        validationInstructions?: string | undefined;
+    }, {
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        timeoutMs?: number | undefined;
+    }>>;
+    /** Test cases */
+    tests: z.ZodArray<z.ZodObject<{
+        /** Unique identifier for the test */
+        id: z.ZodString;
+        /** The question to ask the agent */
+        query: z.ZodString;
+        /** Use case context for the question */
+        useCase: z.ZodString;
+        /** Expected answer description or reference answer */
+        expected: z.ZodString;
+        /** Keywords that should appear in the answer (for keywords mode) */
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Override validation mode for this specific test */
+        validationMode: z.ZodOptional<z.ZodEnum<["semantic", "llm", "keywords"]>>;
+        /** Custom validation instructions for LLM mode */
+        validationInstructions: z.ZodOptional<z.ZodString>;
+        /** Override pass threshold for this specific test (0-1) */
+        passThreshold: z.ZodOptional<z.ZodNumber>;
+        /** Whether this test is currently skipped */
+        skip: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        expected: string;
+        id: string;
+        query: string;
+        useCase: string;
+        keywords?: string[] | undefined;
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        skip?: boolean | undefined;
+    }, {
+        expected: string;
+        id: string;
+        query: string;
+        useCase: string;
+        keywords?: string[] | undefined;
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        skip?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    collections: Record<string, {
+        url: string;
+    }>;
+    tests: {
+        expected: string;
+        id: string;
+        query: string;
+        useCase: string;
+        keywords?: string[] | undefined;
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        skip?: boolean | undefined;
+    }[];
+    options?: {
+        validationMode: "semantic" | "llm" | "keywords";
+        passThreshold: number;
+        timeoutMs: number;
+        validationInstructions?: string | undefined;
+    } | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    collections: Record<string, {
+        url: string;
+    }>;
+    tests: {
+        expected: string;
+        id: string;
+        query: string;
+        useCase: string;
+        keywords?: string[] | undefined;
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        skip?: boolean | undefined;
+    }[];
+    options?: {
+        validationMode?: "semantic" | "llm" | "keywords" | undefined;
+        validationInstructions?: string | undefined;
+        passThreshold?: number | undefined;
+        timeoutMs?: number | undefined;
+    } | undefined;
+    description?: string | undefined;
+}>;
+export type TestSuite = z.infer<typeof testSuiteSchema>;
+/**
+ * Result of a single test case
+ */
+export declare const testResultSchema: z.ZodObject<{
+    /** Test case ID */
+    id: z.ZodString;
+    /** Whether the test passed */
+    passed: z.ZodBoolean;
+    /** Score (0-1) for semantic/llm validation */
+    score: z.ZodOptional<z.ZodNumber>;
+    /** The agent's actual answer */
+    actualAnswer: z.ZodString;
+    /** Validation reasoning (from LLM mode) or match details */
+    reasoning: z.ZodOptional<z.ZodString>;
+    /** Keywords found (for keywords mode) */
+    keywordsFound: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Keywords missing (for keywords mode) */
+    keywordsMissing: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Time taken in milliseconds */
+    durationMs: z.ZodNumber;
+    /** Error message if the test failed to run */
+    error: z.ZodOptional<z.ZodString>;
+    /** Whether the test was skipped */
+    skipped: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    passed: boolean;
+    actualAnswer: string;
+    durationMs: number;
+    score?: number | undefined;
+    reasoning?: string | undefined;
+    keywordsFound?: string[] | undefined;
+    keywordsMissing?: string[] | undefined;
+    error?: string | undefined;
+    skipped?: boolean | undefined;
+}, {
+    id: string;
+    passed: boolean;
+    actualAnswer: string;
+    durationMs: number;
+    score?: number | undefined;
+    reasoning?: string | undefined;
+    keywordsFound?: string[] | undefined;
+    keywordsMissing?: string[] | undefined;
+    error?: string | undefined;
+    skipped?: boolean | undefined;
+}>;
+export type TestResult = z.infer<typeof testResultSchema>;
+/**
+ * Complete test run results
+ */
+export declare const testRunResultSchema: z.ZodObject<{
+    /** Test suite name */
+    suiteName: z.ZodString;
+    /** When the test run started */
+    startedAt: z.ZodString;
+    /** When the test run completed */
+    completedAt: z.ZodString;
+    /** Total duration in milliseconds */
+    durationMs: z.ZodNumber;
+    /** Summary statistics */
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        passed: number;
+        skipped: number;
+        total: number;
+        failed: number;
+    }, {
+        passed: number;
+        skipped: number;
+        total: number;
+        failed: number;
+    }>;
+    /** Individual test results */
+    results: z.ZodArray<z.ZodObject<{
+        /** Test case ID */
+        id: z.ZodString;
+        /** Whether the test passed */
+        passed: z.ZodBoolean;
+        /** Score (0-1) for semantic/llm validation */
+        score: z.ZodOptional<z.ZodNumber>;
+        /** The agent's actual answer */
+        actualAnswer: z.ZodString;
+        /** Validation reasoning (from LLM mode) or match details */
+        reasoning: z.ZodOptional<z.ZodString>;
+        /** Keywords found (for keywords mode) */
+        keywordsFound: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Keywords missing (for keywords mode) */
+        keywordsMissing: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Time taken in milliseconds */
+        durationMs: z.ZodNumber;
+        /** Error message if the test failed to run */
+        error: z.ZodOptional<z.ZodString>;
+        /** Whether the test was skipped */
+        skipped: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        passed: boolean;
+        actualAnswer: string;
+        durationMs: number;
+        score?: number | undefined;
+        reasoning?: string | undefined;
+        keywordsFound?: string[] | undefined;
+        keywordsMissing?: string[] | undefined;
+        error?: string | undefined;
+        skipped?: boolean | undefined;
+    }, {
+        id: string;
+        passed: boolean;
+        actualAnswer: string;
+        durationMs: number;
+        score?: number | undefined;
+        reasoning?: string | undefined;
+        keywordsFound?: string[] | undefined;
+        keywordsMissing?: string[] | undefined;
+        error?: string | undefined;
+        skipped?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    suiteName: string;
+    startedAt: string;
+    completedAt: string;
+    summary: {
+        passed: number;
+        skipped: number;
+        total: number;
+        failed: number;
+    };
+    results: {
+        id: string;
+        passed: boolean;
+        actualAnswer: string;
+        durationMs: number;
+        score?: number | undefined;
+        reasoning?: string | undefined;
+        keywordsFound?: string[] | undefined;
+        keywordsMissing?: string[] | undefined;
+        error?: string | undefined;
+        skipped?: boolean | undefined;
+    }[];
+}, {
+    durationMs: number;
+    suiteName: string;
+    startedAt: string;
+    completedAt: string;
+    summary: {
+        passed: number;
+        skipped: number;
+        total: number;
+        failed: number;
+    };
+    results: {
+        id: string;
+        passed: boolean;
+        actualAnswer: string;
+        durationMs: number;
+        score?: number | undefined;
+        reasoning?: string | undefined;
+        keywordsFound?: string[] | undefined;
+        keywordsMissing?: string[] | undefined;
+        error?: string | undefined;
+        skipped?: boolean | undefined;
+    }[];
+}>;
+export type TestRunResult = z.infer<typeof testRunResultSchema>;
+//# sourceMappingURL=agent.test-runner.schemas.d.ts.map

package/dist/agent/agent.test-runner.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.test-runner.schemas.d.ts","sourceRoot":"","sources":["../../src/agent/agent.test-runner.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,oBAAoB,4CAA0C,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB,qCAAqC;;IAGrC,oCAAoC;;IAGpC,wCAAwC;;IAGxC,sDAAsD;;IAGtD,oEAAoE;;IAGpE,sDAAsD;;IAGtD,kDAAkD;;IAGlD,2DAA2D;;IAG3D,6CAA6C;;;;;;;;;;;;;;;;;;;;;;EAE7C,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAE/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,kDAAkD;;IAGlD,kEAAkE;;IAGlE,mDAAmD;;IAGnD,6DAA6D;;;;;;;;;;;;EAE7D,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B,6BAA6B;;IAG7B,iDAAiD;;IAGjD,+CAA+C;;;;;;;;IAG/C,yBAAyB;;QA5BzB,kDAAkD;;QAGlD,kEAAkE;;QAGlE,mDAAmD;;QAGnD,6DAA6D;;;;;;;;;;;;;IAsB7D,iBAAiB;;QA1EjB,qCAAqC;;QAGrC,oCAAoC;;QAGpC,wCAAwC;;QAGxC,sDAAsD;;QAGtD,oEAAoE;;QAGpE,sDAAsD;;QAGtD,kDAAkD;;QAGlD,2DAA2D;;QAG3D,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD7C,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B,mBAAmB;;IAGnB,8BAA8B;;IAG9B,8CAA8C;;IAG9C,gCAAgC;;IAGhC,4DAA4D;;IAG5D,yCAAyC;;IAGzC,2CAA2C;;IAG3C,iCAAiC;;IAGjC,8CAA8C;;IAG9C,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B,sBAAsB;;IAGtB,gCAAgC;;IAGhC,kCAAkC;;IAGlC,qCAAqC;;IAGrC,yBAAyB;;;;;;;;;;;;;;;;;IAQzB,8BAA8B;;QAzD9B,mBAAmB;;QAGnB,8BAA8B;;QAG9B,8CAA8C;;QAG9C,gCAAgC;;QAGhC,4DAA4D;;QAG5D,yCAAyC;;QAGzC,2CAA2C;;QAG3C,iCAAiC;;QAGjC,8CAA8C;;QAG9C,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCnC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/agent/agent.test-runner.schemas.js

@@ -0,0 +1,110 @@
+import * as z from 'zod';
+/**
+ * Validation modes for test assertions
+ */
+export const validationModeSchema = z.enum(['semantic', 'llm', 'keywords']);
+/**
+ * Individual test case
+ */
+export const testCaseSchema = z.object({
+    /** Unique identifier for the test */
+    id: z.string(),
+    /** The question to ask the agent */
+    query: z.string(),
+    /** Use case context for the question */
+    useCase: z.string(),
+    /** Expected answer description or reference answer */
+    expected: z.string(),
+    /** Keywords that should appear in the answer (for keywords mode) */
+    keywords: z.array(z.string()).optional(),
+    /** Override validation mode for this specific test */
+    validationMode: validationModeSchema.optional(),
+    /** Custom validation instructions for LLM mode */
+    validationInstructions: z.string().optional(),
+    /** Override pass threshold for this specific test (0-1) */
+    passThreshold: z.number().min(0).max(1).optional(),
+    /** Whether this test is currently skipped */
+    skip: z.boolean().optional(),
+});
+/**
+ * Collection specification (same as context.json format)
+ */
+export const collectionSpecSchema = z.object({
+    url: z.string(),
+});
+/**
+ * Test suite options
+ */
+export const testOptionsSchema = z.object({
+    /** Default validation mode (default: semantic) */
+    validationMode: validationModeSchema.optional().default('semantic'),
+    /** Pass threshold for semantic similarity (0-1, default: 0.75) */
+    passThreshold: z.number().min(0).max(1).optional().default(0.75),
+    /** Default validation instructions for LLM mode */
+    validationInstructions: z.string().optional(),
+    /** Maximum time per test in milliseconds (default: 60000) */
+    timeoutMs: z.number().optional().default(60000),
+});
+/**
+ * Complete test suite file structure
+ */
+export const testSuiteSchema = z.object({
+    /** Name of the test suite */
+    name: z.string(),
+    /** Description of what this test suite covers */
+    description: z.string().optional(),
+    /** Collections to sync before running tests */
+    collections: z.record(z.string(), collectionSpecSchema),
+    /** Test suite options */
+    options: testOptionsSchema.optional(),
+    /** Test cases */
+    tests: z.array(testCaseSchema).min(1),
+});
+/**
+ * Result of a single test case
+ */
+export const testResultSchema = z.object({
+    /** Test case ID */
+    id: z.string(),
+    /** Whether the test passed */
+    passed: z.boolean(),
+    /** Score (0-1) for semantic/llm validation */
+    score: z.number().optional(),
+    /** The agent's actual answer */
+    actualAnswer: z.string(),
+    /** Validation reasoning (from LLM mode) or match details */
+    reasoning: z.string().optional(),
+    /** Keywords found (for keywords mode) */
+    keywordsFound: z.array(z.string()).optional(),
+    /** Keywords missing (for keywords mode) */
+    keywordsMissing: z.array(z.string()).optional(),
+    /** Time taken in milliseconds */
+    durationMs: z.number(),
+    /** Error message if the test failed to run */
+    error: z.string().optional(),
+    /** Whether the test was skipped */
+    skipped: z.boolean().optional(),
+});
+/**
+ * Complete test run results
+ */
+export const testRunResultSchema = z.object({
+    /** Test suite name */
+    suiteName: z.string(),
+    /** When the test run started */
+    startedAt: z.string(),
+    /** When the test run completed */
+    completedAt: z.string(),
+    /** Total duration in milliseconds */
+    durationMs: z.number(),
+    /** Summary statistics */
+    summary: z.object({
+        total: z.number(),
+        passed: z.number(),
+        failed: z.number(),
+        skipped: z.number(),
+    }),
+    /** Individual test results */
+    results: z.array(testResultSchema),
+});
+//# sourceMappingURL=agent.test-runner.schemas.js.map

package/dist/agent/agent.test-runner.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.test-runner.schemas.js","sourceRoot":"","sources":["../../src/agent/agent.test-runner.schemas.ts"],"names":[],"mappings":"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"}

package/dist/agent/agent.types.d.ts

@@ -0,0 +1,122 @@
+import * as z from 'zod';
+/**
+ * LLM configuration for the agent
+ */
+export type LLMConfig = {
+    /** OpenAI-compatible API base URL */
+    provider: string;
+    /** Model identifier */
+    model: string;
+    /** API key */
+    apiKey: string;
+    /** Temperature (0-2) */
+    temperature: number;
+    /** Maximum tokens */
+    maxTokens: number;
+};
+/**
+ * Source reference for an answer
+ */
+export declare const sourceSchema: z.ZodObject<{
+    collection: z.ZodString;
+    document: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    document: string;
+    section?: string | undefined;
+}, {
+    collection: string;
+    document: string;
+    section?: string | undefined;
+}>;
+export type Source = z.infer<typeof sourceSchema>;
+/**
+ * Agent response
+ */
+export declare const agentResponseSchema: z.ZodObject<{
+    answer: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        collection: z.ZodString;
+        document: z.ZodString;
+        section: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        document: string;
+        section?: string | undefined;
+    }, {
+        collection: string;
+        document: string;
+        section?: string | undefined;
+    }>, "many">;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    answer: string;
+    sources: {
+        collection: string;
+        document: string;
+        section?: string | undefined;
+    }[];
+    confidence: "high" | "medium" | "low";
+    note?: string | undefined;
+}, {
+    answer: string;
+    sources: {
+        collection: string;
+        document: string;
+        section?: string | undefined;
+    }[];
+    confidence: "high" | "medium" | "low";
+    note?: string | undefined;
+}>;
+export type AgentResponse = z.infer<typeof agentResponseSchema>;
+/**
+ * Callback for verbose mode - called when agent takes a step
+ */
+export type AgentStepCallback = (step: AgentStep) => void;
+/**
+ * Represents a step in the agent's reasoning
+ */
+export type AgentStep = {
+    type: 'thinking' | 'tool_call' | 'tool_result' | 'error';
+    content: string;
+    toolName?: string;
+    toolInput?: Record<string, unknown>;
+};
+/**
+ * Options for creating a document agent
+ */
+export type DocumentAgentOptions = {
+    /** LLM configuration */
+    llmConfig: LLMConfig;
+    /** LangChain tools to use */
+    tools: any[];
+    /** Maximum iterations before stopping */
+    maxIterations?: number;
+    /** Callback for verbose mode */
+    onStep?: AgentStepCallback;
+    /** Collections to restrict searches to (instruction in system prompt) */
+    collections?: string[];
+};
+/**
+ * Options for asking a question
+ */
+export type AskOptions = {
+    /** Callback for verbose mode */
+    onStep?: AgentStepCallback;
+};
+/**
+ * Retry configuration for LLM calls
+ */
+export type RetryConfig = {
+    /** Maximum number of retry attempts */
+    maxRetries: number;
+    /** Initial delay in ms */
+    initialDelayMs: number;
+    /** Maximum delay in ms */
+    maxDelayMs: number;
+    /** Multiplier for exponential backoff */
+    backoffMultiplier: number;
+};
+//# sourceMappingURL=agent.types.d.ts.map

package/dist/agent/agent.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.types.d.ts","sourceRoot":"","sources":["../../src/agent/agent.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc;IACd,MAAM,EAAE,MAAM,CAAC;IACf,wBAAwB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;EAIvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,OAAO,CAAC;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,wBAAwB;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,6BAA6B;IAE7B,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,yCAAyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,gCAAgC;IAChC,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC"}

package/dist/agent/agent.types.js

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+/**
+ * Source reference for an answer
+ */
+export const sourceSchema = z.object({
+    collection: z.string(),
+    document: z.string(),
+    section: z.string().optional(),
+});
+/**
+ * Agent response
+ */
+export const agentResponseSchema = z.object({
+    answer: z.string(),
+    sources: z.array(sourceSchema),
+    confidence: z.enum(['high', 'medium', 'low']),
+    note: z.string().optional(),
+});
+//# sourceMappingURL=agent.types.js.map

package/dist/agent/agent.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.types.js","sourceRoot":"","sources":["../../src/agent/agent.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAkBzB;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;IAC9B,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC,CAAC"}

package/dist/backend/backend.d.ts

@@ -0,0 +1,16 @@
+import { type Response } from './backend.protocol.js';
+import { type BackendServices } from './backend.services.js';
+import { Services, destroy } from '#root/utils/utils.services.js';
+type BackendOptions = {
+    services?: Services;
+};
+declare class Backend {
+    #private;
+    constructor(options?: BackendOptions);
+    setConnectionCount(count: number): void;
+    getServices(): BackendServices;
+    handleRequest(raw: unknown): Promise<Response>;
+    [destroy]: () => Promise<void>;
+}
+export { Backend };
+//# sourceMappingURL=backend.d.ts.map

package/dist/backend/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/backend/backend.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAEd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEpF,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAElE,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,CAAC;AAEF,cAAM,OAAO;;gBAMC,OAAO,CAAC,EAAE,cAAc;IAUpC,kBAAkB,CAAC,KAAK,EAAE,MAAM;IAKhC,WAAW,IAAI,eAAe;IAKxB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IA4DpD,CAAC,OAAO,CAAC,sBAEP;CACH;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}