tekivex-ui 3.4.0 → 3.18.0

package/dist/src/agent/devtools/DevToolsPanel.d.ts

@@ -0,0 +1,8 @@
+import type { AgentEvent } from '../core/events';
+export interface DevToolsPanelProps {
+    events: AgentEvent[];
+    onClear?(): void;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    startOpen?: boolean;
+}
+export declare function DevToolsPanel({ events, onClear, position, startOpen, }: DevToolsPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/agent/devtools/useEventCollector.d.ts

@@ -0,0 +1,8 @@
+import type { AgentEvent } from '../core/events';
+import type { Middleware } from '../core/Middleware';
+export interface UseEventCollectorReturn {
+    events: AgentEvent[];
+    middleware: Middleware;
+    clear(): void;
+}
+export declare function useEventCollector(): UseEventCollectorReturn;

package/dist/src/agent/eval/runEval.d.ts

@@ -0,0 +1,31 @@
+import type { Agent } from '../core/Agent';
+import type { Provider } from '../core/Provider';
+export interface EvalCase {
+    name: string;
+    input: string;
+    expected?: string;
+    judge?(output: string, expected?: string): boolean | Promise<boolean>;
+    meta?: Record<string, unknown>;
+}
+export interface EvalResult {
+    name: string;
+    input: string;
+    output: string;
+    passed: boolean;
+    durationMs: number;
+    error?: Error;
+    meta?: Record<string, unknown>;
+}
+export interface EvalSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    passRate: number;
+    totalDurationMs: number;
+    results: EvalResult[];
+}
+export declare function runEval(agent: Agent, cases: EvalCase[], opts?: {
+    signal?: AbortSignal;
+    onProgress?(done: number, total: number): void;
+}): Promise<EvalSummary>;
+export declare function judgeWithLLM(provider: Provider, model: string, criteria: string): (output: string, expected?: string) => Promise<boolean>;

package/dist/src/agent/index.d.ts

@@ -0,0 +1,54 @@
+export * from './core/types';
+export * from './core/Provider';
+export * from './core/Tool';
+export * from './core/Memory';
+export * from './core/Transport';
+export * from './core/Middleware';
+export * from './core/Sanitizer';
+export * from './core/events';
+export * from './core/sse';
+export * from './core/Agent';
+export { AnthropicProvider } from './providers/anthropic';
+export type { AnthropicProviderOptions } from './providers/anthropic';
+export { OpenAIProvider } from './providers/openai';
+export type { OpenAIProviderOptions } from './providers/openai';
+export { GeminiProvider } from './providers/gemini';
+export type { GeminiProviderOptions } from './providers/gemini';
+export { OllamaProvider } from './providers/ollama';
+export type { OllamaProviderOptions } from './providers/ollama';
+export * from './rag/Retriever';
+export * from './rag/retrievalTool';
+export * from './multi/agentAsTool';
+export * from './middleware/tokenUsage';
+export * from './middleware/retry';
+export * from './middleware/otel';
+export * from './middleware/guardrails';
+export * from './memory/SlidingWindowMemory';
+export * from './memory/SummarizingMemory';
+export * from './memory/VectorMemory';
+export * from './structured/generateObject';
+export * from './content/helpers';
+export * from './mcp/MCPClient';
+export * from './mcp/mcpAdapter';
+export * from './eval/runEval';
+export * from './tools/cancellable';
+export * from './components/TkxAgentMessage';
+export * from './components/TkxToolCallCard';
+export * from './components/TkxReasoningTrace';
+export * from './research/DeepResearch';
+export * from './research/citations';
+export * from './bindings/vanilla';
+export * from './bindings/vue';
+export * from './bindings/svelte';
+export * from './bindings/solid';
+export * from './server/createAgentRoute';
+export * from './server/createAgentClient';
+export * from './replay/recorder';
+export * from './replay/ReplayProvider';
+export * from './devtools/DevToolsPanel';
+export * from './devtools/useEventCollector';
+export * from './a2a/A2AClient';
+export * from './a2a/a2aTool';
+export * from './a2a/createA2ARoute';
+export { useAgent } from './react/useAgent';
+export type { UseAgentReturn } from './react/useAgent';

