@elevasis/ui 1.20.1 → 1.22.0

package/dist/hooks/published.d.ts

@@ -1,9 +1,9 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
+import { z } from 'zod';
 import * as react from 'react';
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand from 'zustand';
 import { Edge } from '@xyflow/react';
-import { z } from 'zod';
 
 /**
  * Query key factory for executions TanStack Query hooks.
@@ -626,6 +626,51 @@ interface AgentToolCallEvent {
  * 3 event types total (lifecycle, iteration, tool-call)
  */
 type AgentLogContext = AgentLifecycleEvent | AgentIterationEvent | AgentToolCallEvent;
+/**
+ * Data for lifecycle 'started' events
+ */
+interface AgentLifecycleStartedData {
+    startTime: number;
+    iteration?: number;
+}
+/**
+ * Data for lifecycle 'completed' events
+ */
+interface AgentLifecycleCompletedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    iteration?: number;
+    attempts?: number;
+    memorySize?: {
+        sessionMemoryKeys: number;
+        historyEntries: number;
+    };
+}
+/**
+ * Data for lifecycle 'failed' events
+ */
+interface AgentLifecycleFailedData {
+    startTime: number;
+    endTime: number;
+    duration: number;
+    error: string;
+    iteration?: number;
+}
+/**
+ * Scoped logger for agent execution
+ * Captures logger and agentId to eliminate repetitive parameter passing
+ *
+ * Type-safe lifecycle logging with stage-specific required fields
+ */
+interface AgentScopedLogger {
+    lifecycle(lifecycle: AgentLifecycle, stage: 'started', data: AgentLifecycleStartedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'completed', data: AgentLifecycleCompletedData): void;
+    lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void;
+    reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    action(actionType: string, message: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    toolCall(toolName: string, iteration: number, startTime: number, endTime: number, duration: number, success: boolean, error?: string, input?: unknown, output?: unknown): void;
+}
 
 /**
  * Base execution logger for Execution Engine
@@ -639,6 +684,12 @@ interface ExecutionLogMessage {
     timestamp: number;
     context?: LogContext;
 }
+interface IExecutionLogger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
 
 /**
  * Shared form field types for dynamic form generation
@@ -920,6 +971,262 @@ interface SerializedWorkflowDefinition {
     interface?: SerializedExecutionInterface;
 }
 
+/**
+ * Model Configuration
+ * Centralized model information, configuration, options, constraints, and validation
+ * Single source of truth for all model-related definitions
+ * Update manually when pricing changes or new models are added
+ */
+
+/**
+ * Supported Open AI models (direct SDK access)
+ */
+type OpenAIModel = 'gpt-5' | 'gpt-5.4-mini' | 'gpt-5.4-nano';
+/**
+ * Supported OpenRouter models (explicit union for type safety)
+ */
+type OpenRouterModel = 'openrouter/z-ai/glm-5';
+/**
+ * Supported Google models (direct SDK access)
+ */
+type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview';
+/**
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
+ */
+type AnthropicModel = 'claude-sonnet-4-5';
+/** Supported LLM models */
+type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock';
+/**
+ * GPT-5 model options schema
+ */
+declare const GPT5OptionsSchema: z.ZodObject<{
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * OpenRouter model options schema
+ * OpenRouter-specific options for routing and transforms
+ */
+declare const OpenRouterOptionsSchema: z.ZodObject<{
+    transforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    route: z.ZodOptional<z.ZodEnum<{
+        fallback: "fallback";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Google model options schema
+ * Gemini 3 specific options for thinking depth control
+ */
+declare const GoogleOptionsSchema: z.ZodObject<{
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Anthropic model options schema
+ * Currently empty - future options: budget_tokens for extended thinking
+ */
+declare const AnthropicOptionsSchema: z.ZodObject<{}, z.core.$strip>;
+/**
+ * Infer TypeScript types from schemas
+ */
+type GPT5Options = z.infer<typeof GPT5OptionsSchema>;
+type MockOptions = Record<string, never>;
+type OpenRouterOptions = z.infer<typeof OpenRouterOptionsSchema>;
+type GoogleOptions = z.infer<typeof GoogleOptionsSchema>;
+type AnthropicOptions = z.infer<typeof AnthropicOptionsSchema>;
+type ModelSpecificOptions = GPT5Options | MockOptions | OpenRouterOptions | GoogleOptions | AnthropicOptions;
+/**
+ * Model configuration for LLM execution
+ * Belongs in resource definition (AgentDefinition, WorkflowDefinition, etc.)
+ */
+interface ModelConfig {
+    model: LLMModel;
+    provider: 'openai' | 'anthropic' | 'openrouter' | 'google' | 'mock';
+    apiKey: string;
+    temperature?: number;
+    /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+    maxOutputTokens?: number;
+    topP?: number;
+    /**
+     * Model-specific options (flat structure)
+     * Options are model-specific, not vendor-specific
+     * Available options defined in MODEL_INFO per model
+     * Validated at build time via validateModelOptions()
+     */
+    modelOptions?: ModelSpecificOptions;
+}
+
+/**
+ * Execution interface configuration
+ * Defines how a resource is executed via the UI (forms, scheduling, webhooks)
+ * Applies to both agents and workflows
+ */
+interface ExecutionInterface {
+    /** Form configuration for execution inputs */
+    form: ExecutionFormSchema;
+    /** Optional: Schedule configuration */
+    schedule?: ScheduleConfig;
+    /** Optional: Webhook trigger configuration */
+    webhook?: WebhookConfig;
+}
+/**
+ * Execution form schema
+ * Extends FormSchema with execution-specific fields
+ */
+interface ExecutionFormSchema extends FormSchema {
+    /**
+     * Field mappings to resource input schema
+     * Maps form field names to contract input paths
+     * If omitted, field names must match contract input keys exactly
+     */
+    fieldMappings?: Record<string, string>;
+    /**
+     * Submit button configuration
+     * Default: { label: 'Run', loadingLabel: 'Running...' }
+     */
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Schedule configuration for automated execution
+ */
+interface ScheduleConfig {
+    /** Whether scheduling is enabled for this resource */
+    enabled: boolean;
+    /** Default schedule (cron expression) */
+    defaultSchedule?: string;
+    /** Allowed schedule patterns (if restricted) */
+    allowedPatterns?: string[];
+}
+/**
+ * Webhook configuration for external triggers
+ */
+interface WebhookConfig {
+    /** Whether webhook trigger is enabled */
+    enabled: boolean;
+    /** Expected payload schema (for documentation) */
+    payloadSchema?: unknown;
+}
+
+interface WorkflowConfig extends ResourceDefinition {
+    type: 'workflow';
+}
+interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    description: string;
+}
+type StepHandler = (input: unknown, context: ExecutionContext) => Promise<unknown>;
+interface LinearNext {
+    type: 'linear';
+    target: string;
+}
+interface ConditionalNext {
+    type: 'conditional';
+    routes: Array<{
+        condition: (data: unknown) => boolean;
+        target: string;
+    }>;
+    default: string;
+}
+type NextConfig = LinearNext | ConditionalNext | null;
+interface WorkflowStep extends WorkflowStepDefinition {
+    handler: StepHandler;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    next: NextConfig;
+}
+interface WorkflowDefinition {
+    config: WorkflowConfig;
+    contract: Contract;
+    steps: Record<string, WorkflowStep>;
+    entryPoint: string;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, workflow appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+}
+
+/**
+ * Generic LLM Types
+ * Universal interfaces for LLM interaction across all resource types
+ */
+/**
+ * Standard chat message format
+ * Compatible with OpenAI, Anthropic, and other providers
+ */
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Generic LLM generation request
+ * Usable by agents, workflows, tools, etc.
+ */
+interface LLMGenerateRequest {
+    messages: LLMMessage[];
+    responseSchema: unknown;
+    /** Maximum output tokens per LLM call. NOT the model's context window — see ModelInfo.maxTokens for that. */
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Generic LLM generation response
+ * Usage field is internal-only (stripped by UniversalLLMAdapter wrapper)
+ */
+interface LLMGenerateResponse<T = unknown> {
+    output: T;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    cost?: number;
+}
+/**
+ * LLM Adapter interface
+ * Generic primitive for all resource types (agents, workflows, tools)
+ *
+ * Design principles:
+ * - Single method: generate() - the core LLM primitive
+ * - Generic return type for type safety
+ * - Universal format (not agent-specific)
+ * - Standard message-based input (OpenAI-compatible)
+ */
+interface LLMAdapter {
+    /**
+     * Generate structured output from prompt using LLM
+     *
+     * @param request - Generation request with messages and response schema
+     * @returns Generated output (typed) with optional usage metadata
+     */
+    generate<T = unknown>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>>;
+}
+
 /**
  * Memory type definitions
  * Types for agent memory management with semantic entry types
@@ -960,6 +1267,302 @@ interface AgentMemory {
      */
     history: MemoryEntry[];
 }
+/**
+ * Memory status for agent awareness
+ */
+interface MemoryStatus {
+    sessionMemoryKeys: number;
+    sessionMemoryLimit: number;
+    currentKeys: string[];
+    historyPercent: number;
+    historyTokens: number;
+    tokenBudget: number;
+}
+/**
+ * Memory constraints (optional limits)
+ */
+interface MemoryConstraints {
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+
+/**
+ * Memory Manager
+ * Encapsulates all memory operations with ultra-simple agent API
+ * Agent provides strings, framework handles wrapping and auto-compaction
+ */
+
+/**
+ * Memory Manager - Agent memory orchestration
+ * Provides ultra-simple API for agents (strings only)
+ * Handles automatic compaction and token management
+ */
+declare class MemoryManager {
+    private memory;
+    private constraints;
+    private logger?;
+    private cachedSnapshot?;
+    constructor(memory: AgentMemory, constraints?: MemoryConstraints, logger?: AgentScopedLogger | undefined);
+    /**
+     * Set session memory entry (agent provides string, framework wraps it)
+     * @param key - Session memory key
+     * @param content - String content from agent
+     */
+    set(key: string, content: string): void;
+    /**
+     * Get session memory entry content
+     * @param key - Session memory key
+     * @returns String content if exists, undefined otherwise
+     */
+    get(key: string): string | undefined;
+    /**
+     * Delete session memory entry
+     * @param key - Key to delete
+     * @returns True if key existed and was deleted
+     */
+    delete(key: string): boolean;
+    /**
+     * Add entry to history (called by framework after tool results, reasoning, etc.)
+     * Automatically sets timestamp to current time
+     * @param entry - Memory entry to add (without timestamp - auto-generated)
+     */
+    addToHistory(entry: Omit<MemoryEntry, 'timestamp'>): void;
+    /**
+     * Auto-compact history if approaching token budget
+     * Uses preserve-anchors strategy: keep first + recent entries
+     */
+    autoCompact(): void;
+    /**
+     * Enforce hard limits (called before LLM request)
+     * Emergency fallback if agent exceeds limits
+     */
+    enforceHardLimits(): void;
+    /**
+     * Get history length (for logging and introspection)
+     * @returns Number of entries in history
+     */
+    getHistoryLength(): number;
+    /**
+     * Get memory status for agent awareness
+     * @returns Memory status with token usage and key counts
+     */
+    getStatus(): MemoryStatus;
+    /**
+     * Create memory snapshot for persistence
+     * Caches snapshot internally for later retrieval
+     * @returns Deep copy of current memory state
+     */
+    toSnapshot(): AgentMemory;
+    /**
+     * Get cached memory snapshot
+     * Returns snapshot created by toSnapshot()
+     * @returns Cached snapshot (undefined if toSnapshot() not called yet)
+     */
+    getSnapshot(): AgentMemory | undefined;
+    /**
+     * Build context string for LLM
+     * Serializes sessionmemory + history memory with clear sections
+     * Shows current iteration entries FIRST (reverse chronological) for LLM attention
+     * @param currentIteration - Current iteration number (0 = pre-iteration)
+     * @param currentTurn - Current turn number (optional, for session context filtering)
+     * @returns Formatted memory context for LLM prompt
+     */
+    toContext(currentIteration: number, currentTurn?: number): string;
+}
+
+/**
+ * Knowledge Map Types
+ *
+ * Enables agents to navigate organizational knowledge through a lightweight
+ * graph that lazy-loads capabilities on-demand.
+ *
+ * @module agent/knowledge-map
+ */
+
+/**
+ * Lightweight knowledge map (passed as agent property)
+ *
+ * Contains metadata about available knowledge nodes without loading
+ * the full content upfront. Total size: ~300-500 tokens.
+ *
+ * Multi-tenancy is enforced via:
+ * - File-scoped maps (organizations/{org-name}/knowledge/)
+ * - ExecutionContext.organizationId passed to node.load()
+ */
+interface KnowledgeMap {
+    /** Available knowledge nodes indexed by ID */
+    nodes: Record<string, KnowledgeNode>;
+}
+/**
+ * Single knowledge source
+ *
+ * Represents a domain knowledge area (CRM, brand guidelines, Excel tools)
+ * that can be lazy-loaded to provide instructions and tools to agents.
+ */
+interface KnowledgeNode {
+    /** Unique identifier for this node (e.g., "crm", "brand-guidelines") */
+    id: string;
+    /**
+     * Description of when to use this knowledge
+     * Used for semantic matching against user intent
+     */
+    description: string;
+    /**
+     * Load knowledge content on-demand
+     *
+     * @param context - Execution context with organizationId for multi-tenancy
+     * @returns Promise resolving to knowledge content (prompt + optional tools)
+     */
+    load(context: ExecutionContext): Promise<KnowledgeContent>;
+    /**
+     * Loaded state flag
+     * Set to true after load() is called
+     */
+    loaded?: boolean;
+    /**
+     * Cached prompt (for system prompt serialization)
+     * Only the prompt is cached - tools go to toolRegistry, children flattened to nodes
+     */
+    prompt?: string;
+}
+/**
+ * Content returned by knowledge node
+ *
+ * Separates instructions (prompt) from capabilities (tools).
+ * Tools are optional - some nodes only provide context.
+ *
+ * Supports recursive navigation - nodes can contain child nodes
+ * that are discovered when the parent node is loaded.
+ */
+interface KnowledgeContent {
+    /** Instructions and context (markdown format) */
+    prompt: string;
+    /** Tool implementations (optional) */
+    tools?: Tool[];
+    /**
+     * Child knowledge nodes (optional, recursive)
+     *
+     * Enables hierarchical navigation: base → specialized → deep expertise.
+     * Child nodes are flattened into the main knowledge map when parent loads,
+     * making them available for subsequent navigate-knowledge actions.
+     *
+     * Example: CRM base node returns crm-customers and crm-deals as children
+     */
+    nodes?: Record<string, KnowledgeNode>;
+}
+
+/**
+ * Agent-specific type definitions
+ * Types for autonomous agents with tools, memory, and constraints
+ */
+
+/**
+ * Factory function for creating LLM adapters.
+ * Injected into the Agent class to decouple the engine from server-only provider SDKs.
+ * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
+ * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
+ *
+ * Uses `any` for optional params so both the real createLLMAdapter (with typed
+ * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
+ */
+type LLMAdapterFactory = (config: ModelConfig, ...args: any[]) => LLMAdapter;
+interface AgentConfig extends ResourceDefinition {
+    type: 'agent';
+    systemPrompt: string;
+    constraints?: AgentConstraints;
+    /**
+     * Session capability declaration (opt-in)
+     * If true, agent is designed for multi-turn session interactions
+     * Controls whether agent can use message action and appears in Sessions UI
+     *
+     * Use for:
+     * - Conversational agents with multi-turn interactions
+     * - Agents requiring persistent context across turns
+     * - Agents that need human-in-the-loop communication
+     */
+    sessionCapable?: boolean;
+    /**
+     * Security level for system prompt hardening (auto-derived if omitted)
+     *
+     * - 'standard': Lightweight defense (3 rules) - default for non-session agents
+     * - 'hardened': Comprehensive defense (6 rules) - default for session-capable agents
+     * - 'none': No security prompt - for pure internal agents with no external input
+     *
+     * If omitted, derived from sessionCapable:
+     *   sessionCapable: true  -> 'hardened'
+     *   sessionCapable: false -> 'standard'
+     */
+    securityLevel?: 'standard' | 'hardened' | 'none';
+    /**
+     * Memory management preferences (opt-in)
+     * If provided, agent can use memoryOps to manage session memory
+     * If omitted, agent has no memory management capabilities
+     *
+     * Agent-specific guidance on what to preserve, when to persist, and what to clean up.
+     * This guidance is injected into the system prompt when memory management is enabled.
+     *
+     * Use for:
+     * - Conversational agents needing cross-turn context
+     * - Agents managing complex user preferences
+     * - Agents tracking decisions over multiple iterations
+     */
+    memoryPreferences?: string;
+}
+interface AgentConstraints {
+    maxIterations?: number;
+    timeout?: number;
+    maxSessionMemoryKeys?: number;
+    maxMemoryTokens?: number;
+}
+interface AgentDefinition {
+    config: AgentConfig;
+    contract: Contract;
+    tools: Tool[];
+    /**
+     * Model configuration for LLM execution
+     * Specifies provider, API key, and model-specific options
+     */
+    modelConfig: ModelConfig;
+    /**
+     * Optional knowledge map for lazy-loading capabilities
+     * Enables agents to navigate organizational knowledge on-demand
+     */
+    knowledgeMap?: KnowledgeMap;
+    /**
+     * Preload memory before execution starts
+     * Handles BOTH context loading AND session restoration
+     *
+     * @param context - Execution context (includes sessionId if session turn)
+     * @returns Initial AgentMemory state (sessionMemory entries + optionally history)
+     */
+    preloadMemory?: (context: ExecutionContext) => Promise<AgentMemory> | AgentMemory;
+    /**
+     * Metrics configuration for ROI calculations
+     * Optional: Only needed if tracking automation savings
+     */
+    metricsConfig?: ResourceMetricsConfig;
+    /**
+     * Execution interface configuration (optional)
+     * If provided, agent appears in Execution Runner UI
+     */
+    interface?: ExecutionInterface;
+}
+/**
+ * Agent execution context
+ * Groups all state needed for agent execution phases
+ */
+interface IterationContext {
+    config: AgentConfig;
+    contract: Contract;
+    toolRegistry: Map<string, Tool>;
+    memoryManager: MemoryManager;
+    executionContext: ExecutionContext;
+    iteration: number;
+    logger: AgentScopedLogger;
+    modelConfig: ModelConfig;
+    adapterFactory: LLMAdapterFactory;
+    knowledgeMap?: KnowledgeMap;
+}
 
 type Json = string | number | boolean | null | {
     [key: string]: Json | undefined;
@@ -3663,7 +4266,7 @@ interface MembershipFeatureConfig {
  */
 interface UserConfig {
     theme?: {
-        preset?: 'default' | 'tactical' | 'regal' | 'cyber-volt' | 'aurora' | 'rose-gold' | 'midnight' | 'ember' | 'obsidian' | 'honey' | 'abyss' | 'canopy' | 'slate' | 'cyber-strike' | 'cyber-punk' | 'cyber-void' | 'nirvana' | 'wave' | 'synapse' | 'cortex' | 'helios' | 'graphite' | 'canyon' | 'nord' | 'catppuccin' | 'tokyo-night' | 'gruvbox';
+        preset?: 'default' | 'tactical' | 'regal' | 'cyber-volt' | 'aurora' | 'rose-gold' | 'midnight' | 'ember' | 'obsidian' | 'honey' | 'abyss' | 'canopy' | 'slate' | 'cyber-strike' | 'cyber-chrome' | 'cyber-void' | 'nirvana' | 'wave' | 'synapse' | 'cortex' | 'helios' | 'graphite' | 'quarry' | 'canyon' | 'nord' | 'catppuccin' | 'tokyo-night' | 'gruvbox';
         colorScheme?: 'light' | 'dark' | 'auto';
     };
     onboarding?: {
@@ -3720,6 +4323,102 @@ interface MembershipWithDetails extends OrganizationMembership {
     config?: MembershipFeatureConfig;
 }
 
+/**
+ * MetricsCollector
+ * Tracks execution timing and ROI metrics
+ */
+declare class MetricsCollector {
+    private timings;
+    private durationMs?;
+    /**
+     * Start a timer with a label
+     */
+    startTimer(label: string): void;
+    /**
+     * End a timer and calculate duration
+     * If label is 'execution', stores duration for metrics summary
+     */
+    endTimer(label: string): number | null;
+    /**
+     * Build execution metrics summary with optional ROI calculation
+     */
+    buildExecutionMetrics(metricsConfig?: ResourceMetricsConfig): ExecutionMetricsSummary;
+}
+
+interface BaseAICall {
+    callSequence: number;
+    callType: 'agent-reasoning' | 'agent-completion' | 'workflow-step' | 'tool' | 'other';
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    context?: AICallContext;
+}
+type AICallContext = AgentReasoningContext | AgentCompletionContext | WorkflowStepContext | ToolCallContext | OtherCallContext;
+interface AgentReasoningContext {
+    type: 'agent-reasoning';
+    iteration: number;
+    actionsPlanned?: string[];
+    sessionId?: string;
+    turnNumber?: number;
+}
+interface AgentCompletionContext {
+    type: 'agent-completion';
+    attempt: 1 | 2;
+    validationFailed?: boolean;
+    sessionId?: string;
+    turnNumber?: number;
+}
+interface WorkflowStepContext {
+    type: 'workflow-step';
+    stepId: string;
+    stepName?: string;
+    stepSequence?: number;
+}
+interface ToolCallContext {
+    type: 'tool';
+    toolName: string;
+    parentIteration?: number;
+    parentStepId?: string;
+}
+interface OtherCallContext {
+    type: 'other';
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+type AICallRecord = BaseAICall;
+/**
+ * Raw LLM usage data returned by adapters
+ * Used as input to AIUsageCollector.record()
+ */
+interface LLMUsageData {
+    model: LLMModel;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    /** Actual cost from provider in USD (when available, e.g., OpenRouter) */
+    cost?: number;
+}
+interface AIUsageSummary {
+    model: LLMModel;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCostUsd: number;
+    callCount: number;
+    calls: AICallRecord[];
+}
+interface ExecutionMetricsSummary {
+    durationMs?: number;
+    automationSavingsUsd?: number;
+}
+interface ResourceMetricsConfig {
+    estimatedManualMinutes: number;
+    hourlyLaborRateUsd: number;
+    confidenceLevel?: 'low' | 'medium' | 'high';
+    notes?: string;
+}
 /**
  * Time range selector for dashboard metrics
  */
@@ -3790,6 +4489,23 @@ interface CostBreakdownMetrics {
         avgCostUsd: number;
     }>;
 }
+/**
+ * Detailed execution metrics response
+ * Full execution metrics with AI call breakdown
+ */
+interface ExecutionMetricsDetail {
+    executionId: string;
+    organizationId: string;
+    resourceId: string;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCostUsd: number;
+    aiCallCount: number;
+    aiCalls: AICallRecord[];
+    durationMs?: number;
+    automationSavingsUsd?: number;
+    createdAt: string;
+}
 /**
  * Dashboard metrics response
  * Aggregates core observability metrics in a single response
@@ -3964,11 +4680,51 @@ interface CostByModelResponse {
     totalCallCount: number;
 }
 
+/**
+ * AIUsageCollector
+ * Centralized token tracking that aggregates usage across all LLM calls in an execution
+ */
+declare class AIUsageCollector {
+    private model;
+    private calls;
+    private callSequence;
+    /**
+     * Record a single AI call with usage metrics
+     *
+     * @param usage - Token usage and latency data from LLM adapter
+     * @param callType - Type discriminator (agent-reasoning, tool, etc.)
+     * @param context - Optional typed context specific to callType
+     */
+    record(usage: LLMUsageData, callType?: BaseAICall['callType'], context?: AICallContext): void;
+    /**
+     * Get aggregated summary of all AI calls
+     */
+    getSummary(): AIUsageSummary;
+    /**
+     * Check if any usage has been recorded
+     */
+    hasUsage(): boolean;
+}
+
 /**
  * Base Execution Engine type definitions
  * Core types shared across all Execution Engine resources
  */
 
+/**
+ * Immutable execution metadata
+ * Represents complete execution identity (who, what, when, where)
+ * Shared across ExecutionContext and ExecutionLoggerContext to eliminate field duplication
+ */
+interface ExecutionMetadata {
+    executionId: string;
+    organizationId: string;
+    organizationName: string;
+    resourceId: string;
+    userId?: string;
+    sessionId?: string;
+    sessionTurnNumber?: number;
+}
 /**
  * Unified message event type - covers all message types in sessions
  * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
@@ -4016,6 +4772,27 @@ type MessageEvent = {
     result?: unknown;
     error?: string;
 };
+/**
+ * Execution context for all resources
+ * Unified callback replaces SessionTurnMessages (removed)
+ */
+interface ExecutionContext extends ExecutionMetadata {
+    logger: IExecutionLogger;
+    signal?: AbortSignal;
+    onMessageEvent?: (event: MessageEvent) => Promise<void>;
+    /** Called per iteration to write heartbeat + check stall status. Non-fatal if it throws. */
+    onHeartbeat?: () => Promise<void>;
+    aiUsageCollector?: AIUsageCollector;
+    metricsCollector?: MetricsCollector;
+    parentExecutionId?: string;
+    executionDepth: number;
+    credentialName?: string;
+    store: Map<string, unknown>;
+}
+interface Contract {
+    inputSchema: z.ZodSchema;
+    outputSchema?: z.ZodSchema;
+}
 /**
  * NOTE: AIResource interface has been removed and replaced with ResourceDefinition
  * from registry/types.ts. All resources (executable and non-executable) now extend
@@ -4026,6 +4803,45 @@ type MessageEvent = {
  */
 type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefinition;
 
+/**
+ * Tool definitions
+ *
+ * Tool interface used by agents and workflows.
+ * Provides a universal interface for AI systems to interact with tools.
+ */
+
+/**
+ * Options for tool execution
+ * Provides named parameters for better API clarity and extensibility
+ */
+interface ToolExecutionOptions {
+    /** Tool input (validated against inputSchema before execution) */
+    input: unknown;
+    /** Execution context with multi-tenant isolation and observability (optional for simple tools, required for platform/integration tools) */
+    executionContext?: ExecutionContext;
+    /** Full iteration context for advanced tools (provides access to memoryManager, toolRegistry, logger, etc.) */
+    iterationContext?: IterationContext;
+    /** Abort signal for timeout/cancellation -- forward to fetch() calls for clean cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Tool interface for AI systems
+ *
+ * Used by:
+ * - Agents: For agentic tool use (reasoning loop selects and executes tools)
+ * - Workflows: For workflow step tool invocation (future)
+ * - Platform tools: createApprovalTool(), createSchedulerTool()
+ * - Integration tools: External API calls (Gmail, Slack, etc.)
+ */
+interface Tool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema;
+    outputSchema: z.ZodSchema;
+    execute: (options: ToolExecutionOptions) => Promise<unknown>;
+    timeout?: number;
+}
+
 /**
  * Supported integration types
  *
@@ -4434,6 +5250,99 @@ interface Activity {
     createdAt: Date;
 }
 
+/**
+ * Calibration SSE Event Types
+ *
+ * Shared event type definitions for calibration real-time streaming.
+ * Used by both the API broadcaster and the command-center UI.
+ */
+interface CalibrationExecutionStartedEvent {
+    type: 'execution-started';
+    variantName: string;
+    inputIndex: number;
+    timestamp: number;
+}
+interface CalibrationExecutionCompletedEvent {
+    type: 'execution-completed';
+    variantName: string;
+    inputIndex: number;
+    executionId: string;
+    timestamp: number;
+}
+interface CalibrationExecutionFailedEvent {
+    type: 'execution-failed';
+    variantName: string;
+    inputIndex?: number;
+    error: string;
+    timestamp: number;
+}
+interface CalibrationSessionStartedEvent {
+    type: 'session-started';
+    variantName: string;
+    sessionId: string;
+    timestamp: number;
+}
+interface CalibrationTurnStartedEvent {
+    type: 'turn-started';
+    variantName: string;
+    turnNumber: number;
+    timestamp: number;
+}
+interface CalibrationTurnCompletedEvent {
+    type: 'turn-completed';
+    variantName: string;
+    turnNumber: number;
+    executionId: string;
+    timestamp: number;
+}
+interface CalibrationSessionCompletedEvent {
+    type: 'session-completed';
+    variantName: string;
+    sessionId: string;
+    turnCount: number;
+    timestamp: number;
+}
+interface CalibrationGradingStartedEvent {
+    type: 'grading-started';
+    variantName: string;
+    timestamp: number;
+}
+interface CalibrationGradingCompletedEvent {
+    type: 'grading-completed';
+    variantName: string;
+    score: number;
+    timestamp: number;
+}
+interface CalibrationGradingFailedEvent {
+    type: 'grading-failed';
+    variantName: string;
+    error: string;
+    timestamp: number;
+}
+interface CalibrationCompletedEvent {
+    type: 'calibration-completed';
+    summary: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+    timestamp: number;
+}
+interface CalibrationFailedEvent {
+    type: 'calibration-failed';
+    error: string;
+    timestamp: number;
+}
+interface CalibrationConnectedEvent {
+    type: 'connected';
+    timestamp: number;
+    data?: undefined;
+}
+/**
+ * Union of all calibration SSE events
+ */
+type CalibrationSSEEvent = CalibrationExecutionStartedEvent | CalibrationExecutionCompletedEvent | CalibrationExecutionFailedEvent | CalibrationSessionStartedEvent | CalibrationTurnStartedEvent | CalibrationTurnCompletedEvent | CalibrationSessionCompletedEvent | CalibrationGradingStartedEvent | CalibrationGradingCompletedEvent | CalibrationGradingFailedEvent | CalibrationCompletedEvent | CalibrationFailedEvent | CalibrationConnectedEvent;
+
 /**
  * Execution history item.
  * Represents a single execution triggered by a schedule.
@@ -4478,6 +5387,154 @@ declare const ExecutionHistoryResponseSchema: z.ZodObject<{
 type ExecutionHistoryItem = z.infer<typeof ExecutionHistoryItemSchema>;
 type ExecutionHistoryResponse = z.infer<typeof ExecutionHistoryResponseSchema>;
 
+/**
+ * Calibration Lab Type Definitions
+ * Core types for AI model configuration optimization with cost/performance comparison
+ */
+
+/**
+ * Calibration project - groups related optimization runs
+ * Provides organizational structure for iterative testing
+ */
+interface CalibrationProject {
+    id: string;
+    organizationId: string;
+    resourceId: string;
+    resourceType: 'agent' | 'workflow';
+    name: string;
+    description?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Configuration variant for testing
+ * Defines what to override in the base agent/workflow definition
+ */
+interface ConfigVariant {
+    variantName: string;
+    definitionOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+}
+/**
+ * Agent definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type AgentCalibrationOverrides = Omit<Partial<AgentDefinition>, 'config' | 'contract' | 'tools' | 'metricsConfig' | 'interface'>;
+/**
+ * Workflow definition overrides for calibration
+ * Excludes identity/metadata fields that should not be modified
+ */
+type WorkflowCalibrationOverrides = Omit<Partial<WorkflowDefinition>, 'config' | 'contract' | 'steps' | 'entryPoint' | 'metricsConfig' | 'interface'>;
+/**
+ * Grading rubric for LLM-as-judge evaluation
+ * Defines criteria and passing threshold
+ */
+interface GradingRubric {
+    passingThreshold: number;
+    criteria: GradingCriterion[];
+}
+/**
+ * Individual grading criterion
+ * Weight should be 0-1, and all weights should sum to 1
+ */
+interface GradingCriterion {
+    name: string;
+    weight: number;
+    description: string;
+    scoringGuide: string;
+}
+/**
+ * Grading result for a single execution or session
+ * Contains overall score and per-criterion breakdown
+ */
+interface GradeResult {
+    score: number;
+    passed: boolean;
+    details: Record<string, {
+        score: number;
+        justification: string;
+    }>;
+}
+/**
+ * Single-turn calibration result
+ * One result per (variant × input) combination
+ */
+interface SingleCalibrationResult {
+    executionId: string;
+    variantName: string;
+    inputIndex: number;
+    appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    errorMessage?: string;
+    grade?: GradeResult;
+    gradeError?: string;
+}
+/**
+ * Multi-turn session calibration result
+ * Leverages existing sessions infrastructure
+ */
+interface SessionCalibrationResult {
+    sessionId: string;
+    variantName: string;
+    appliedOverrides?: AgentCalibrationOverrides | WorkflowCalibrationOverrides;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    errorMessage?: string;
+    turnCount: number;
+    grade?: GradeResult;
+    gradeError?: string;
+}
+/**
+ * Calibration run - individual test execution within a project
+ * Contains configuration, results, and grading information
+ */
+interface CalibrationRun {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    name: string;
+    description?: string | null;
+    executionMode: 'single' | 'session';
+    testInputs: unknown[];
+    configVariants: ConfigVariant[];
+    gradingRubric?: GradingRubric | null;
+    graderModel?: string | null;
+    results: (SingleCalibrationResult | SessionCalibrationResult)[];
+    status: 'pending' | 'running' | 'completed' | 'partial' | 'failed';
+    createdAt: Date;
+    completedAt?: Date | null;
+}
+/**
+ * Execution log subset for comparison view
+ * Contains essential data without full execution context
+ */
+interface ExecutionLog {
+    executionId: string;
+    status: 'running' | 'completed' | 'failed';
+    input: unknown;
+    output: unknown | null;
+    error: CalibrationExecutionError | null;
+    startedAt: string;
+    completedAt: string | null;
+}
+/**
+ * Execution error information for calibration display
+ * Subset of full execution error for UI display purposes
+ * Named differently from ExecutionError class to avoid type conflicts
+ */
+interface CalibrationExecutionError {
+    message: string;
+    category?: string;
+    type?: string;
+}
+/**
+ * Combined calibration run data for comparison view
+ * Single API call returns run + execution logs + metrics
+ */
+interface CalibrationRunWithFullData {
+    run: CalibrationRun;
+    logs: Record<string, ExecutionLog>;
+    metrics: Record<string, ExecutionMetricsDetail>;
+}
+
 /**
  * Deployment types — browser-safe
  *
@@ -5993,6 +7050,110 @@ interface UseResourceExecutionsOptions {
  */
 declare function useResourceExecutions({ resourceId, timeRange, enabled }: UseResourceExecutionsOptions): _tanstack_react_query.UseQueryResult<ResourceExecutionsResponse, Error>;
 
+/**
+ * Query key factory for calibration hooks.
+ * Ensures consistent, organization-scoped cache isolation.
+ */
+declare const calibrationKeys: {
+    all: readonly ["calibration"];
+    projects: (org: string) => readonly ["calibration", "projects", string];
+    projectsByResource: (org: string, resourceId: string, resourceType: string) => readonly ["calibration", "projects", string, string, string];
+    project: (org: string, projectId: string) => readonly ["calibration", "project", string, string];
+    runs: (org: string, projectId: string) => readonly ["calibration", "runs", string, string];
+    run: (org: string, runId: string) => readonly ["calibration", "run", string, string];
+    runFull: (org: string, runId: string) => readonly ["calibration", "run-full", string, string];
+};
+
+/**
+ * Fetch all calibration projects for the organization (unified view)
+ */
+declare function useAllCalibrationProjects(): _tanstack_react_query.UseQueryResult<CalibrationProject[], Error>;
+/**
+ * Fetch calibration projects for a specific resource
+ */
+declare function useCalibrationProjects(resourceId: string, resourceType: 'agent' | 'workflow'): _tanstack_react_query.UseQueryResult<CalibrationProject[], Error>;
+declare function useCalibrationProject(projectId: string): _tanstack_react_query.UseQueryResult<CalibrationProject, Error>;
+declare function useCreateProject(): _tanstack_react_query.UseMutationResult<CalibrationProject, Error, {
+    resourceId: string;
+    resourceType: "agent" | "workflow";
+    name: string;
+    description?: string | undefined;
+}, unknown>;
+declare function useUpdateProject(): _tanstack_react_query.UseMutationResult<CalibrationProject, Error, {
+    name?: string | undefined;
+    description?: string | undefined;
+} & {
+    id: string;
+}, unknown>;
+declare function useDeleteProject(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+
+declare function useCalibrationRuns(projectId: string): _tanstack_react_query.UseQueryResult<CalibrationRun[], Error>;
+declare function useCalibrationRun(runId: string): _tanstack_react_query.UseQueryResult<CalibrationRun, Error>;
+declare function useCreateRun(): _tanstack_react_query.UseMutationResult<CalibrationRun, Error, {
+    projectId: string;
+    name: string;
+    executionMode: "single" | "session";
+    testInputs: unknown[];
+    configVariants: {
+        variantName: string;
+        definitionOverrides?: Record<string, unknown> | undefined;
+    }[];
+    description?: string | undefined;
+    gradingRubric?: {
+        passingThreshold: number;
+        criteria: {
+            name: string;
+            weight: number;
+            description: string;
+            scoringGuide: string;
+        }[];
+    } | undefined;
+    graderModel?: "gpt-5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "openrouter/z-ai/glm-5" | "mock" | undefined;
+}, unknown>;
+declare function useExecuteRun(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+declare function useDeleteRun(): _tanstack_react_query.UseMutationResult<void, Error, {
+    runId: string;
+    projectId: string;
+}, unknown>;
+declare function useGradeRun(): _tanstack_react_query.UseMutationResult<void, Error, {
+    runId: string;
+    rubric?: unknown;
+    graderModel?: string;
+}, unknown>;
+
+declare function useCalibrationRunFull(runId: string): _tanstack_react_query.UseQueryResult<CalibrationRunWithFullData, Error>;
+
+interface CalibrationProgress {
+    connected: boolean;
+    events: CalibrationSSEEvent[];
+    summary?: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+    isComplete: boolean;
+    error?: string;
+}
+interface UseCalibrationSSEOptions {
+    runId: string;
+    manager: SSEConnectionManager;
+    apiUrl: string;
+    enabled?: boolean;
+}
+declare function useCalibrationSSE({ runId, manager, apiUrl, enabled }: UseCalibrationSSEOptions): {
+    disconnect: () => void;
+    reset: () => void;
+    connected: boolean;
+    events: CalibrationSSEEvent[];
+    summary?: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+    isComplete: boolean;
+    error?: string;
+};
+
 /**
  * Hook to fetch sessions list with optional filtering.
  */
@@ -6052,5 +7213,5 @@ declare function useSessionWebSocket(sessionId: string, apiUrl: string): {
     lastTokenUsage: SessionTokenUsage | null;
 };
 
-export { OperationsService, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, createUseFeatureAccess, executionsKeys, isSessionCapable, observabilityKeys, operationsKeys, scheduleKeys, sessionsKeys, sortData, useActivities, useActivityTrend, useArchiveSession, useArchivedLogs, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount as useNotificationCountSSE, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateSchedule, useWarningNotification };
-export type { ActivityTrendResponse, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, ChatMessage, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, DocFile, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogsPageResponse, FailingResource, GetMessagesResponse, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, MessageEvent, MessageType, ResourcesResponse, RetryExecutionParams, SessionDTO, SessionExecution, SessionExecutionsResponse, SessionListItem, SessionTokenUsage, SortDirection, SortState, SubmitActionRequest, SubmitActionResponse, TaskSchedule, TopFailingResourcesParams, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseBatchedResourcesHealthParams, UseExecutionHealthParams, UseExecutionLogsParams, UseExecutionPanelStateOptions, UseExecutionPanelStateReturn, UseNotificationCountArgs, UseResourcesHealthParams, UseSSEConnectionOptions, UseScheduledTasksOptions, WebSocketState };
+export { OperationsService, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, calibrationKeys, createUseFeatureAccess, executionsKeys, isSessionCapable, observabilityKeys, operationsKeys, scheduleKeys, sessionsKeys, sortData, useActivities, useActivityTrend, useAllCalibrationProjects, useArchiveSession, useArchivedLogs, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCalibrationProject, useCalibrationProjects, useCalibrationRun, useCalibrationRunFull, useCalibrationRuns, useCalibrationSSE, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateProject, useCreateRun, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteProject, useDeleteRun, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecuteRun, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGradeRun, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount as useNotificationCountSSE, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateProject, useUpdateSchedule, useWarningNotification };
+export type { ActivityTrendResponse, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CalibrationProgress, CancelExecutionParams, CancelExecutionResult, ChatMessage, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, DocFile, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogsPageResponse, FailingResource, GetMessagesResponse, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, MessageEvent, MessageType, ResourcesResponse, RetryExecutionParams, SessionDTO, SessionExecution, SessionExecutionsResponse, SessionListItem, SessionTokenUsage, SortDirection, SortState, SubmitActionRequest, SubmitActionResponse, TaskSchedule, TopFailingResourcesParams, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseBatchedResourcesHealthParams, UseCalibrationSSEOptions, UseExecutionHealthParams, UseExecutionLogsParams, UseExecutionPanelStateOptions, UseExecutionPanelStateReturn, UseNotificationCountArgs, UseResourcesHealthParams, UseSSEConnectionOptions, UseScheduledTasksOptions, WebSocketState };