@kb-labs/studio-data-client 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2755 @@
+import { AxiosRequestConfig } from 'axios';
+import * as _kb_labs_rest_api_contracts from '@kb-labs/rest-api-contracts';
+import { ErrorEnvelope, ReadyResponse, NotReadyResponse, SystemInfoPayload, SystemCapabilitiesPayload, SystemConfigPayload, PlatformConfigPayload } from '@kb-labs/rest-api-contracts';
+import { ServiceObservabilityHealth } from '@kb-labs/core-contracts';
+import * as _kb_labs_core_platform_adapters from '@kb-labs/core-platform/adapters';
+import { EventsQuery, EventsResponse, EventsStats, BufferStatus, DlqStatus } from '@kb-labs/core-platform/adapters';
+export { AnalyticsEvent, BufferStatus, DlqStatus, EventsQuery, EventsResponse, EventsStats } from '@kb-labs/core-platform/adapters';
+import { z } from 'zod';
+import { ManifestV3 } from '@kb-labs/plugin-contracts';
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+declare class KBError extends Error {
+    code: string;
+    message: string;
+    status?: number | undefined;
+    cause?: unknown | undefined;
+    constructor(code: string, message: string, status?: number | undefined, cause?: unknown | undefined);
+}
+declare const errorCodes: {
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly AUTH_ERROR: "AUTH_ERROR";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly CONFLICT: "CONFLICT";
+    readonly RATE_LIMIT: "RATE_LIMIT";
+    readonly TOOL_ERROR: "TOOL_ERROR";
+};
+
+interface FetchOptions extends RequestInit {
+    timeout?: number;
+}
+interface ResponseError {
+    status: number;
+    statusText: string;
+    data?: unknown;
+}
+interface RequestInterceptor {
+    (config: FetchOptions): FetchOptions | Promise<FetchOptions>;
+}
+interface ResponseInterceptor {
+    (response: Response): Response | Promise<Response>;
+}
+interface ErrorInterceptor {
+    (error: KBError): KBError | Promise<KBError>;
+}
+
+declare class HttpClient {
+    private client;
+    private requestInterceptors;
+    private responseInterceptors;
+    private errorInterceptors;
+    private baseUrl;
+    constructor(baseUrl?: string, token?: string);
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    addErrorInterceptor(interceptor: ErrorInterceptor): void;
+    getBaseUrl(): string;
+    fetch<T>(path: string, options?: AxiosRequestConfig): Promise<T>;
+    private processError;
+}
+
+declare function mapFetchError(error: unknown, response?: Response): KBError;
+/**
+ * Map error envelope to KBError
+ */
+declare function mapErrorEnvelope(envelope: ErrorEnvelope): KBError;
+
+/**
+ * @module @kb-labs/studio-data-client/client/envelope-interceptor
+ * Envelope interceptor for automatic unwrap of API responses
+ */
+
+/**
+ * Create envelope unwrap interceptor
+ * Automatically unwraps { ok: true, data: T } to T
+ */
+declare function createEnvelopeInterceptor(): ResponseInterceptor;
+/**
+ * Extract envelope metadata from response
+ */
+declare function extractEnvelopeMeta(response: Response): {
+    requestId?: string;
+    apiVersion?: string;
+    durationMs?: number;
+} | null;
+
+declare const SCHEMA_VERSION = "1.0";
+type ID = string;
+type ISODate = string;
+interface PackageRef {
+    name: string;
+    version?: string;
+    private?: boolean;
+    path?: string;
+}
+interface RunRef {
+    id: ID;
+    startedAt: ISODate;
+    endedAt?: ISODate;
+    status: 'pending' | 'ok' | 'warn' | 'fail';
+}
+interface ActionResult {
+    ok: boolean;
+    message?: string;
+    runId?: ID;
+}
+
+interface HealthStatus {
+    ok: boolean;
+    timestamp: ISODate;
+    sources: Array<{
+        name: string;
+        ok: boolean;
+        latency?: number;
+        error?: string;
+    }>;
+    snapshot?: ServiceObservabilityHealth;
+}
+
+type WorkflowStatus = 'queued' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'waiting_approval';
+interface StepRun {
+    id: string;
+    jobId: string;
+    name: string;
+    status: WorkflowStatus;
+    queuedAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    durationMs?: number;
+    command?: string;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: Record<string, unknown> | null;
+    spec?: {
+        name: string;
+        uses?: string;
+        with?: Record<string, unknown>;
+    };
+}
+interface JobRun {
+    id: string;
+    runId: string;
+    jobName: string;
+    status: WorkflowStatus;
+    runsOn: 'local' | 'sandbox';
+    queuedAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    durationMs?: number;
+    concurrency?: Record<string, unknown>;
+    retries?: Record<string, unknown>;
+    timeoutMs?: number;
+    artifacts: Record<string, unknown>;
+    steps: StepRun[];
+    error?: Record<string, unknown> | null;
+}
+interface WorkflowTrigger {
+    type: 'manual' | 'webhook' | 'push' | 'schedule';
+    actor?: string;
+    payload?: Record<string, unknown>;
+}
+interface WorkflowRun {
+    id: string;
+    name: string;
+    version: string;
+    status: WorkflowStatus;
+    createdAt: string;
+    queuedAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    durationMs?: number;
+    trigger: WorkflowTrigger;
+    jobs: JobRun[];
+    artifacts?: string[];
+    metadata?: Record<string, unknown>;
+    result?: WorkflowExecutionResult;
+}
+interface WorkflowSpec {
+    name: string;
+    version: string;
+    on?: Record<string, unknown>;
+    jobs: Record<string, unknown>;
+}
+interface WorkflowRunsListResponse {
+    runs: WorkflowRun[];
+    total: number;
+}
+interface WorkflowRunResponse {
+    run: WorkflowRun;
+}
+interface WorkflowLogEvent {
+    type: string;
+    runId: string;
+    jobId?: string;
+    stepId?: string;
+    payload?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface WorkflowResultMetrics {
+    timeMs?: number;
+    cpuMs?: number;
+    memMb?: number;
+    jobsTotal?: number;
+    jobsSucceeded?: number;
+    jobsFailed?: number;
+    jobsCancelled?: number;
+    stepsTotal?: number;
+    stepsFailed?: number;
+    stepsCancelled?: number;
+}
+interface WorkflowResultError {
+    message: string;
+    code?: string;
+    details?: Record<string, unknown>;
+}
+interface WorkflowExecutionResult {
+    status: WorkflowStatus;
+    summary?: string;
+    startedAt?: string;
+    completedAt?: string;
+    metrics?: WorkflowResultMetrics;
+    details?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: WorkflowResultError;
+}
+interface WorkflowPresenterEvent {
+    id: string;
+    type: string;
+    version: string;
+    timestamp: string;
+    payload?: unknown;
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/observability
+ * Observability contracts for Studio
+ */
+/**
+ * State Broker statistics
+ */
+interface StateBrokerStats {
+    /** Daemon uptime in milliseconds */
+    uptime: number;
+    /** Total number of cache entries */
+    totalEntries: number;
+    /** Total cache size in bytes */
+    totalSize: number;
+    /** Cache hit rate (0-1) */
+    hitRate: number;
+    /** Cache miss rate (0-1) */
+    missRate: number;
+    /** Number of evicted entries */
+    evictions: number;
+    /** Stats per namespace */
+    namespaces: Record<string, NamespaceStats>;
+}
+/**
+ * Namespace-level statistics
+ */
+interface NamespaceStats {
+    /** Number of entries */
+    entries: number;
+    /** Cache hits */
+    hits: number;
+    /** Cache misses */
+    misses: number;
+    /** Size in bytes */
+    size: number;
+}
+/**
+ * DevKit health snapshot
+ */
+interface DevKitHealth {
+    /** Health score (0-100) */
+    healthScore: number;
+    /** Letter grade (A-F) */
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    /** Issues breakdown */
+    issues: {
+        duplicateDeps?: number;
+        missingReadmes?: number;
+        typeErrors?: number;
+        brokenImports?: number;
+        unusedExports?: number;
+        [key: string]: number | undefined;
+    };
+    /** Total packages */
+    packages: number;
+    /** Average type coverage percentage */
+    avgTypeCoverage?: number;
+}
+/**
+ * Prometheus metrics from REST API
+ */
+interface PrometheusMetrics {
+    /** Request statistics */
+    requests: {
+        total: number;
+        success: number;
+        clientErrors: number;
+        serverErrors: number;
+    };
+    /** Latency statistics */
+    latency: {
+        average: number;
+        min: number;
+        max: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+    /** Per-plugin metrics */
+    perPlugin: Array<{
+        pluginId: string;
+    } & PluginMetrics>;
+    /** Per-tenant metrics */
+    perTenant: Array<{
+        tenantId: string;
+    } & TenantMetrics>;
+    /** Error breakdown */
+    errors: {
+        byStatusCode: Record<number, number>;
+        recent: Array<{
+            timestamp: number;
+            statusCode: number;
+            errorCode?: string;
+            message: string;
+        }>;
+    };
+    /** Timestamps */
+    timestamps: {
+        startTime: number;
+        lastRequest: number | null;
+    };
+    /** Redis statistics */
+    redis: {
+        updates: number;
+        healthyTransitions: number;
+        unhealthyTransitions: number;
+        lastStatus: {
+            healthy: boolean;
+            state: string;
+            role: string;
+        } | null;
+    };
+    /** Plugin mount snapshot */
+    pluginMounts: {
+        total: number;
+        succeeded: number;
+        failed: number;
+        elapsedMs: number;
+    } | null;
+    /** Uptime information */
+    uptime: {
+        seconds: number;
+        startTime: string;
+        lastRequest: string | null;
+    };
+}
+/**
+ * Plugin-level metrics
+ */
+interface PluginMetrics {
+    requests: number;
+    errors: number;
+    latency: {
+        average: number;
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Tenant-level metrics
+ */
+interface TenantMetrics {
+    requests: number;
+    errors: number;
+    latency: {
+        average: number;
+    };
+}
+/**
+ * System event from /events/registry SSE stream
+ */
+type SystemEvent = RegistryEvent | HealthEvent;
+/**
+ * Registry snapshot event
+ */
+interface RegistryEvent {
+    type: 'registry';
+    rev: string;
+    generatedAt: string;
+    partial: boolean;
+    stale: boolean;
+    expiresAt: string | null;
+    ttlMs: number | null;
+    checksum?: string;
+    checksumAlgorithm?: 'sha256';
+    previousChecksum: string | null;
+}
+/**
+ * Health status event
+ */
+interface HealthEvent {
+    type: 'health';
+    status: 'healthy' | 'unhealthy';
+    ts: string;
+    ready: boolean;
+    reason: string | null;
+    registryPartial: boolean;
+    registryStale: boolean;
+    registryLoaded: boolean;
+    pluginMountInProgress: boolean;
+    pluginRoutesMounted: boolean;
+    pluginsMounted: number;
+    pluginsFailed: number;
+    lastPluginMountTs: string | null;
+    pluginRoutesLastDurationMs: number | null;
+    redisEnabled: boolean;
+    redisHealthy: boolean;
+    redisStates?: Array<{
+        role: string;
+        state: string;
+    }>;
+}
+/**
+ * Log record (matches backend LogRecord interface)
+ */
+interface LogRecord {
+    id?: string;
+    time: string;
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    msg?: string;
+    plugin?: string;
+    command?: string;
+    executionId?: string;
+    tenantId?: string;
+    trace?: string;
+    span?: string;
+    err?: {
+        name: string;
+        message: string;
+        stack?: string;
+        code?: string;
+    };
+    meta?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Log query filters
+ */
+interface LogQuery {
+    from?: string;
+    to?: string;
+    level?: string;
+    plugin?: string;
+    executionId?: string;
+    tenantId?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Log query response
+ */
+interface LogQueryResponse {
+    ok: boolean;
+    data: {
+        logs: LogRecord[];
+        total: number;
+        filters: LogQuery;
+        bufferStats: {
+            size: number;
+            maxSize: number;
+            oldest?: string;
+            newest?: string;
+        };
+    };
+}
+/**
+ * Log event from /logs/stream SSE
+ */
+interface LogEvent {
+    type: 'log';
+    time: string;
+    level: LogRecord['level'];
+    msg?: string;
+    plugin?: string;
+    executionId?: string;
+    tenantId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Context options for AI summarization
+ */
+interface LogSummarizeContext {
+    errors?: boolean;
+    warnings?: boolean;
+    info?: boolean;
+    metadata?: boolean;
+    stackTraces?: boolean;
+}
+/**
+ * Log summarization request
+ */
+interface LogSummarizeRequest {
+    /** User's question about the logs */
+    question: string;
+    /** Context inclusion options */
+    includeContext?: LogSummarizeContext;
+    /** Time range filter */
+    timeRange?: {
+        from?: string;
+        to?: string;
+    };
+    /** Log filters */
+    filters?: {
+        level?: string;
+        plugin?: string;
+        traceId?: string;
+        executionId?: string;
+    };
+    /** Group logs by field */
+    groupBy?: 'trace' | 'execution' | 'plugin';
+}
+/**
+ * Log statistics for AI context
+ */
+interface LogStats {
+    total: number;
+    byLevel: Record<string, number>;
+    byPlugin: Record<string, number>;
+    topErrors: Array<{
+        message: string;
+        count: number;
+    }>;
+    timeRange: {
+        from: string | null;
+        to: string | null;
+    };
+}
+/**
+ * Log summarization response
+ */
+interface LogSummarizeResponse {
+    ok: boolean;
+    data: {
+        summary: {
+            question: string;
+            timeRange: {
+                from: string | null;
+                to: string | null;
+            };
+            total: number;
+            stats: LogStats;
+            groups: Record<string, any[]> | null;
+        };
+        /** AI-generated summary (null if LLM unavailable) */
+        aiSummary: string | null;
+        /** Info message if AI not available */
+        message?: string | null;
+    };
+}
+/**
+ * Historical data point for time-series metrics
+ */
+interface HistoricalDataPoint {
+    /** Unix timestamp in milliseconds */
+    timestamp: number;
+    /** Metric value */
+    value: number;
+}
+/**
+ * Heatmap cell data (7 days × 24 hours)
+ */
+interface HeatmapCell {
+    /** Day of week: 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' */
+    day: string;
+    /** Hour of day: 0-23 */
+    hour: number;
+    /** Aggregated metric value */
+    value: number;
+}
+/**
+ * Metrics history query options
+ */
+interface MetricsHistoryQuery {
+    /** Metric type */
+    metric: 'requests' | 'errors' | 'latency' | 'uptime';
+    /** Time range */
+    range: '1m' | '5m' | '10m' | '30m' | '1h';
+    /** Aggregation interval (optional) */
+    interval?: '5s' | '1m' | '5m';
+}
+/**
+ * Metrics heatmap query options
+ */
+interface MetricsHeatmapQuery {
+    /** Metric type */
+    metric: 'latency' | 'errors' | 'requests';
+    /** Number of days (optional, default: 7) */
+    days?: 7 | 14 | 30;
+}
+/**
+ * Incident severity levels
+ */
+type IncidentSeverity = 'critical' | 'warning' | 'info';
+/**
+ * Incident type categories
+ */
+type IncidentType = 'error_rate' | 'latency_spike' | 'plugin_failure' | 'adapter_failure' | 'system_health' | 'custom';
+/**
+ * Root cause analysis item
+ */
+interface RootCauseItem {
+    /** Factor contributing to the incident */
+    factor: string;
+    /** Confidence level (0.0 - 1.0) */
+    confidence: number;
+    /** Evidence supporting this root cause */
+    evidence: string;
+}
+/**
+ * Related logs data collected during incident
+ */
+interface RelatedLogsData {
+    errorCount: number;
+    warnCount: number;
+    timeRange: [number, number];
+    sampleErrors: string[];
+    topEndpoints?: Array<{
+        endpoint: string;
+        count: number;
+        sample: string;
+    }>;
+}
+/**
+ * Slow request details
+ */
+interface SlowRequest {
+    endpoint: string;
+    method: string;
+    durationMs: number;
+    statusCode?: number;
+}
+/**
+ * Related metrics data (before/during comparison)
+ */
+interface RelatedMetricsData {
+    before?: Record<string, number>;
+    during?: Record<string, number>;
+    topSlowest?: SlowRequest[];
+    affectedEndpoints?: string[];
+}
+/**
+ * Timeline event during incident
+ */
+interface TimelineEvent {
+    timestamp: number;
+    event: string;
+    source: 'detector' | 'logs' | 'metrics' | 'manual';
+}
+/**
+ * Related data gathered during incident detection
+ */
+interface RelatedData {
+    logs?: RelatedLogsData;
+    metrics?: RelatedMetricsData;
+    timeline?: TimelineEvent[];
+}
+/**
+ * AI-generated incident analysis
+ */
+interface IncidentAnalysis {
+    summary: string;
+    rootCauses: RootCauseItem[];
+    patterns: string[];
+    recommendations: string[];
+    analyzedAt: number;
+}
+/**
+ * Incident record
+ */
+interface Incident {
+    /** Unique incident identifier */
+    id: string;
+    /** Incident type */
+    type: IncidentType;
+    /** Severity level */
+    severity: IncidentSeverity;
+    /** Incident title/summary */
+    title: string;
+    /** Detailed description */
+    details: string;
+    /** Root cause analysis (optional) - array of contributing factors */
+    rootCause?: RootCauseItem[];
+    /** Affected services/plugins */
+    affectedServices?: string[];
+    /** Timestamp when incident occurred (Unix ms) */
+    timestamp: number;
+    /** Timestamp when incident was resolved (Unix ms) */
+    resolvedAt?: number;
+    /** Resolution notes */
+    resolutionNotes?: string;
+    /** Related metrics/logs */
+    metadata?: Record<string, unknown>;
+    /** Related data gathered during detection (NEW) */
+    relatedData?: RelatedData;
+    /** AI analysis results (NEW) */
+    aiAnalysis?: IncidentAnalysis;
+    /** When AI analysis was performed (NEW) */
+    aiAnalyzedAt?: number;
+}
+/**
+ * Incident query options
+ */
+interface IncidentQuery {
+    /** Maximum number of incidents to return (default: 50) */
+    limit?: number;
+    /** Filter by severity */
+    severity?: IncidentSeverity | IncidentSeverity[];
+    /** Filter by type */
+    type?: IncidentType | IncidentType[];
+    /** Filter by time range (from timestamp) */
+    from?: number;
+    /** Filter by time range (to timestamp) */
+    to?: number;
+    /** Include resolved incidents (default: false) */
+    includeResolved?: boolean;
+}
+/**
+ * Incident create payload
+ */
+interface IncidentCreatePayload {
+    type: IncidentType;
+    severity: IncidentSeverity;
+    title: string;
+    details: string;
+    rootCause?: RootCauseItem[];
+    affectedServices?: string[];
+    timestamp?: number;
+    metadata?: Record<string, unknown>;
+    relatedData?: RelatedData;
+}
+/**
+ * Incidents list response with summary stats
+ */
+interface IncidentsListResponse {
+    ok: boolean;
+    data: {
+        incidents: Incident[];
+        summary: {
+            total: number;
+            unresolved: number;
+            bySeverity: {
+                critical: number;
+                warning: number;
+                info: number;
+            };
+            showing: number;
+        };
+    };
+}
+/**
+ * Incident detail response
+ */
+interface IncidentDetailResponse {
+    ok: boolean;
+    data: Incident;
+}
+/**
+ * Incident analysis response
+ */
+interface IncidentAnalysisResponse {
+    ok: boolean;
+    data: IncidentAnalysis & {
+        cached: boolean;
+    };
+}
+/**
+ * Incident resolve request
+ */
+interface IncidentResolveRequest {
+    resolutionNotes?: string;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/adapters
+ * Platform adapter analytics contracts
+ */
+/**
+ * LLM usage statistics by model
+ */
+interface LLMModelStats {
+    requests: number;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cost: number;
+    costPer1KTokens: number;
+    tokensPerRequest: number;
+    errorRate: number;
+    avgDurationMs: number;
+    cacheReadTokens: number;
+    billableTokens: number;
+    cacheSavingsUsd: number;
+}
+/**
+ * LLM usage statistics response
+ */
+interface LLMUsageStats {
+    totalRequests: number;
+    totalTokens: number;
+    totalCost: number;
+    totalCacheReadTokens: number;
+    totalBillableTokens: number;
+    totalCacheSavingsUsd: number;
+    byModel: Record<string, LLMModelStats>;
+    errors: number;
+    timeRange: {
+        from: string;
+        to: string;
+    };
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/adapters-embeddings
+ * Embeddings adapter analytics contracts
+ */
+/**
+ * Embeddings usage statistics
+ */
+interface EmbeddingsUsageStats {
+    totalRequests: number;
+    totalTextLength: number;
+    totalCost: number;
+    errors: number;
+    avgDurationMs: number;
+    batchRequests: number;
+    singleRequests: number;
+    avgBatchSize: number;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/adapters-vectorstore
+ * VectorStore adapter analytics contracts
+ */
+/**
+ * VectorStore usage statistics
+ */
+interface VectorStoreUsageStats {
+    searchQueries: number;
+    upsertOperations: number;
+    deleteOperations: number;
+    avgSearchDuration: number;
+    avgSearchScore: number;
+    avgResultsCount: number;
+    totalVectorsUpserted: number;
+    totalVectorsDeleted: number;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/adapters-cache
+ * Cache adapter analytics contracts
+ */
+/**
+ * Cache usage statistics
+ */
+interface CacheUsageStats {
+    totalGets: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    sets: number;
+    avgGetDuration: number;
+    avgSetDuration: number;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/contracts/adapters-storage
+ * Storage adapter analytics contracts
+ */
+/**
+ * Storage usage statistics
+ */
+interface StorageUsageStats {
+    readOperations: number;
+    writeOperations: number;
+    deleteOperations: number;
+    totalBytesRead: number;
+    totalBytesWritten: number;
+    avgReadDuration: number;
+    avgWriteDuration: number;
+}
+
+declare const idSchema: z.ZodString;
+declare const isoDateSchema: z.ZodString;
+declare const packageRefSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    private: z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version?: string | undefined;
+    private?: boolean | undefined;
+    path?: string | undefined;
+}, {
+    name: string;
+    version?: string | undefined;
+    private?: boolean | undefined;
+    path?: string | undefined;
+}>;
+declare const runRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["pending", "ok", "warn", "fail"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "ok" | "pending" | "warn" | "fail";
+    id: string;
+    startedAt: string;
+    endedAt?: string | undefined;
+}, {
+    status: "ok" | "pending" | "warn" | "fail";
+    id: string;
+    startedAt: string;
+    endedAt?: string | undefined;
+}>;
+declare const actionResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    message?: string | undefined;
+    runId?: string | undefined;
+}, {
+    ok: boolean;
+    message?: string | undefined;
+    runId?: string | undefined;
+}>;
+
+declare const auditSummarySchema: z.ZodObject<{
+    ts: z.ZodString;
+    totals: z.ZodObject<{
+        packages: z.ZodNumber;
+        ok: z.ZodNumber;
+        warn: z.ZodNumber;
+        fail: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        ok: number;
+        warn: number;
+        fail: number;
+        packages: number;
+        durationMs: number;
+    }, {
+        ok: number;
+        warn: number;
+        fail: number;
+        packages: number;
+        durationMs: number;
+    }>;
+    topFailures: z.ZodArray<z.ZodObject<{
+        pkg: z.ZodString;
+        checks: z.ZodArray<z.ZodEnum<["style", "types", "tests", "build", "devlink", "mind"]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        pkg: string;
+        checks: ("style" | "types" | "tests" | "build" | "devlink" | "mind")[];
+    }, {
+        pkg: string;
+        checks: ("style" | "types" | "tests" | "build" | "devlink" | "mind")[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    ts: string;
+    totals: {
+        ok: number;
+        warn: number;
+        fail: number;
+        packages: number;
+        durationMs: number;
+    };
+    topFailures: {
+        pkg: string;
+        checks: ("style" | "types" | "tests" | "build" | "devlink" | "mind")[];
+    }[];
+}, {
+    ts: string;
+    totals: {
+        ok: number;
+        warn: number;
+        fail: number;
+        packages: number;
+        durationMs: number;
+    };
+    topFailures: {
+        pkg: string;
+        checks: ("style" | "types" | "tests" | "build" | "devlink" | "mind")[];
+    }[];
+}>;
+declare const auditCheckSchema: z.ZodObject<{
+    id: z.ZodEnum<["style", "types", "tests", "build", "devlink", "mind"]>;
+    ok: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodNumber>;
+    warnings: z.ZodOptional<z.ZodNumber>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+    meta?: unknown;
+    errors?: number | undefined;
+    warnings?: number | undefined;
+}, {
+    ok: boolean;
+    id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+    meta?: unknown;
+    errors?: number | undefined;
+    warnings?: number | undefined;
+}>;
+declare const auditPackageReportSchema: z.ZodObject<{
+    pkg: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        private: z.ZodOptional<z.ZodBoolean>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version?: string | undefined;
+        private?: boolean | undefined;
+        path?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        private?: boolean | undefined;
+        path?: string | undefined;
+    }>;
+    lastRun: z.ZodObject<{
+        id: z.ZodString;
+        startedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<["pending", "ok", "warn", "fail"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "ok" | "pending" | "warn" | "fail";
+        id: string;
+        startedAt: string;
+        endedAt?: string | undefined;
+    }, {
+        status: "ok" | "pending" | "warn" | "fail";
+        id: string;
+        startedAt: string;
+        endedAt?: string | undefined;
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<["style", "types", "tests", "build", "devlink", "mind"]>;
+        ok: z.ZodBoolean;
+        errors: z.ZodOptional<z.ZodNumber>;
+        warnings: z.ZodOptional<z.ZodNumber>;
+        meta: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        ok: boolean;
+        id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+        meta?: unknown;
+        errors?: number | undefined;
+        warnings?: number | undefined;
+    }, {
+        ok: boolean;
+        id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+        meta?: unknown;
+        errors?: number | undefined;
+        warnings?: number | undefined;
+    }>, "many">;
+    artifacts: z.ZodObject<{
+        json: z.ZodOptional<z.ZodString>;
+        md: z.ZodOptional<z.ZodString>;
+        txt: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        json?: string | undefined;
+        md?: string | undefined;
+        txt?: string | undefined;
+        html?: string | undefined;
+    }, {
+        json?: string | undefined;
+        md?: string | undefined;
+        txt?: string | undefined;
+        html?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    pkg: {
+        name: string;
+        version?: string | undefined;
+        private?: boolean | undefined;
+        path?: string | undefined;
+    };
+    checks: {
+        ok: boolean;
+        id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+        meta?: unknown;
+        errors?: number | undefined;
+        warnings?: number | undefined;
+    }[];
+    lastRun: {
+        status: "ok" | "pending" | "warn" | "fail";
+        id: string;
+        startedAt: string;
+        endedAt?: string | undefined;
+    };
+    artifacts: {
+        json?: string | undefined;
+        md?: string | undefined;
+        txt?: string | undefined;
+        html?: string | undefined;
+    };
+}, {
+    pkg: {
+        name: string;
+        version?: string | undefined;
+        private?: boolean | undefined;
+        path?: string | undefined;
+    };
+    checks: {
+        ok: boolean;
+        id: "style" | "types" | "tests" | "build" | "devlink" | "mind";
+        meta?: unknown;
+        errors?: number | undefined;
+        warnings?: number | undefined;
+    }[];
+    lastRun: {
+        status: "ok" | "pending" | "warn" | "fail";
+        id: string;
+        startedAt: string;
+        endedAt?: string | undefined;
+    };
+    artifacts: {
+        json?: string | undefined;
+        md?: string | undefined;
+        txt?: string | undefined;
+        html?: string | undefined;
+    };
+}>;
+
+declare const releasePreviewSchema: z.ZodObject<{
+    range: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>;
+    packages: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        prev: z.ZodString;
+        next: z.ZodString;
+        bump: z.ZodEnum<["major", "minor", "patch", "none"]>;
+        breaking: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        prev: string;
+        next: string;
+        bump: "patch" | "major" | "minor" | "none";
+        breaking?: number | undefined;
+    }, {
+        name: string;
+        prev: string;
+        next: string;
+        bump: "patch" | "major" | "minor" | "none";
+        breaking?: number | undefined;
+    }>, "many">;
+    manifestJson: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    packages: {
+        name: string;
+        prev: string;
+        next: string;
+        bump: "patch" | "major" | "minor" | "none";
+        breaking?: number | undefined;
+    }[];
+    range: {
+        from: string;
+        to: string;
+    };
+    manifestJson?: string | undefined;
+    markdown?: string | undefined;
+}, {
+    packages: {
+        name: string;
+        prev: string;
+        next: string;
+        bump: "patch" | "major" | "minor" | "none";
+        breaking?: number | undefined;
+    }[];
+    range: {
+        from: string;
+        to: string;
+    };
+    manifestJson?: string | undefined;
+    markdown?: string | undefined;
+}>;
+
+declare const healthStatusSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    timestamp: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ok: z.ZodBoolean;
+        latency: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        ok: boolean;
+        name: string;
+        error?: string | undefined;
+        latency?: number | undefined;
+    }, {
+        ok: boolean;
+        name: string;
+        error?: string | undefined;
+        latency?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    timestamp: string;
+    sources: {
+        ok: boolean;
+        name: string;
+        error?: string | undefined;
+        latency?: number | undefined;
+    }[];
+}, {
+    ok: boolean;
+    timestamp: string;
+    sources: {
+        ok: boolean;
+        name: string;
+        error?: string | undefined;
+        latency?: number | undefined;
+    }[];
+}>;
+
+interface RouteInfo {
+    method: string;
+    url: string;
+}
+interface RoutesResponse {
+    schema: string;
+    ts: string;
+    count: number;
+    routes: RouteInfo[];
+    raw?: string;
+}
+interface SystemDataSource {
+    getHealth(): Promise<HealthStatus>;
+    getReady?(): Promise<ReadyResponse | NotReadyResponse>;
+    getInfo?(): Promise<SystemInfoPayload>;
+    getCapabilities?(): Promise<SystemCapabilitiesPayload>;
+    getConfig?(): Promise<SystemConfigPayload>;
+    /** Get all registered API routes */
+    getRoutes(): Promise<RoutesResponse>;
+    /** Get the base URL of the API (e.g., http://localhost:5050/api/v1) */
+    getBaseUrl(): string;
+}
+
+interface WorkflowRunsFilters {
+    status?: string;
+    limit?: number;
+}
+interface WorkflowRunParams {
+    spec: WorkflowSpec;
+    idempotencyKey?: string;
+    concurrencyGroup?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DashboardStatsResponse {
+    workflows: {
+        total: number;
+        active: number;
+        inactive: number;
+    };
+    jobs: {
+        running: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    };
+    crons: {
+        total: number;
+        enabled: number;
+        disabled: number;
+    };
+    activeExecutions: Array<{
+        id: string;
+        type: string;
+        workflowName?: string;
+        status: 'running';
+        progress?: number;
+        progressMessage?: string;
+        startedAt: string;
+        durationMs?: number;
+    }>;
+    recentActivity: Array<{
+        id: string;
+        type: string;
+        workflowName?: string;
+        status: 'completed' | 'failed' | 'cancelled';
+        finishedAt: string;
+        durationMs?: number;
+        error?: string;
+    }>;
+}
+interface WorkflowInfo {
+    id: string;
+    name: string;
+    description?: string;
+    source: 'manifest' | 'standalone';
+    pluginId?: string;
+    status?: 'active' | 'inactive';
+    tags?: string[];
+    inputs?: Record<string, {
+        type: 'string' | 'number' | 'boolean';
+        description?: string;
+        required?: boolean;
+        default?: unknown;
+    }>;
+}
+interface WorkflowListResponse {
+    workflows: WorkflowInfo[];
+}
+interface JobStatusInfo {
+    id: string;
+    type: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    tenantId?: string;
+    priority?: number;
+    createdAt?: Date | string;
+    startedAt?: Date | string;
+    finishedAt?: Date | string;
+    attempt?: number;
+    maxRetries?: number;
+    result?: unknown;
+    error?: string;
+    progress?: number;
+    progressMessage?: string;
+}
+interface JobListFilter {
+    type?: string;
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    limit?: number;
+    offset?: number;
+}
+interface JobListResponse {
+    jobs: JobStatusInfo[];
+}
+interface JobStepInfo {
+    name: string;
+    handler?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    progress?: number;
+    startedAt?: string;
+    finishedAt?: string;
+    durationMs?: number;
+    error?: string;
+    output?: unknown;
+}
+interface JobStepsResponse {
+    jobId: string;
+    workflowName?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    steps: JobStepInfo[];
+    currentStep?: number;
+}
+interface JobLogsResponse {
+    jobId: string;
+    logs: Array<{
+        timestamp: string;
+        level: 'info' | 'warn' | 'error' | 'debug';
+        message: string;
+        context?: Record<string, unknown>;
+    }>;
+    total: number;
+    hasMore: boolean;
+}
+interface CronInfo {
+    id: string;
+    schedule: string;
+    jobType: string;
+    timezone?: string;
+    enabled: boolean;
+    lastRun?: Date | string;
+    nextRun?: Date | string;
+    pluginId?: string;
+}
+interface CronListResponse {
+    crons: CronInfo[];
+}
+interface WorkflowRunInfo {
+    id: string;
+    workflowId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    trigger: {
+        type: 'manual' | 'api' | 'cron';
+        user?: string;
+    };
+    startedAt: string;
+    finishedAt?: string;
+    durationMs?: number;
+    error?: string;
+}
+interface WorkflowRunHistoryResponse {
+    workflowId: string;
+    runs: WorkflowRunInfo[];
+    total: number;
+}
+interface PendingApproval {
+    jobId: string;
+    stepId: string;
+    stepName: string;
+    specId?: string;
+    context: Record<string, unknown>;
+    waitingSince?: string;
+}
+interface PendingApprovalsResponse {
+    runId: string;
+    pending: PendingApproval[];
+}
+interface ResolveApprovalParams {
+    runId: string;
+    jobId: string;
+    stepId: string;
+    action: 'approve' | 'reject';
+    comment?: string;
+    data?: Record<string, unknown>;
+}
+interface WorkflowDataSource {
+    listRuns(filters?: WorkflowRunsFilters): Promise<WorkflowRunsListResponse>;
+    getRun(runId: string): Promise<WorkflowRun | null>;
+    cancelRun(runId: string): Promise<WorkflowRun>;
+    runWorkflow?(params: WorkflowRunParams): Promise<WorkflowRun>;
+    getPendingApprovals?(runId: string): Promise<PendingApprovalsResponse>;
+    resolveApproval?(params: ResolveApprovalParams): Promise<{
+        resolved: boolean;
+    }>;
+    listEvents?(runId: string, options?: {
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<{
+        events: WorkflowPresenterEvent[];
+        cursor: string | null;
+    }>;
+    getStats(): Promise<DashboardStatsResponse>;
+    listWorkflows(filters?: {
+        limit?: number;
+    }): Promise<WorkflowListResponse>;
+    getWorkflow(workflowId: string): Promise<WorkflowInfo | null>;
+    runWorkflowById(workflowId: string, input?: Record<string, unknown>): Promise<{
+        runId: string;
+        status: string;
+    }>;
+    listJobs(filters?: JobListFilter): Promise<JobListResponse>;
+    getJob(jobId: string): Promise<JobStatusInfo | null>;
+    getJobSteps(jobId: string): Promise<JobStepsResponse>;
+    getJobLogs(jobId: string, filters?: {
+        limit?: number;
+        offset?: number;
+        level?: string;
+    }): Promise<JobLogsResponse>;
+    listCronJobs(): Promise<CronListResponse>;
+    getWorkflowRuns(workflowId: string, filters?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<WorkflowRunHistoryResponse>;
+    cancelWorkflowRun(runId: string): Promise<{
+        cancelled: boolean;
+        runId: string;
+    }>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/cache-source
+ * Cache management data source
+ */
+/**
+ * Cache invalidation result
+ */
+interface CacheInvalidationResult {
+    invalidated: boolean;
+    timestamp: string;
+    previousRev: number | null;
+    newRev: number;
+    pluginsDiscovered: number;
+}
+/**
+ * Cache data source interface
+ */
+interface CacheDataSource {
+    /**
+     * Invalidate cache and force re-discovery
+     */
+    invalidateCache(): Promise<CacheInvalidationResult>;
+}
+
+/**
+ * Observability data source interface
+ */
+interface ObservabilityDataSource {
+    /**
+     * Get State Broker statistics
+     */
+    getStateBrokerStats(): Promise<StateBrokerStats>;
+    /**
+     * Get DevKit health snapshot
+     */
+    getDevKitHealth(): Promise<DevKitHealth>;
+    /**
+     * Get Prometheus metrics from REST API
+     */
+    getPrometheusMetrics(): Promise<PrometheusMetrics>;
+    /**
+     * Subscribe to system events SSE stream
+     * Returns cleanup function
+     */
+    subscribeToSystemEvents(onEvent: (event: SystemEvent) => void, onError: (error: Error) => void): () => void;
+    /**
+     * Query logs with filters
+     */
+    queryLogs(filters: LogQuery): Promise<LogQueryResponse>;
+    /**
+     * Subscribe to live log stream
+     * Returns cleanup function
+     */
+    subscribeToLogs(onLog: (log: LogRecord) => void, onError: (error: Error) => void, filters?: LogQuery): () => void;
+    /**
+     * Get AI-powered log summarization
+     */
+    summarizeLogs(request: LogSummarizeRequest): Promise<LogSummarizeResponse>;
+    /**
+     * Get single log by ID with optional related logs
+     */
+    getLog(id: string, includeRelated?: boolean): Promise<{
+        log: LogRecord;
+        related?: LogRecord[];
+    }>;
+    /**
+     * Get logs related to a specific log (same trace/execution/request)
+     */
+    getRelatedLogs(id: string): Promise<{
+        total: number;
+        logs: LogRecord[];
+        correlationKeys: any;
+    }>;
+    /**
+     * Get historical metrics time-series data
+     */
+    getMetricsHistory(query: MetricsHistoryQuery): Promise<HistoricalDataPoint[]>;
+    /**
+     * Get metrics heatmap data (7 days × 24 hours)
+     */
+    getMetricsHeatmap(query: MetricsHeatmapQuery): Promise<HeatmapCell[]>;
+    /**
+     * Query incident history (DEPRECATED - use listIncidents)
+     */
+    queryIncidents(query?: IncidentQuery): Promise<Incident[]>;
+    /**
+     * Create a new incident
+     */
+    createIncident(payload: IncidentCreatePayload): Promise<Incident>;
+    /**
+     * Resolve an incident
+     */
+    resolveIncident(id: string, resolutionNotes?: string): Promise<Incident>;
+    /**
+     * List incidents with filters and summary stats (NEW)
+     */
+    listIncidents(query?: IncidentQuery): Promise<IncidentsListResponse>;
+    /**
+     * Get incident details by ID (NEW)
+     */
+    getIncident(id: string): Promise<IncidentDetailResponse>;
+    /**
+     * Analyze incident with AI (NEW)
+     */
+    analyzeIncident(id: string): Promise<IncidentAnalysisResponse>;
+    /**
+     * Chat with AI insights
+     */
+    chatWithInsights(question: string, context?: {
+        includeMetrics?: boolean;
+        includeIncidents?: boolean;
+        includeHistory?: boolean;
+        timeRange?: '1h' | '6h' | '24h' | '7d';
+        plugins?: string[];
+    }): Promise<{
+        answer: string;
+        context: string[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/analytics-source
+ * Analytics data source interface
+ */
+
+/**
+ * Analytics data source interface
+ */
+interface AnalyticsDataSource {
+    /**
+     * Get analytics events
+     */
+    getEvents(query?: EventsQuery): Promise<EventsResponse>;
+    /**
+     * Get aggregated statistics
+     */
+    getStats(): Promise<EventsStats>;
+    /**
+     * Get buffer status (if applicable)
+     */
+    getBufferStatus(): Promise<BufferStatus | null>;
+    /**
+     * Get DLQ status (if applicable)
+     */
+    getDlqStatus(): Promise<DlqStatus | null>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/adapters-source
+ * Platform adapter analytics data source interface
+ */
+
+/**
+ * Date range and aggregation options for analytics queries
+ */
+interface DateRangeOptions {
+    /** Start date (ISO 8601 timestamp) */
+    from?: string;
+    /** End date (ISO 8601 timestamp) */
+    to?: string;
+    /**
+     * Optional model filter (LLM analytics only, legacy).
+     * Prefer breakdownBy='payload.model' for universal breakdown support.
+     */
+    models?: string | string[];
+    /**
+     * Time bucket granularity. Default: 'day'.
+     * Controls the format of DailyStats.date in the response.
+     */
+    groupBy?: 'hour' | 'day' | 'week' | 'month';
+    /**
+     * Dot-notation path to split results by (e.g. 'payload.model', 'payload.tier').
+     * When specified, each time bucket returns multiple rows — one per unique value.
+     * Rows include a `breakdown` field with the field value.
+     * Adapters that don't support this silently return data without breakdown.
+     */
+    breakdownBy?: string;
+    /**
+     * Specific metric field names to aggregate (e.g. ['totalCost', 'totalTokens']).
+     * When omitted, adapters return all known metrics for the event type.
+     */
+    metrics?: string[];
+}
+/**
+ * Daily aggregated statistics for time-series charts
+ */
+interface DailyStats {
+    /**
+     * Bucket key — format depends on groupBy:
+     * 'YYYY-MM-DD' (day, default), 'YYYY-MM-DDTHH' (hour), 'YYYY-WXX' (week), 'YYYY-MM' (month)
+     */
+    date: string;
+    /** Number of events in this bucket */
+    count: number;
+    /** Event-specific metrics (e.g., totalTokens, totalCost, avgDurationMs) */
+    metrics?: Record<string, number>;
+    /**
+     * Present when DateRangeOptions.breakdownBy is specified.
+     * The value of the breakdown field for this row.
+     */
+    breakdown?: string;
+}
+/**
+ * Platform adapter analytics data source
+ */
+interface AdaptersDataSource {
+    /**
+     * Get LLM usage statistics
+     * @param options - Optional date range filter
+     */
+    getLLMUsage(options?: DateRangeOptions): Promise<LLMUsageStats>;
+    /**
+     * Get Embeddings usage statistics
+     * @param options - Optional date range filter
+     */
+    getEmbeddingsUsage(options?: DateRangeOptions): Promise<EmbeddingsUsageStats>;
+    /**
+     * Get VectorStore usage statistics
+     * @param options - Optional date range filter
+     */
+    getVectorStoreUsage(options?: DateRangeOptions): Promise<VectorStoreUsageStats>;
+    /**
+     * Get Cache usage statistics
+     * @param options - Optional date range filter
+     */
+    getCacheUsage(options?: DateRangeOptions): Promise<CacheUsageStats>;
+    /**
+     * Get Storage usage statistics
+     * @param options - Optional date range filter
+     */
+    getStorageUsage(options?: DateRangeOptions): Promise<StorageUsageStats>;
+    /**
+     * Get daily aggregated LLM statistics for time-series charts
+     * @param options - Optional date range filter
+     */
+    getLLMDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    /**
+     * Get daily aggregated Embeddings statistics for time-series charts
+     * @param options - Optional date range filter
+     */
+    getEmbeddingsDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    /**
+     * Get daily aggregated VectorStore statistics for time-series charts
+     * @param options - Optional date range filter
+     */
+    getVectorStoreDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    /**
+     * Get daily aggregated Cache statistics for time-series charts
+     * @param options - Optional date range filter
+     */
+    getCacheDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    /**
+     * Get daily aggregated Storage statistics for time-series charts
+     * @param options - Optional date range filter
+     */
+    getStorageDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/platform-source
+ * Platform configuration data source contract
+ */
+
+/**
+ * Platform configuration data source
+ */
+interface PlatformDataSource {
+    /**
+     * Get platform configuration (adapters, options, execution mode)
+     */
+    getConfig(): Promise<PlatformConfigPayload>;
+}
+
+/**
+ * Plugin registry data source interface
+ */
+
+interface PluginSource {
+    /** Source kind (workspace, npm, etc.) */
+    kind: string;
+    /** Source path or location */
+    path: string;
+}
+interface PluginManifestEntry {
+    /** Plugin ID (@scope/name) */
+    pluginId: string;
+    /** Full plugin manifest */
+    manifest: ManifestV3;
+    /** Absolute path to plugin root directory */
+    pluginRoot: string;
+    /** Source of the plugin */
+    source: string | PluginSource;
+    /** When the plugin was discovered (ISO timestamp) */
+    discoveredAt?: string;
+    /** When the plugin's dist/ was last built (ISO timestamp) */
+    buildTimestamp?: string;
+    /** Manifest validation result */
+    validation?: {
+        /** Whether the manifest is valid */
+        valid: boolean;
+        /** Validation errors (if any) */
+        errors: string[];
+    };
+}
+interface PluginsRegistryResponse {
+    /** List of discovered plugin manifests */
+    manifests: PluginManifestEntry[];
+    /** Base path for all REST API routes (e.g., /api/v1) */
+    apiBasePath?: string;
+}
+interface PluginAskRequest {
+    /** The question to ask about the plugin */
+    question: string;
+}
+interface PluginAskResponse {
+    /** LLM's answer */
+    answer: string;
+    /** Token usage */
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+/**
+ * Data source for plugin registry operations
+ */
+interface PluginsDataSource {
+    /**
+     * Get all discovered plugins with their manifests
+     */
+    getPlugins(): Promise<PluginsRegistryResponse>;
+    /**
+     * Ask AI a question about a specific plugin
+     */
+    askAboutPlugin(pluginId: string, request: PluginAskRequest): Promise<PluginAskResponse>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-system-source
+ * HTTP implementation of SystemDataSource
+ */
+
+/**
+ * HTTP implementation of SystemDataSource
+ */
+declare class HttpSystemSource implements SystemDataSource {
+    private client;
+    constructor(client: HttpClient);
+    getHealth(): Promise<HealthStatus>;
+    /**
+     * Get ready status
+     */
+    getReady(): Promise<ReadyResponse | NotReadyResponse>;
+    /**
+     * Get info
+     */
+    getInfo(): Promise<SystemInfoPayload>;
+    /**
+     * Get capabilities
+     */
+    getCapabilities(): Promise<SystemCapabilitiesPayload>;
+    /**
+     * Get config (redacted)
+     */
+    getConfig(): Promise<SystemConfigPayload>;
+    /**
+     * Get all registered API routes
+     */
+    getRoutes(): Promise<RoutesResponse>;
+    /**
+     * Get the base URL of the API
+     */
+    getBaseUrl(): string;
+}
+
+declare class HttpWorkflowSource implements WorkflowDataSource {
+    private readonly client;
+    constructor(client: HttpClient);
+    listRuns(filters?: WorkflowRunsFilters): Promise<WorkflowRunsListResponse>;
+    getRun(runId: string): Promise<WorkflowRun | null>;
+    cancelRun(runId: string): Promise<WorkflowRun>;
+    runWorkflow(params: WorkflowRunParams): Promise<WorkflowRun>;
+    listEvents(runId: string, options?: {
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<{
+        events: WorkflowPresenterEvent[];
+        cursor: string | null;
+    }>;
+    getStats(): Promise<DashboardStatsResponse>;
+    listWorkflows(filters?: {
+        limit?: number;
+    }): Promise<WorkflowListResponse>;
+    getWorkflow(workflowId: string): Promise<WorkflowInfo | null>;
+    runWorkflowById(workflowId: string, input?: Record<string, unknown>): Promise<{
+        runId: string;
+        status: string;
+    }>;
+    listJobs(filters?: JobListFilter): Promise<JobListResponse>;
+    getJob(jobId: string): Promise<JobStatusInfo | null>;
+    getJobSteps(jobId: string): Promise<JobStepsResponse>;
+    getJobLogs(jobId: string, filters?: {
+        limit?: number;
+        offset?: number;
+        level?: string;
+    }): Promise<JobLogsResponse>;
+    listCronJobs(): Promise<CronListResponse>;
+    getPendingApprovals(runId: string): Promise<PendingApprovalsResponse>;
+    resolveApproval(params: ResolveApprovalParams): Promise<{
+        resolved: boolean;
+    }>;
+    cancelWorkflowRun(runId: string): Promise<{
+        cancelled: boolean;
+        runId: string;
+    }>;
+    getWorkflowRuns(workflowId: string, filters?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<WorkflowRunHistoryResponse>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-cache-source
+ * HTTP implementation of CacheDataSource
+ */
+
+/**
+ * HTTP implementation of CacheDataSource
+ */
+declare class HttpCacheSource implements CacheDataSource {
+    private client;
+    constructor(client: HttpClient);
+    invalidateCache(): Promise<CacheInvalidationResult>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-observability-source
+ * HTTP implementation of ObservabilityDataSource
+ */
+
+/**
+ * HTTP implementation of ObservabilityDataSource
+ */
+declare class HttpObservabilitySource implements ObservabilityDataSource {
+    private client;
+    constructor(client: HttpClient);
+    getStateBrokerStats(): Promise<StateBrokerStats>;
+    getDevKitHealth(): Promise<DevKitHealth>;
+    getPrometheusMetrics(): Promise<PrometheusMetrics>;
+    subscribeToSystemEvents(onEvent: (event: SystemEvent) => void, onError: (error: Error) => void): () => void;
+    queryLogs(filters: LogQuery): Promise<LogQueryResponse>;
+    subscribeToLogs(onLog: (log: LogRecord) => void, onError: (error: Error) => void, filters?: LogQuery): () => void;
+    summarizeLogs(request: LogSummarizeRequest): Promise<LogSummarizeResponse>;
+    getLog(id: string, includeRelated?: boolean): Promise<{
+        log: LogRecord;
+        related?: LogRecord[];
+    }>;
+    getRelatedLogs(id: string): Promise<{
+        total: number;
+        logs: LogRecord[];
+        correlationKeys: any;
+    }>;
+    getMetricsHistory(query: MetricsHistoryQuery): Promise<HistoricalDataPoint[]>;
+    getMetricsHeatmap(query: MetricsHeatmapQuery): Promise<HeatmapCell[]>;
+    queryIncidents(query?: IncidentQuery): Promise<Incident[]>;
+    createIncident(payload: IncidentCreatePayload): Promise<Incident>;
+    resolveIncident(id: string, resolutionNotes?: string): Promise<Incident>;
+    listIncidents(query?: IncidentQuery): Promise<IncidentsListResponse>;
+    getIncident(id: string): Promise<IncidentDetailResponse>;
+    analyzeIncident(id: string): Promise<IncidentAnalysisResponse>;
+    chatWithInsights(question: string, context?: {
+        includeMetrics?: boolean;
+        includeIncidents?: boolean;
+        includeHistory?: boolean;
+        timeRange?: '1h' | '6h' | '24h' | '7d';
+        plugins?: string[];
+    }): Promise<{
+        answer: string;
+        context: string[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-analytics-source
+ * HTTP implementation of AnalyticsDataSource
+ */
+
+/**
+ * HTTP implementation of AnalyticsDataSource
+ * Calls REST API /v1/analytics/* endpoints
+ */
+declare class HttpAnalyticsSource implements AnalyticsDataSource {
+    private readonly client;
+    constructor(client: HttpClient);
+    getEvents(query?: EventsQuery): Promise<EventsResponse>;
+    getStats(): Promise<EventsStats>;
+    getBufferStatus(): Promise<BufferStatus | null>;
+    getDlqStatus(): Promise<DlqStatus | null>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-adapters-source
+ * HTTP implementation of AdaptersDataSource
+ */
+
+/**
+ * HTTP implementation of AdaptersDataSource
+ * Calls REST API /v1/adapters/* endpoints
+ */
+declare class HttpAdaptersSource implements AdaptersDataSource {
+    private readonly client;
+    constructor(client: HttpClient);
+    /**
+     * Build query string from date range options
+     */
+    private buildQueryString;
+    getLLMUsage(options?: DateRangeOptions): Promise<LLMUsageStats>;
+    getEmbeddingsUsage(options?: DateRangeOptions): Promise<EmbeddingsUsageStats>;
+    getVectorStoreUsage(options?: DateRangeOptions): Promise<VectorStoreUsageStats>;
+    getCacheUsage(options?: DateRangeOptions): Promise<CacheUsageStats>;
+    getStorageUsage(options?: DateRangeOptions): Promise<StorageUsageStats>;
+    getLLMDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    getEmbeddingsDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    getVectorStoreDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    getCacheDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+    getStorageDailyStats(options?: DateRangeOptions): Promise<DailyStats[]>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/sources/http-platform-source
+ * HTTP implementation of PlatformDataSource
+ */
+
+/**
+ * HTTP implementation of PlatformDataSource
+ */
+declare class HttpPlatformSource implements PlatformDataSource {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * Get platform configuration
+     */
+    getConfig(): Promise<PlatformConfigPayload>;
+}
+
+/**
+ * HTTP implementation of PluginsDataSource
+ */
+
+declare class HttpPluginsSource implements PluginsDataSource {
+    private readonly client;
+    constructor(client: HttpClient);
+    getPlugins(): Promise<PluginsRegistryResponse>;
+    askAboutPlugin(pluginId: string, request: PluginAskRequest): Promise<PluginAskResponse>;
+}
+
+declare class MockSystemSource implements SystemDataSource {
+    getHealth(): Promise<HealthStatus>;
+    getRoutes(): Promise<RoutesResponse>;
+    getBaseUrl(): string;
+}
+
+declare class MockWorkflowSource implements WorkflowDataSource {
+    private runs;
+    listRuns(_filters?: WorkflowRunsFilters): Promise<{
+        runs: WorkflowRun[];
+        total: number;
+    }>;
+    getRun(runId: string): Promise<WorkflowRun | null>;
+    cancelRun(runId: string): Promise<WorkflowRun>;
+    runWorkflow(params: WorkflowRunParams): Promise<WorkflowRun>;
+    listEvents(): Promise<{
+        events: never[];
+        cursor: null;
+    }>;
+    getStats(): Promise<DashboardStatsResponse>;
+    listWorkflows(_filters?: {
+        limit?: number;
+    }): Promise<WorkflowListResponse>;
+    getWorkflow(workflowId: string): Promise<WorkflowInfo | null>;
+    runWorkflowById(workflowId: string, _input?: Record<string, unknown>): Promise<{
+        runId: string;
+        status: string;
+    }>;
+    listJobs(filters?: JobListFilter): Promise<JobListResponse>;
+    getJob(jobId: string): Promise<JobStatusInfo | null>;
+    getJobSteps(jobId: string): Promise<JobStepsResponse>;
+    getJobLogs(jobId: string, _filters?: {
+        limit?: number;
+        offset?: number;
+        level?: string;
+    }): Promise<JobLogsResponse>;
+    listCronJobs(): Promise<CronListResponse>;
+    cancelWorkflowRun(runId: string): Promise<{
+        cancelled: boolean;
+        runId: string;
+    }>;
+    getWorkflowRuns(workflowId: string, _filters?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<WorkflowRunHistoryResponse>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/mocks/mock-cache-source
+ * Mock implementation of CacheDataSource
+ */
+
+/**
+ * Mock implementation of CacheDataSource
+ */
+declare class MockCacheSource implements CacheDataSource {
+    invalidateCache(): Promise<CacheInvalidationResult>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/mocks/mock-observability-source
+ * Mock implementation of ObservabilityDataSource
+ */
+
+/**
+ * Mock implementation of ObservabilityDataSource
+ *
+ * Returns deterministic mock data for development and testing
+ */
+declare class MockObservabilitySource implements ObservabilityDataSource {
+    getStateBrokerStats(): Promise<StateBrokerStats>;
+    getDevKitHealth(): Promise<DevKitHealth>;
+    getPrometheusMetrics(): Promise<PrometheusMetrics>;
+    queryLogs(filters: LogQuery): Promise<LogQueryResponse>;
+    subscribeToSystemEvents(onEvent: (event: SystemEvent) => void, _onError: (error: Error) => void): () => void;
+    subscribeToLogs(onLog: (log: LogRecord) => void, _onError: (error: Error) => void, filters?: LogQuery): () => void;
+    getLog(_id: string, includeRelated?: boolean): Promise<{
+        log: LogRecord;
+        related?: LogRecord[];
+    }>;
+    getRelatedLogs(_id: string): Promise<{
+        total: number;
+        logs: LogRecord[];
+        correlationKeys: any;
+    }>;
+    summarizeLogs(request: LogSummarizeRequest): Promise<LogSummarizeResponse>;
+    getMetricsHistory(query: MetricsHistoryQuery): Promise<HistoricalDataPoint[]>;
+    getMetricsHeatmap(query: MetricsHeatmapQuery): Promise<HeatmapCell[]>;
+    queryIncidents(query?: IncidentQuery): Promise<Incident[]>;
+    createIncident(payload: IncidentCreatePayload): Promise<Incident>;
+    resolveIncident(_id: string, resolutionNotes?: string): Promise<Incident>;
+    listIncidents(query?: IncidentQuery): Promise<IncidentsListResponse>;
+    getIncident(_id: string): Promise<IncidentDetailResponse>;
+    analyzeIncident(_id: string): Promise<IncidentAnalysisResponse>;
+    chatWithInsights(question: string, context?: {
+        includeMetrics?: boolean;
+        includeIncidents?: boolean;
+        includeHistory?: boolean;
+        timeRange?: '1h' | '6h' | '24h' | '7d';
+        plugins?: string[];
+    }): Promise<{
+        answer: string;
+        context: string[];
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/mocks/mock-analytics-source
+ * Mock implementation of AnalyticsDataSource
+ */
+
+/**
+ * Mock implementation of AnalyticsDataSource
+ * Returns deterministic mock data for development and testing
+ */
+declare class MockAnalyticsSource implements AnalyticsDataSource {
+    private mockEvents;
+    constructor();
+    private generateMockEvents;
+    getEvents(query?: EventsQuery): Promise<EventsResponse>;
+    getStats(): Promise<EventsStats>;
+    getBufferStatus(): Promise<BufferStatus | null>;
+    getDlqStatus(): Promise<DlqStatus | null>;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/mocks/mock-adapters-source
+ * Mock implementation of AdaptersDataSource
+ */
+
+/**
+ * Mock adapters data source for testing
+ */
+declare class MockAdaptersSource implements AdaptersDataSource {
+    getLLMUsage(_options?: DateRangeOptions): Promise<LLMUsageStats>;
+    getEmbeddingsUsage(_options?: DateRangeOptions): Promise<EmbeddingsUsageStats>;
+    getVectorStoreUsage(_options?: DateRangeOptions): Promise<VectorStoreUsageStats>;
+    getCacheUsage(_options?: DateRangeOptions): Promise<CacheUsageStats>;
+    getStorageUsage(_options?: DateRangeOptions): Promise<StorageUsageStats>;
+    getLLMDailyStats(_options?: DateRangeOptions): Promise<DailyStats[]>;
+    getEmbeddingsDailyStats(_options?: DateRangeOptions): Promise<DailyStats[]>;
+    getVectorStoreDailyStats(_options?: DateRangeOptions): Promise<DailyStats[]>;
+    getCacheDailyStats(_options?: DateRangeOptions): Promise<DailyStats[]>;
+    getStorageDailyStats(_options?: DateRangeOptions): Promise<DailyStats[]>;
+    /**
+     * Helper to generate mock daily stats
+     */
+    private generateMockDailyStats;
+}
+
+/**
+ * @module @kb-labs/studio-data-client/mocks/mock-platform-source
+ * Mock implementation of PlatformDataSource for development
+ */
+
+/**
+ * Mock platform data source
+ */
+declare class MockPlatformSource implements PlatformDataSource {
+    getConfig(): Promise<PlatformConfigPayload>;
+}
+
+/**
+ * Mock implementation of PluginsDataSource for testing
+ */
+
+declare class MockPluginsSource implements PluginsDataSource {
+    getPlugins(): Promise<PluginsRegistryResponse>;
+    askAboutPlugin(pluginId: string, request: {
+        question: string;
+    }): Promise<{
+        answer: string;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+        };
+    }>;
+}
+
+interface DataSourcesConfig {
+    mode: 'mock' | 'http';
+    baseUrl?: string;
+    /** Bearer token forwarded to Gateway on every request */
+    token?: string;
+}
+interface DataSources {
+    system: SystemDataSource;
+    workflow: WorkflowDataSource;
+    cache: CacheDataSource;
+    observability: ObservabilityDataSource;
+    analytics: AnalyticsDataSource;
+    adapters: AdaptersDataSource;
+    platform: PlatformDataSource;
+    plugins: PluginsDataSource;
+}
+declare function createDataSources(config: DataSourcesConfig): DataSources;
+
+/**
+ * @module @kb-labs/studio-data-client/query-keys
+ * Query keys factory for TanStack Query
+ */
+
+/**
+ * Standardized query keys factory
+ */
+declare const qk: {
+    readonly audit: {
+        readonly all: readonly ["audit"];
+        readonly summary: () => readonly ["audit", "summary"];
+        readonly runs: {
+            readonly all: () => readonly ["audit", "runs"];
+            readonly list: (params?: {
+                cursor?: string;
+                limit?: number;
+                status?: string;
+            }) => readonly ["audit", "runs", "list", {
+                cursor?: string;
+                limit?: number;
+                status?: string;
+            } | undefined];
+            readonly byId: (runId: string) => readonly ["audit", "runs", "detail", string];
+        };
+        readonly report: {
+            readonly latest: () => readonly ["audit", "report", "latest"];
+            readonly byRunId: (runId: string) => readonly ["audit", "report", string];
+        };
+        readonly pkg: (name: string) => readonly ["audit", "pkg", string];
+    };
+    readonly release: {
+        readonly all: readonly ["release"];
+        readonly preview: (params?: {
+            from?: string;
+            to?: string;
+        }) => readonly ["release", "preview", {
+            from?: string;
+            to?: string;
+        } | undefined];
+        readonly runs: {
+            readonly all: () => readonly ["release", "runs"];
+            readonly byId: (runId: string) => readonly ["release", "runs", "detail", string];
+        };
+        readonly changelog: (params?: {
+            format?: string;
+        }) => readonly ["release", "changelog", {
+            format?: string;
+        } | undefined];
+    };
+    readonly jobs: {
+        readonly all: readonly ["jobs"];
+        readonly byId: (jobId: string) => readonly ["jobs", "detail", string];
+        readonly logs: {
+            readonly byJobId: (jobId: string, offset?: number) => readonly ["jobs", "logs", string, number | undefined];
+            readonly stream: (jobId: string) => readonly ["jobs", "logs", "stream", string];
+        };
+        readonly events: (jobId: string) => readonly ["jobs", "events", string];
+        readonly list: (params?: {
+            cursor?: string;
+            limit?: number;
+            status?: string;
+            kind?: string;
+        }) => readonly ["jobs", "list", {
+            cursor?: string;
+            limit?: number;
+            status?: string;
+            kind?: string;
+        } | undefined];
+    };
+    readonly system: {
+        readonly all: readonly ["system"];
+        readonly health: {
+            readonly live: () => readonly ["system", "health", "live"];
+            readonly ready: () => readonly ["system", "health", "ready"];
+        };
+        readonly info: () => readonly ["system", "info"];
+        readonly capabilities: () => readonly ["system", "capabilities"];
+        readonly config: () => readonly ["system", "config"];
+    };
+    readonly workflows: {
+        readonly all: readonly ["workflows"];
+        readonly list: (filters?: WorkflowRunsFilters) => readonly ["workflows", "list", WorkflowRunsFilters];
+        readonly run: (runId: string) => readonly ["workflows", "run", string];
+    };
+    readonly devlink: {
+        readonly all: readonly ["devlink"];
+        readonly summary: () => readonly ["devlink", "summary"];
+        readonly graph: () => readonly ["devlink", "graph"];
+    };
+    readonly mind: {
+        readonly all: readonly ["mind"];
+        readonly summary: () => readonly ["mind", "summary"];
+    };
+    readonly analytics: {
+        readonly all: readonly ["analytics"];
+        readonly summary: (params?: {
+            start?: string;
+            end?: string;
+        }) => readonly ["analytics", "summary", {
+            start?: string;
+            end?: string;
+        } | undefined];
+    };
+    readonly platform: {
+        readonly all: readonly ["platform"];
+        readonly config: () => readonly ["platform", "config"];
+    };
+};
+declare const queryKeys: {
+    readonly audit: {
+        readonly all: readonly ["audit"];
+        readonly summary: () => readonly ["audit", "summary"];
+        readonly runs: {
+            readonly all: () => readonly ["audit", "runs"];
+            readonly list: (params?: {
+                cursor?: string;
+                limit?: number;
+                status?: string;
+            }) => readonly ["audit", "runs", "list", {
+                cursor?: string;
+                limit?: number;
+                status?: string;
+            } | undefined];
+            readonly byId: (runId: string) => readonly ["audit", "runs", "detail", string];
+        };
+        readonly report: {
+            readonly latest: () => readonly ["audit", "report", "latest"];
+            readonly byRunId: (runId: string) => readonly ["audit", "report", string];
+        };
+        readonly pkg: (name: string) => readonly ["audit", "pkg", string];
+    };
+    readonly release: {
+        readonly all: readonly ["release"];
+        readonly preview: (params?: {
+            from?: string;
+            to?: string;
+        }) => readonly ["release", "preview", {
+            from?: string;
+            to?: string;
+        } | undefined];
+        readonly runs: {
+            readonly all: () => readonly ["release", "runs"];
+            readonly byId: (runId: string) => readonly ["release", "runs", "detail", string];
+        };
+        readonly changelog: (params?: {
+            format?: string;
+        }) => readonly ["release", "changelog", {
+            format?: string;
+        } | undefined];
+    };
+    readonly jobs: {
+        readonly all: readonly ["jobs"];
+        readonly byId: (jobId: string) => readonly ["jobs", "detail", string];
+        readonly logs: {
+            readonly byJobId: (jobId: string, offset?: number) => readonly ["jobs", "logs", string, number | undefined];
+            readonly stream: (jobId: string) => readonly ["jobs", "logs", "stream", string];
+        };
+        readonly events: (jobId: string) => readonly ["jobs", "events", string];
+        readonly list: (params?: {
+            cursor?: string;
+            limit?: number;
+            status?: string;
+            kind?: string;
+        }) => readonly ["jobs", "list", {
+            cursor?: string;
+            limit?: number;
+            status?: string;
+            kind?: string;
+        } | undefined];
+    };
+    readonly system: {
+        readonly all: readonly ["system"];
+        readonly health: {
+            readonly live: () => readonly ["system", "health", "live"];
+            readonly ready: () => readonly ["system", "health", "ready"];
+        };
+        readonly info: () => readonly ["system", "info"];
+        readonly capabilities: () => readonly ["system", "capabilities"];
+        readonly config: () => readonly ["system", "config"];
+    };
+    readonly workflows: {
+        readonly all: readonly ["workflows"];
+        readonly list: (filters?: WorkflowRunsFilters) => readonly ["workflows", "list", WorkflowRunsFilters];
+        readonly run: (runId: string) => readonly ["workflows", "run", string];
+    };
+    readonly devlink: {
+        readonly all: readonly ["devlink"];
+        readonly summary: () => readonly ["devlink", "summary"];
+        readonly graph: () => readonly ["devlink", "graph"];
+    };
+    readonly mind: {
+        readonly all: readonly ["mind"];
+        readonly summary: () => readonly ["mind", "summary"];
+    };
+    readonly analytics: {
+        readonly all: readonly ["analytics"];
+        readonly summary: (params?: {
+            start?: string;
+            end?: string;
+        }) => readonly ["analytics", "summary", {
+            start?: string;
+            end?: string;
+        } | undefined];
+    };
+    readonly platform: {
+        readonly all: readonly ["platform"];
+        readonly config: () => readonly ["platform", "config"];
+    };
+};
+
+declare function useHealthStatus(source: SystemDataSource): _tanstack_react_query.UseQueryResult<HealthStatus, Error>;
+declare function useReadyStatus(source: SystemDataSource): _tanstack_react_query.UseQueryResult<any, Error>;
+declare function useSystemInfo(source: SystemDataSource): _tanstack_react_query.UseQueryResult<any, Error>;
+declare function useCapabilities(source: SystemDataSource): _tanstack_react_query.UseQueryResult<any, Error>;
+
+declare function useWorkflowRuns(source: WorkflowDataSource, filters?: WorkflowRunsFilters): _tanstack_react_query.UseQueryResult<WorkflowRunsListResponse, Error>;
+declare function useWorkflowRun(runId: string | null, source: WorkflowDataSource): _tanstack_react_query.UseQueryResult<WorkflowRun | null, Error>;
+declare function useCancelWorkflowRun(source: WorkflowDataSource): _tanstack_react_query.UseMutationResult<WorkflowRun, Error, string, unknown>;
+declare function useRunWorkflow(source: WorkflowDataSource): _tanstack_react_query.UseMutationResult<WorkflowRun, Error, WorkflowRunParams, unknown>;
+declare function useResolveApproval(source: WorkflowDataSource): _tanstack_react_query.UseMutationResult<{
+    resolved: boolean;
+}, Error, ResolveApprovalParams, unknown>;
+interface UseWorkflowLogsOptions {
+    follow?: boolean;
+    idleTimeoutMs?: number;
+    enabled?: boolean;
+    baseUrl?: string;
+}
+declare function useWorkflowLogs(runId: string | null, options?: UseWorkflowLogsOptions): {
+    events: WorkflowLogEvent[];
+    error: Error | null;
+    isConnected: boolean;
+};
+interface UseWorkflowEventsOptions {
+    follow?: boolean;
+    pollIntervalMs?: number;
+    cursor?: string | null;
+    enabled?: boolean;
+    baseUrl?: string;
+}
+declare function useWorkflowEvents(runId: string | null, options?: UseWorkflowEventsOptions): {
+    events: WorkflowPresenterEvent[];
+    error: Error | null;
+    isConnected: boolean;
+};
+
+/**
+ * Hook to fetch State Broker statistics
+ *
+ * Auto-refreshes every 5 seconds to show real-time cache metrics
+ */
+declare function useStateBrokerStats(source: ObservabilityDataSource): _tanstack_react_query.UseQueryResult<StateBrokerStats, Error>;
+/**
+ * Hook to fetch DevKit health snapshot
+ *
+ * Caches for 1 minute as DevKit health doesn't change frequently
+ */
+declare function useDevKitHealth(source: ObservabilityDataSource): _tanstack_react_query.UseQueryResult<DevKitHealth, Error>;
+/**
+ * Hook to fetch Prometheus metrics from REST API
+ *
+ * Auto-refreshes every 10 seconds to show near real-time metrics
+ */
+declare function usePrometheusMetrics(source: ObservabilityDataSource): _tanstack_react_query.UseQueryResult<PrometheusMetrics, Error>;
+/**
+ * Hook to connect to system events SSE stream
+ *
+ * Uses ObservabilityDataSource to subscribe to real-time system events
+ */
+declare function useSystemEvents(source: ObservabilityDataSource): {
+    events: SystemEvent[];
+    isConnected: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to connect to live log stream
+ *
+ * Uses ObservabilityDataSource to subscribe to real-time logs
+ *
+ * @param source - Observability data source
+ * @param filters - Optional log filters
+ */
+declare function useLogStream(source: ObservabilityDataSource, filters?: LogQuery): {
+    logs: LogRecord[];
+    isConnected: boolean;
+    error: Error | null;
+    clearLogs: () => void;
+};
+/**
+ * Hook to fetch historical metrics time-series data
+ *
+ * Auto-refreshes every 5 seconds for near real-time charts
+ */
+declare function useMetricsHistory(source: ObservabilityDataSource, query: MetricsHistoryQuery): _tanstack_react_query.UseQueryResult<HistoricalDataPoint[], Error>;
+/**
+ * Hook to fetch metrics heatmap data
+ *
+ * Caches for 1 minute as heatmap data changes slowly
+ */
+declare function useMetricsHeatmap(source: ObservabilityDataSource, query: MetricsHeatmapQuery): _tanstack_react_query.UseQueryResult<HeatmapCell[], Error>;
+/**
+ * Hook to query incident history
+ *
+ * Auto-refreshes every 30 seconds to show new incidents
+ */
+declare function useIncidents(source: ObservabilityDataSource, query?: IncidentQuery): _tanstack_react_query.UseQueryResult<Incident[], Error>;
+
+/**
+ * Hook to fetch analytics events
+ *
+ * @param source - Analytics data source
+ * @param query - Optional query filters
+ */
+declare function useAnalyticsEvents(source: AnalyticsDataSource, query?: EventsQuery): _tanstack_react_query.UseQueryResult<_kb_labs_core_platform_adapters.EventsResponse, Error>;
+/**
+ * Hook to fetch analytics stats
+ *
+ * @param source - Analytics data source
+ */
+declare function useAnalyticsStats(source: AnalyticsDataSource): _tanstack_react_query.UseQueryResult<_kb_labs_core_platform_adapters.EventsStats, Error>;
+/**
+ * Hook to fetch buffer status
+ *
+ * @param source - Analytics data source
+ */
+declare function useAnalyticsBufferStatus(source: AnalyticsDataSource): _tanstack_react_query.UseQueryResult<_kb_labs_core_platform_adapters.BufferStatus | null, Error>;
+/**
+ * Hook to fetch DLQ status
+ *
+ * @param source - Analytics data source
+ */
+declare function useAnalyticsDlqStatus(source: AnalyticsDataSource): _tanstack_react_query.UseQueryResult<_kb_labs_core_platform_adapters.DlqStatus | null, Error>;
+
+/**
+ * Hook to fetch LLM usage statistics
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersLLMUsage(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<LLMUsageStats, Error>;
+/**
+ * Hook to fetch Embeddings usage statistics
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersEmbeddingsUsage(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<EmbeddingsUsageStats, Error>;
+/**
+ * Hook to fetch VectorStore usage statistics
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersVectorStoreUsage(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<VectorStoreUsageStats, Error>;
+/**
+ * Hook to fetch Cache usage statistics
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersCacheUsage(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<CacheUsageStats, Error>;
+/**
+ * Hook to fetch Storage usage statistics
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersStorageUsage(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<StorageUsageStats, Error>;
+/**
+ * Hook to fetch LLM daily statistics for time-series charts
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersLLMDailyStats(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<DailyStats[], Error>;
+/**
+ * Hook to fetch Embeddings daily statistics for time-series charts
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersEmbeddingsDailyStats(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<DailyStats[], Error>;
+/**
+ * Hook to fetch VectorStore daily statistics for time-series charts
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersVectorStoreDailyStats(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<DailyStats[], Error>;
+/**
+ * Hook to fetch Cache daily statistics for time-series charts
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersCacheDailyStats(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<DailyStats[], Error>;
+/**
+ * Hook to fetch Storage daily statistics for time-series charts
+ *
+ * @param source - Adapters data source
+ * @param options - Optional date range filter
+ */
+declare function useAdaptersStorageDailyStats(source: AdaptersDataSource, options?: DateRangeOptions): _tanstack_react_query.UseQueryResult<DailyStats[], Error>;
+
+/**
+ * Get platform configuration (adapters, options, execution mode)
+ */
+declare function usePlatformConfig(source: PlatformDataSource): _tanstack_react_query.UseQueryResult<_kb_labs_rest_api_contracts.PlatformConfigPayload, Error>;
+
+/**
+ * @module @kb-labs/studio-data-client/hooks/types
+ * Types for hooks
+ */
+/**
+ * Job event types
+ */
+type JobEventType = 'job.queued' | 'job.started' | 'job.progress' | 'job.finished' | 'job.failed';
+
+/**
+ * @module @kb-labs/studio-data-client/hooks/use-job-events
+ * React hook for subscribing to job events via SSE with fallback to polling
+ */
+
+/**
+ * Job event structure
+ */
+interface JobEvent {
+    type: JobEventType;
+    jobId: string;
+    timestamp: string;
+    data?: {
+        status?: string;
+        progress?: number;
+        error?: string;
+    };
+}
+/**
+ * Hook options
+ */
+interface UseJobEventsOptions {
+    enabled?: boolean;
+    pollInterval?: number;
+    baseUrl?: string;
+    onEvent?: (event: JobEvent) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+/**
+ * Hook result
+ */
+interface UseJobEventsResult {
+    events: JobEvent[];
+    isConnected: boolean;
+    error: Error | null;
+    reconnect: () => void;
+}
+/**
+ * Use job events hook with SSE support and polling fallback
+ */
+declare function useJobEvents(jobId: string | null, options?: UseJobEventsOptions): UseJobEventsResult;
+
+/**
+ * @module @kb-labs/studio-data-client/hooks/use-notifications
+ * React hook for tracking critical log notifications
+ */
+
+interface LogNotification {
+    id: string;
+    timestamp: string;
+    level: 'warn' | 'error';
+    message: string;
+    plugin?: string;
+    executionId?: string;
+    error?: {
+        name: string;
+        message: string;
+    };
+    read: boolean;
+}
+interface UseNotificationsResult {
+    notifications: LogNotification[];
+    unreadCount: number;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+    clearAll: () => void;
+    clearNotification: (id: string) => void;
+}
+/**
+ * Hook to track critical log notifications (warn/error) from SSE stream
+ *
+ * Automatically subscribes to log stream and filters warn/error logs.
+ * Maintains a list of recent critical logs with read/unread status.
+ *
+ * @param source - Observability data source
+ * @param maxNotifications - Maximum number of notifications to keep (default: 50)
+ */
+declare function useNotifications(source: ObservabilityDataSource, maxNotifications?: number): UseNotificationsResult;
+
+export { type ActionResult, type AdaptersDataSource, type AnalyticsDataSource, type CacheDataSource, type CacheInvalidationResult, type CacheUsageStats, type CronInfo, type CronListResponse, type DailyStats, type DashboardStatsResponse, type DataSources, type DataSourcesConfig, type DateRangeOptions, type DevKitHealth, type EmbeddingsUsageStats, type ErrorInterceptor, type FetchOptions, type HealthEvent, type HealthStatus, type HeatmapCell, type HistoricalDataPoint, HttpAdaptersSource, HttpAnalyticsSource, HttpCacheSource, HttpClient, HttpObservabilitySource, HttpPlatformSource, HttpPluginsSource, HttpSystemSource, HttpWorkflowSource, type ID, type ISODate, type Incident, type IncidentAnalysis, type IncidentAnalysisResponse, type IncidentCreatePayload, type IncidentDetailResponse, type IncidentQuery, type IncidentResolveRequest, type IncidentSeverity, type IncidentType, type IncidentsListResponse, type JobEvent, type JobEventType, type JobListFilter, type JobListResponse, type JobLogsResponse, type JobRun, type JobStatusInfo, type JobStepInfo, type JobStepsResponse, KBError, type LLMModelStats, type LLMUsageStats, type LogEvent, type LogNotification, type LogQuery, type LogQueryResponse, type LogRecord, type LogStats, type LogSummarizeContext, type LogSummarizeRequest, type LogSummarizeResponse, type MetricsHeatmapQuery, type MetricsHistoryQuery, MockAdaptersSource, MockAnalyticsSource, MockCacheSource, MockObservabilitySource, MockPlatformSource, MockPluginsSource, MockSystemSource, MockWorkflowSource, type NamespaceStats, type ObservabilityDataSource, type PackageRef, type PendingApproval, type PendingApprovalsResponse, type PlatformDataSource, type PluginAskRequest, type PluginAskResponse, type PluginManifestEntry, type PluginMetrics, type PluginSource, type PluginsDataSource, type PluginsRegistryResponse, type PrometheusMetrics, type RegistryEvent, type RelatedData, type RelatedLogsData, type RelatedMetricsData, type RequestInterceptor, type ResolveApprovalParams, type ResponseError, type ResponseInterceptor, type RootCauseItem, type RouteInfo, type RoutesResponse, type RunRef, SCHEMA_VERSION, type SlowRequest, type StateBrokerStats, type StepRun, type StorageUsageStats, type SystemDataSource, type SystemEvent, type TenantMetrics, type TimelineEvent, type UseJobEventsOptions, type UseJobEventsResult, type UseNotificationsResult, type UseWorkflowEventsOptions, type UseWorkflowLogsOptions, type VectorStoreUsageStats, type WorkflowDataSource, type WorkflowExecutionResult, type WorkflowInfo, type WorkflowListResponse, type WorkflowLogEvent, type WorkflowPresenterEvent, type WorkflowResultError, type WorkflowResultMetrics, type WorkflowRun, type WorkflowRunHistoryResponse, type WorkflowRunInfo, type WorkflowRunParams, type WorkflowRunResponse, type WorkflowRunsFilters, type WorkflowRunsListResponse, type WorkflowSpec, type WorkflowStatus, type WorkflowTrigger, actionResultSchema, auditCheckSchema, auditPackageReportSchema, auditSummarySchema, createDataSources, createEnvelopeInterceptor, errorCodes, extractEnvelopeMeta, healthStatusSchema, idSchema, isoDateSchema, mapErrorEnvelope, mapFetchError, packageRefSchema, qk, queryKeys, releasePreviewSchema, runRefSchema, useAdaptersCacheDailyStats, useAdaptersCacheUsage, useAdaptersEmbeddingsDailyStats, useAdaptersEmbeddingsUsage, useAdaptersLLMDailyStats, useAdaptersLLMUsage, useAdaptersStorageDailyStats, useAdaptersStorageUsage, useAdaptersVectorStoreDailyStats, useAdaptersVectorStoreUsage, useAnalyticsBufferStatus, useAnalyticsDlqStatus, useAnalyticsEvents, useAnalyticsStats, useCancelWorkflowRun, useCapabilities, useDevKitHealth, useHealthStatus, useIncidents, useJobEvents, useLogStream, useMetricsHeatmap, useMetricsHistory, useNotifications, usePlatformConfig, usePrometheusMetrics, useReadyStatus, useResolveApproval, useRunWorkflow, useStateBrokerStats, useSystemEvents, useSystemInfo, useWorkflowEvents, useWorkflowLogs, useWorkflowRun, useWorkflowRuns };