package/dist/src/agent/mcp/MCPClient.d.ts

@@ -0,0 +1,33 @@
+import { type Transport } from '../core/Transport';
+export interface MCPClientOptions {
+    endpoint: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+}
+export interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPCallResult {
+    content?: Array<{
+        type: string;
+        text?: string;
+    }>;
+    isError?: boolean;
+}
+export declare class MCPClient {
+    private readonly opts;
+    private idSeq;
+    private transport;
+    private initialized;
+    constructor(opts: MCPClientOptions);
+    initialize(signal?: AbortSignal): Promise<void>;
+    listTools(signal?: AbortSignal): Promise<MCPTool[]>;
+    callTool(name: string, args: unknown, signal?: AbortSignal): Promise<MCPCallResult>;
+    private call;
+}

package/dist/src/agent/mcp/mcpAdapter.d.ts

@@ -0,0 +1,3 @@
+import { type Tool } from '../core/Tool';
+import { MCPClient } from './MCPClient';
+export declare function mcpTools(client: MCPClient, signal?: AbortSignal): Promise<Tool[]>;

package/dist/src/agent/memory/SlidingWindowMemory.d.ts

@@ -0,0 +1,10 @@
+import type { Memory } from '../core/Memory';
+import type { Message } from '../core/types';
+export declare class SlidingWindowMemory implements Memory {
+    private readonly windowSize;
+    private messages;
+    constructor(windowSize: number);
+    append(message: Message): void;
+    all(): Message[];
+    clear(): void;
+}

package/dist/src/agent/memory/SummarizingMemory.d.ts

@@ -0,0 +1,16 @@
+import type { Memory } from '../core/Memory';
+import type { Message } from '../core/types';
+export interface SummarizingMemoryOptions {
+    threshold: number;
+    keepRecent?: number;
+    summarizer(messages: Message[]): string | Promise<string>;
+}
+export declare class SummarizingMemory implements Memory {
+    private readonly opts;
+    private messages;
+    private summary;
+    constructor(opts: SummarizingMemoryOptions);
+    append(message: Message): Promise<void>;
+    all(): Message[];
+    clear(): void;
+}

package/dist/src/agent/memory/VectorMemory.d.ts

@@ -0,0 +1,17 @@
+import type { Memory } from '../core/Memory';
+import type { Retriever } from '../rag/Retriever';
+import type { Message } from '../core/types';
+export interface VectorMemoryOptions {
+    retriever: Retriever;
+    topK?: number;
+    keepRecent?: number;
+    onAppend?(message: Message): void | Promise<void>;
+}
+export declare class VectorMemory implements Memory {
+    private readonly opts;
+    private messages;
+    constructor(opts: VectorMemoryOptions);
+    append(message: Message): Promise<void>;
+    all(): Promise<Message[]>;
+    clear(): void;
+}

package/dist/src/agent/middleware/guardrails.d.ts

@@ -0,0 +1,20 @@
+import type { Middleware } from '../core/Middleware';
+export interface GuardrailVerdict {
+    allow: boolean;
+    replacement?: string;
+    reason?: string;
+}
+export interface Guardrail {
+    name: string;
+    checkInput?(text: string): GuardrailVerdict | Promise<GuardrailVerdict>;
+    checkOutput?(text: string): GuardrailVerdict | Promise<GuardrailVerdict>;
+}
+export declare class GuardrailViolation extends Error {
+    readonly guardrailName: string;
+    readonly reason: string;
+    constructor(guardrailName: string, reason: string);
+}
+export declare function checkGuardrails(text: string, guardrails: Guardrail[], direction: 'input' | 'output'): Promise<GuardrailVerdict>;
+export declare function guardrailsMiddleware(guardrails: Guardrail[]): Middleware;
+export declare const piiRedactor: Guardrail;
+export declare const promptInjectionDetector: Guardrail;

package/dist/src/agent/middleware/otel.d.ts

@@ -0,0 +1,13 @@
+import type { Middleware } from '../core/Middleware';
+export interface OTelSpan {
+    end(attrs?: Record<string, unknown>): void;
+}
+export interface OTelSink {
+    spanStart(name: string, attrs?: Record<string, unknown>): OTelSpan;
+    event(name: string, attrs?: Record<string, unknown>): void;
+}
+export interface OTelMiddlewareOptions {
+    sink: OTelSink;
+    serviceName?: string;
+}
+export declare function otelMiddleware(opts: OTelMiddlewareOptions): Middleware;

package/dist/src/agent/middleware/retry.d.ts

@@ -0,0 +1,11 @@
+import type { Transport, TransportResponse } from '../core/Transport';
+export interface RetryOptions {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    factor?: number;
+    jitter?: boolean;
+    retryOn?(res: TransportResponse): boolean;
+    retryOnError?(err: unknown): boolean;
+}
+export declare function withRetry(base: Transport, opts?: RetryOptions): Transport;

package/dist/src/agent/middleware/tokenUsage.d.ts

@@ -0,0 +1,27 @@
+import type { Middleware } from '../core/Middleware';
+export interface TokenUsageTotals {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    totalCostUSD: number;
+    byModel: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        costUSD: number;
+    }>;
+}
+export interface TokenPricing {
+    inputPerMillion: number;
+    outputPerMillion: number;
+    cachedInputPerMillion?: number;
+}
+export interface TokenUsageMiddlewareOptions {
+    pricing?: Record<string, TokenPricing>;
+    model?: string;
+    onUpdate?(totals: TokenUsageTotals): void;
+}
+export declare function createTokenUsageTracker(opts?: TokenUsageMiddlewareOptions): {
+    middleware: Middleware;
+    totals(): TokenUsageTotals;
+    reset(): void;
+};

package/dist/src/agent/multi/agentAsTool.d.ts

@@ -0,0 +1,11 @@
+import type { Agent } from '../core/Agent';
+import { type Tool } from '../core/Tool';
+export interface AgentAsToolOptions {
+    name: string;
+    description: string;
+    agent: Agent;
+    inputDescription?: string;
+}
+export declare function agentAsTool(opts: AgentAsToolOptions): Tool<{
+    input: string;
+}, string>;

package/dist/src/agent/providers/anthropic.d.ts

@@ -0,0 +1,16 @@
+import type { ChatOptions, Provider, StreamEvent } from '../core/Provider';
+import { type Transport } from '../core/Transport';
+export interface AnthropicProviderOptions {
+    endpoint?: string;
+    apiKey?: string;
+    apiVersion?: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+}
+export declare class AnthropicProvider implements Provider {
+    private readonly opts;
+    readonly name = "anthropic";
+    private readonly transport;
+    constructor(opts?: AnthropicProviderOptions);
+    stream(opts: ChatOptions): AsyncGenerator<StreamEvent>;
+}

package/dist/src/agent/providers/gemini.d.ts

@@ -0,0 +1,16 @@
+import type { ChatOptions, Provider, StreamEvent } from '../core/Provider';
+import { type Transport } from '../core/Transport';
+export interface GeminiProviderOptions {
+    endpoint?: string;
+    apiKey?: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+}
+export declare class GeminiProvider implements Provider {
+    private readonly opts;
+    readonly name = "gemini";
+    private readonly transport;
+    constructor(opts?: GeminiProviderOptions);
+    stream(opts: ChatOptions): AsyncGenerator<StreamEvent>;
+    private buildUrl;
+}

package/dist/src/agent/providers/ollama.d.ts

@@ -0,0 +1,14 @@
+import type { ChatOptions, Provider, StreamEvent } from '../core/Provider';
+import { type Transport } from '../core/Transport';
+export interface OllamaProviderOptions {
+    endpoint?: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+}
+export declare class OllamaProvider implements Provider {
+    private readonly opts;
+    readonly name = "ollama";
+    private readonly transport;
+    constructor(opts?: OllamaProviderOptions);
+    stream(opts: ChatOptions): AsyncGenerator<StreamEvent>;
+}

package/dist/src/agent/providers/openai.d.ts

@@ -0,0 +1,16 @@
+import type { ChatOptions, Provider, StreamEvent } from '../core/Provider';
+import { type Transport } from '../core/Transport';
+export interface OpenAIProviderOptions {
+    endpoint?: string;
+    apiKey?: string;
+    organization?: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+}
+export declare class OpenAIProvider implements Provider {
+    private readonly opts;
+    readonly name = "openai";
+    private readonly transport;
+    constructor(opts?: OpenAIProviderOptions);
+    stream(opts: ChatOptions): AsyncGenerator<StreamEvent>;
+}

package/dist/src/agent/rag/Retriever.d.ts

@@ -0,0 +1,13 @@
+export interface RetrievalResult {
+    text: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RetrieveOptions {
+    topK?: number;
+    signal?: AbortSignal;
+    filter?: Record<string, unknown>;
+}
+export interface Retriever {
+    retrieve(query: string, opts?: RetrieveOptions): Promise<RetrievalResult[]>;
+}

package/dist/src/agent/rag/retrievalTool.d.ts

@@ -0,0 +1,11 @@
+import { type Tool } from '../core/Tool';
+import type { Retriever } from './Retriever';
+export interface RetrievalToolOptions {
+    retriever: Retriever;
+    name?: string;
+    description?: string;
+    topK?: number;
+}
+export declare function retrievalTool(opts: RetrievalToolOptions): Tool<{
+    query: string;
+}, string>;

package/dist/src/agent/react/useAgent.d.ts

@@ -0,0 +1,12 @@
+import { type AgentOptions } from '../core/Agent';
+import type { Message } from '../core/types';
+export interface UseAgentReturn {
+    messages: Message[];
+    streamingText: string;
+    isStreaming: boolean;
+    error: Error | null;
+    send(text: string): Promise<void>;
+    stop(): void;
+    reset(): void;
+}
+export declare function useAgent(opts: AgentOptions): UseAgentReturn;

package/dist/src/agent/replay/ReplayProvider.d.ts

@@ -0,0 +1,13 @@
+import type { ChatOptions, Provider, StreamEvent } from '../core/Provider';
+import type { Recording } from './recorder';
+export interface ReplayProviderOptions {
+    recording: Recording;
+    delayMsBetweenEvents?: number;
+}
+export declare class ReplayProvider implements Provider {
+    private readonly opts;
+    readonly name = "replay";
+    private readonly events;
+    constructor(opts: ReplayProviderOptions);
+    stream(_opts: ChatOptions): AsyncGenerator<StreamEvent>;
+}

package/dist/src/agent/replay/recorder.d.ts

@@ -0,0 +1,16 @@
+import type { AgentEvent } from '../core/events';
+import type { Middleware } from '../core/Middleware';
+export interface Recording {
+    events: AgentEvent[];
+    startedAt: number;
+}
+export declare class Recorder {
+    private events;
+    private started;
+    record(event: AgentEvent): void;
+    snapshot(): Recording;
+    toJSONL(): string;
+    static fromJSONL(jsonl: string): Recording;
+    reset(): void;
+    asMiddleware(): Middleware;
+}

package/dist/src/agent/research/DeepResearch.d.ts

@@ -0,0 +1,37 @@
+import type { Provider } from '../core/Provider';
+import type { Tool } from '../core/Tool';
+import type { Retriever } from '../rag/Retriever';
+export interface DeepResearchOptions {
+    provider: Provider;
+    model: string;
+    retriever?: Retriever;
+    tools?: Tool[];
+    maxSubtasks?: number;
+    concurrency?: number;
+    signal?: AbortSignal;
+}
+export interface ResearchPlan {
+    subtasks: Array<{
+        id: string;
+        question: string;
+    }>;
+}
+export interface SubFinding {
+    id: string;
+    question: string;
+    findings: string;
+    error?: string;
+}
+export interface ResearchResult {
+    question: string;
+    plan: ResearchPlan;
+    subFindings: SubFinding[];
+    synthesis: string;
+}
+export declare class DeepResearch {
+    private readonly opts;
+    constructor(opts: DeepResearchOptions);
+    run(question: string, signal?: AbortSignal): Promise<ResearchResult>;
+    private research;
+}
+export declare function createDeepResearch(opts: DeepResearchOptions): DeepResearch;

package/dist/src/agent/research/citations.d.ts

@@ -0,0 +1,10 @@
+export interface Citation {
+    id: string;
+    text: string;
+    source?: string;
+    url?: string;
+    score?: number;
+}
+export declare function extractCitations(text: string): Citation[];
+export declare function mergeCitations(...lists: Citation[][]): Citation[];
+export declare function formatCitationsList(citations: Citation[]): string;

package/dist/src/agent/server/createAgentClient.d.ts

@@ -0,0 +1,11 @@
+import type { AgentEvent } from '../core/events';
+import { type Transport } from '../core/Transport';
+export interface AgentClientOptions {
+    endpoint: string;
+    transport?: Transport;
+    headers?: Record<string, string>;
+}
+export interface AgentClient {
+    run(message: string, signal?: AbortSignal): AsyncIterable<AgentEvent>;
+}
+export declare function createAgentClient(opts: AgentClientOptions): AgentClient;

package/dist/src/agent/server/createAgentRoute.d.ts

@@ -0,0 +1,10 @@
+import { type AgentOptions } from '../core/Agent';
+export interface CreateAgentRouteOptions {
+    agent: (req: Request) => AgentOptions | Promise<AgentOptions>;
+    parseInput?(req: Request, body: unknown): {
+        message: string;
+    } | Promise<{
+        message: string;
+    }>;
+}
+export declare function createAgentRoute(opts: CreateAgentRouteOptions): (req: Request) => Promise<Response>;

package/dist/src/agent/structured/generateObject.d.ts

@@ -0,0 +1,19 @@
+import type { Provider } from '../core/Provider';
+import type { JSONSchema } from '../core/types';
+export interface GenerateObjectOptions<T> {
+    provider: Provider;
+    model: string;
+    schema: JSONSchema;
+    prompt: string;
+    system?: string;
+    maxTokens?: number;
+    temperature?: number;
+    maxRetries?: number;
+    parse?(raw: unknown): T;
+    signal?: AbortSignal;
+}
+export declare class StructuredOutputError extends Error {
+    readonly raw: string;
+    constructor(message: string, raw: string);
+}
+export declare function generateObject<T = unknown>(opts: GenerateObjectOptions<T>): Promise<T>;

package/dist/src/agent/tools/cancellable.d.ts

@@ -0,0 +1,6 @@
+import { type Tool } from '../core/Tool';
+export declare class ToolAbortError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+export declare function cancellable<TInput, TOutput>(tool: Tool<TInput, TOutput>): Tool<TInput, TOutput>;

package/dist/src/charts/TkxDataExplorer.d.ts

@@ -0,0 +1,17 @@
+import { type CSSProperties } from 'react';
+export type DataRecord = Record<string, string | number | null>;
+export type ChartKind = 'bar' | 'line' | 'area' | 'pie' | 'scatter';
+export type ColumnType = 'number' | 'string' | 'mixed';
+export interface TkxDataExplorerProps {
+    initialData?: DataRecord[];
+    allowedCharts?: ChartKind[];
+    previewRows?: number;
+    chartHeight?: number;
+    onDataLoad?: (data: DataRecord[]) => void;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function parseCSV(text: string): string[][];
+export declare function csvToRecords(rows: string[][]): DataRecord[];
+export declare function inferColumnTypes(records: DataRecord[]): Record<string, ColumnType>;
+export declare function TkxDataExplorer({ initialData, allowedCharts, previewRows, chartHeight, onDataLoad, style, className, }: TkxDataExplorerProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/charts/index.d.ts

@@ -5,6 +5,8 @@ export { TkxPieChart } from './TkxPieChart';
 export { TkxDonutChart } from './TkxDonutChart';
 export { TkxScatterChart } from './TkxScatterChart';
 export { TkxRadarChart } from './TkxRadarChart';
+export { TkxDataExplorer, parseCSV, csvToRecords, inferColumnTypes, } from './TkxDataExplorer';
+export type { TkxDataExplorerProps, DataRecord, ChartKind, ColumnType, } from './TkxDataExplorer';
 export type { TkxAreaChartProps } from './TkxAreaChart';
 export type { TkxBarChartProps } from './TkxBarChart';
 export type { TkxLineChartProps } from './TkxLineChart';

package/dist/src/components/TkxAccessibilityChecker.d.ts

@@ -0,0 +1,12 @@
+export interface TkxAccessibilityCheckerProps {
+    show?: boolean;
+    intervalMs?: number;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    scope?: Element | null;
+    axeOptions?: Record<string, unknown>;
+    onScan?: (result: {
+        violations: number;
+        impacts: Record<string, number>;
+    }) => void;
+}
+export declare function TkxAccessibilityChecker({ show, intervalMs, position, scope, axeOptions, onScan, }: TkxAccessibilityCheckerProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/components/TkxAppBar.d.ts

@@ -1,6 +1,7 @@
 import { type ReactNode } from 'react';
 export interface TkxAppBarProps {
     title?: ReactNode;
+    leading?: ReactNode;
     logo?: ReactNode;
     actions?: ReactNode;
     navigation?: ReactNode;
@@ -8,4 +9,4 @@ export interface TkxAppBarProps {
     variant?: 'default' | 'transparent' | 'elevated';
     color?: 'primary' | 'surface';
 }
-export declare function TkxAppBar({ title, logo, actions, navigation, position, variant, color, }: TkxAppBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function TkxAppBar({ title, leading, logo, actions, navigation, position, variant, color, }: TkxAppBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxButton.d.ts

@@ -12,5 +12,6 @@ export interface TkxButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>
     rightIcon?: ReactNode;
     isFullWidth?: boolean;
     glow?: boolean;
+    isDisabled?: boolean;
 }
 export declare const TkxButton: import("react").ForwardRefExoticComponent<TkxButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/src/components/TkxCommandPalette.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+export interface CommandPaletteCommand {
+    id: string;
+    title: string;
+    subtitle?: string;
+    section?: string;
+    icon?: ReactNode;
+    shortcut?: string[];
+    data?: unknown;
+    hidden?: boolean;
+    onSelect?: (cmd: CommandPaletteCommand) => void;
+}
+export interface CommandHotkey {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    key: string;
+}
+export interface TkxCommandPaletteProps {
+    commands: CommandPaletteCommand[];
+    hotkey?: CommandHotkey | null;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placeholder?: string;
+    onSelect?: (cmd: CommandPaletteCommand) => void;
+    recents?: boolean;
+    maxRecents?: number;
+    emptyState?: ReactNode;
+    className?: string;
+}
+export declare function fuzzyScore(query: string, text: string): number | null;
+export declare function TkxCommandPalette({ commands, hotkey, open: controlledOpen, onOpenChange, placeholder, onSelect, recents, maxRecents, emptyState, className, }: TkxCommandPaletteProps): import("react").ReactPortal | null;