@kuntur/a2a-carbon-chat-adapter 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1380 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode } from 'react';
+
+/**
+ * Agent Configuration Types
+ */
+/**
+ * A2A Extension configuration passed to agents
+ */
+interface A2AExtensionConfig$1 {
+    settings?: {
+        thinking_group?: {
+            thinking?: boolean;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Agent Configuration
+ *
+ * Defines how to connect to an A2A agent.
+ */
+interface AgentConfig {
+    /** Unique identifier for this agent configuration */
+    id: string;
+    /** Display name shown in UI */
+    name: string;
+    /** Agent's A2A endpoint URL (without /jsonrpc suffix) */
+    url: string;
+    /** Optional API key for authentication */
+    apiKey?: string;
+    /** Optional description for agent switcher UI */
+    description?: string;
+    /** Optional icon URL for agent avatar */
+    iconUrl?: string;
+    /** Optional A2A extension configuration */
+    extensions?: A2AExtensionConfig$1;
+    /** Optional metadata for application-specific use */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Multi-agent registry for applications with multiple agents
+ */
+interface AgentRegistry {
+    /** Map of agent ID to configuration */
+    agents: Record<string, AgentConfig>;
+    /** Default agent ID to use when none specified */
+    defaultAgentId?: string;
+}
+/**
+ * Agent connection state
+ */
+type AgentConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error' | 'streaming';
+/**
+ * Agent state including connection and conversation
+ */
+interface AgentState {
+    connectionState: AgentConnectionState;
+    error?: Error;
+    taskId?: string;
+    contextId?: string;
+}
+
+/**
+ * Extension type definitions based on agentstack-sdk
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/services/llm.ts
+ */
+interface LLMDemand {
+    description?: string | null;
+    suggested?: string[] | null;
+}
+interface LLMDemands {
+    llm_demands: Record<string, LLMDemand>;
+}
+interface LLMFulfillment {
+    identifier?: string | null;
+    api_base: string;
+    api_key: string;
+    api_model: string;
+}
+interface LLMFulfillments {
+    llm_fulfillments: Record<string, LLMFulfillment>;
+}
+interface EmbeddingDemand {
+    description?: string | null;
+    suggested?: string[] | null;
+}
+interface EmbeddingDemands {
+    embedding_demands: Record<string, EmbeddingDemand>;
+}
+interface EmbeddingFulfillment {
+    api_base: string;
+    api_key: string;
+    api_model: string;
+}
+interface EmbeddingFulfillments {
+    embedding_fulfillments: Record<string, EmbeddingFulfillment>;
+}
+interface MCPDemand {
+    suggested?: string[] | null;
+}
+interface MCPDemands {
+    mcp_demands: Record<string, MCPDemand>;
+}
+interface MCPFulfillment {
+    url: string;
+}
+interface MCPFulfillments {
+    mcp_fulfillments: Record<string, MCPFulfillment>;
+}
+interface SecretDemand {
+    name?: string;
+    description?: string;
+}
+interface SecretDemands {
+    secret_demands: Record<string, SecretDemand>;
+}
+interface SecretFulfillment {
+    secret: string;
+}
+interface SecretFulfillments {
+    secret_fulfillments: Record<string, SecretFulfillment>;
+}
+interface SettingsDemands {
+    fields: unknown[];
+}
+interface SettingsFulfillments {
+    values: Record<string, unknown>;
+}
+interface FormDemands {
+    initial_form?: unknown;
+}
+interface FormFulfillments {
+    values: Record<string, unknown>;
+}
+interface OAuthDemand {
+    scopes?: string[];
+    redirect_uri?: string;
+}
+interface OAuthDemands {
+    oauth_demands: Record<string, OAuthDemand>;
+}
+interface OAuthFulfillment {
+    access_token: string;
+}
+interface OAuthFulfillments {
+    oauth_fulfillments: Record<string, OAuthFulfillment>;
+}
+interface ContextToken {
+    token: string;
+    expires_at?: string | null;
+}
+interface Fulfillments {
+    llm: (demand: LLMDemands) => Promise<LLMFulfillments>;
+    embedding: (demand: EmbeddingDemands) => Promise<EmbeddingFulfillments>;
+    mcp: (demand: MCPDemands) => Promise<MCPFulfillments>;
+    oauth: (demand: OAuthDemands) => Promise<OAuthFulfillments>;
+    settings: (demand: SettingsDemands) => Promise<SettingsFulfillments>;
+    secrets: (demand: SecretDemands) => Promise<SecretFulfillments>;
+    form: (demand: FormDemands) => Promise<FormFulfillments>;
+    oauthRedirectUri: () => string | null;
+    getContextToken: () => ContextToken;
+}
+interface ExtractedDemands {
+    llmDemands: LLMDemands | null;
+    embeddingDemands: EmbeddingDemands | null;
+    mcpDemands: MCPDemands | null;
+    oauthDemands: OAuthDemands | null;
+    settingsDemands: SettingsDemands | null;
+    secretDemands: SecretDemands | null;
+    formDemands: FormDemands | null;
+}
+
+/**
+ * Extension Handler for agent-client-zero
+ *
+ * This module handles:
+ * 1. Parsing agent card to extract extension demands
+ * 2. Building metadata with fulfillments for A2A requests
+ * 3. Parsing UI extension metadata from agent responses
+ *
+ * Reference: https://raw.githubusercontent.com/i-am-bee/agentstack/main/docs/development/custom-ui/client-sdk/extensions.mdx
+ */
+
+/**
+ * Platform configuration for fulfilling extension demands
+ * Users configure these values to provide services to agents
+ */
+interface PlatformConfig {
+    llm?: {
+        apiBase: string;
+        apiKey: string;
+        defaultModel: string;
+    };
+    embedding?: {
+        apiBase: string;
+        apiKey: string;
+        defaultModel: string;
+    };
+    mcp?: {
+        servers: Record<string, {
+            url: string;
+        }>;
+    };
+    oauth?: {
+        redirectUri: string;
+        providers: Record<string, {
+            accessToken: string;
+        }>;
+    };
+    secrets?: Record<string, string>;
+    settings?: Record<string, unknown>;
+}
+/**
+ * Extract service extension demands from agent card capabilities
+ *
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/handle-agent-card.ts
+ */
+declare function extractDemandsFromAgentCard(agentCard: AgentCard): ExtractedDemands;
+/**
+ * Build fulfillment functions based on platform configuration
+ */
+declare function buildFulfillments(config: PlatformConfig): Partial<Fulfillments>;
+/**
+ * Resolve metadata to send with A2A requests
+ * This builds the metadata object that fulfills agent extension demands
+ *
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/handle-agent-card.ts#L60-L100
+ */
+declare function resolveMetadata(demands: ExtractedDemands, fulfillments: Partial<Fulfillments>): Promise<Record<string, unknown>>;
+/**
+ * Main handler function - combines extraction and resolution
+ *
+ * Usage:
+ * ```typescript
+ * const { demands, resolveMetadata } = handleAgentCard(agentCard);
+ * const metadata = await resolveMetadata(fulfillments);
+ * await client.sendMessage(message, metadata);
+ * ```
+ */
+declare function handleAgentCard(agentCard: AgentCard): {
+    demands: ExtractedDemands;
+    resolveMetadata: (fulfillments: Partial<Fulfillments>) => Promise<Record<string, unknown>>;
+};
+
+interface AgentCard {
+    name: string;
+    url: string;
+    description?: string;
+    skills?: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    securitySchemes?: Record<string, any>;
+    capabilities?: {
+        streaming?: boolean;
+    };
+    extensions?: string[];
+}
+interface A2AExtensionConfig {
+    settings?: {
+        thinking_group?: {
+            thinking?: boolean;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface A2AClientConfig {
+    apiKey?: string;
+    extensions?: A2AExtensionConfig;
+    platformConfig?: PlatformConfig;
+}
+interface A2AError {
+    code: number;
+    message: string;
+    data?: any;
+}
+interface A2AMessagePart {
+    kind: 'text' | 'file' | 'data';
+    text?: string;
+    file?: {
+        name: string;
+        mimeType: string;
+        bytes?: string;
+        uri?: string;
+    };
+    data?: Record<string, unknown>;
+}
+interface A2AMessage {
+    role: string;
+    messageId: string;
+    parts: A2AMessagePart[];
+}
+interface StreamChunk {
+    contextId?: string;
+    taskId?: string;
+    kind: 'status-update' | 'artifact-update';
+    status?: {
+        state: 'submitted' | 'working' | 'completed' | 'failed' | 'canceled' | 'input-required' | 'auth-required';
+        message?: A2AMessage & {
+            metadata?: Record<string, unknown>;
+        };
+    };
+    artifact?: {
+        artifactId: string;
+        name?: string;
+        description?: string;
+        parts: A2AMessagePart[];
+        metadata?: Record<string, unknown>;
+    };
+    final?: boolean;
+}
+declare class A2AClient {
+    private baseUrl;
+    private jsonRpcUrl;
+    private apiKey;
+    private extensions;
+    private agentCard;
+    private platformConfig;
+    private extractedDemands;
+    private fulfillments;
+    constructor(agentUrl: string, config?: A2AClientConfig);
+    /**
+     * Get configured extensions
+     */
+    getExtensions(): A2AExtensionConfig;
+    /**
+     * Update extension configuration
+     */
+    setExtensions(extensions: A2AExtensionConfig): void;
+    initialize(): Promise<AgentCard>;
+    getAgentCard(): AgentCard | null;
+    getJsonRpcUrl(): string;
+    /**
+     * Get resolved metadata for A2A requests
+     * Call this after initialize() to get metadata that fulfills agent demands
+     */
+    getResolvedMetadata(): Promise<Record<string, unknown>>;
+    /**
+     * Get extracted demands from agent card
+     */
+    getExtractedDemands(): ExtractedDemands | null;
+    /**
+     * Update platform configuration after initialization
+     */
+    setPlatformConfig(config: PlatformConfig): void;
+    /**
+     * Get current platform configuration
+     */
+    getPlatformConfig(): PlatformConfig | null;
+    /**
+     * Build the base params object for A2A requests
+     */
+    private buildRequestParams;
+    sendMessage(message: string): Promise<any>;
+    streamMessage(message: string, onChunk: (chunk: StreamChunk) => void | Promise<void>, onComplete?: () => void | Promise<void>): Promise<void>;
+}
+
+/**
+ * A2A Extension URIs
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/
+ */
+declare const EXTENSION_URIS: {
+    readonly LLM: "https://a2a-extensions.agentstack.beeai.dev/services/llm/v1";
+    readonly EMBEDDING: "https://a2a-extensions.agentstack.beeai.dev/services/embedding/v1";
+    readonly MCP: "https://a2a-extensions.agentstack.beeai.dev/services/mcp/v1";
+    readonly OAUTH_PROVIDER: "https://a2a-extensions.agentstack.beeai.dev/services/oauth-provider/v1";
+    readonly SECRETS: "https://a2a-extensions.agentstack.beeai.dev/services/secrets/v1";
+    readonly PLATFORM_API: "https://a2a-extensions.agentstack.beeai.dev/services/platform-api/v1";
+    readonly FORM_SERVICE: "https://a2a-extensions.agentstack.beeai.dev/services/form/v1";
+    readonly CITATION: "https://a2a-extensions.agentstack.beeai.dev/ui/citation/v1";
+    readonly TRAJECTORY: "https://a2a-extensions.agentstack.beeai.dev/ui/trajectory/v1";
+    readonly ERROR: "https://a2a-extensions.agentstack.beeai.dev/ui/error/v1";
+    readonly FORM_REQUEST: "https://a2a-extensions.agentstack.beeai.dev/ui/form-request/v1";
+    readonly CANVAS: "https://a2a-extensions.agentstack.beeai.dev/ui/canvas/v1";
+    readonly AGENT_DETAIL: "https://a2a-extensions.agentstack.beeai.dev/ui/agent-detail/v1";
+    readonly OAUTH_REQUEST: "https://a2a-extensions.agentstack.beeai.dev/ui/oauth/v1";
+    readonly SETTINGS: "https://a2a-extensions.agentstack.beeai.dev/ui/settings/v1";
+};
+type ExtensionUri = typeof EXTENSION_URIS[keyof typeof EXTENSION_URIS];
+
+/**
+ * UI Extension Metadata Parser
+ *
+ * Parses metadata from agent responses to extract UI extension data
+ * for rendering citations, trajectories, errors, forms, etc.
+ *
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-ui/src/api/a2a/utils.ts
+ */
+/**
+ * Citation metadata structure
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/ui/citation.ts
+ */
+interface Citation {
+    url?: string | null;
+    start_index?: number | null;
+    end_index?: number | null;
+    title?: string | null;
+    description?: string | null;
+}
+interface CitationMetadata {
+    citations: Citation[];
+}
+/**
+ * Trajectory metadata structure
+ * Reference: https://github.com/i-am-bee/agentstack/blob/main/apps/agentstack-sdk-ts/src/client/a2a/extensions/ui/trajectory.ts
+ */
+interface TrajectoryMetadata {
+    title?: string | null;
+    content?: string | null;
+    group_id?: string | null;
+}
+/**
+ * Error metadata structure
+ */
+interface ErrorMetadata {
+    message: string;
+    code?: string | null;
+    stacktrace?: string | null;
+    context?: Record<string, unknown> | null;
+}
+/**
+ * Form request metadata structure
+ */
+interface FormField {
+    id: string;
+    type: 'text' | 'date' | 'file' | 'single_select' | 'multi_select' | 'checkbox' | 'checkbox_group';
+    label: string;
+    description?: string;
+    required?: boolean;
+    default_value?: unknown;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    col_span?: number;
+}
+interface FormRequestMetadata {
+    title?: string;
+    description?: string;
+    columns?: number;
+    submit_label?: string;
+    fields: FormField[];
+}
+/**
+ * Canvas edit request metadata
+ */
+interface CanvasEditMetadata {
+    artifact_id: string;
+    start_index: number;
+    end_index: number;
+    description: string;
+}
+/**
+ * Agent detail metadata
+ */
+interface AgentDetailMetadata {
+    interaction_mode?: 'single-turn' | 'multi-turn';
+    user_greeting?: string;
+    version?: string;
+    framework?: string;
+    source_code_url?: string;
+    tools?: Array<{
+        name: string;
+        description: string;
+    }>;
+    skills?: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    contributors?: Array<{
+        name: string;
+        url?: string;
+    }>;
+}
+/**
+ * Parsed UI extensions from message metadata
+ */
+interface ParsedUIExtensions {
+    citations?: CitationMetadata;
+    trajectory?: TrajectoryMetadata;
+    error?: ErrorMetadata;
+    formRequest?: FormRequestMetadata;
+    canvas?: CanvasEditMetadata;
+    agentDetail?: AgentDetailMetadata;
+}
+/**
+ * Extract UI extension data from message metadata
+ */
+declare function parseUIExtensions(metadata: Record<string, unknown> | undefined): ParsedUIExtensions;
+/**
+ * Extract citations from message metadata
+ * Convenience function for citation-specific extraction
+ */
+declare function extractCitations(metadata: Record<string, unknown> | undefined): Citation[];
+/**
+ * Extract trajectory from message metadata
+ * Convenience function for trajectory-specific extraction
+ */
+declare function extractTrajectory(metadata: Record<string, unknown> | undefined): TrajectoryMetadata | null;
+/**
+ * Extract error from message metadata
+ */
+declare function extractError(metadata: Record<string, unknown> | undefined): ErrorMetadata | null;
+/**
+ * Extract form request from message metadata
+ */
+declare function extractFormRequest(metadata: Record<string, unknown> | undefined): FormRequestMetadata | null;
+
+/**
+ * Chat Component Types
+ */
+
+/**
+ * Layout modes for the chat interface
+ */
+type ChatLayout = 'fullscreen' | 'sidebar' | 'float';
+/**
+ * Props for the main A2AChat component
+ */
+interface A2AChatProps {
+    /**
+     * Full agent configuration object
+     * Use this for complete control over agent settings
+     */
+    agent?: AgentConfig;
+    /**
+     * Agent ID to look up from AgentProvider context
+     * Use this when agents are registered in a parent AgentProvider
+     */
+    agentId?: string;
+    /**
+     * Simple URL-only configuration
+     * Use this for quick single-agent setups
+     */
+    agentUrl?: string;
+    /**
+     * API key (used with agentUrl)
+     */
+    apiKey?: string;
+    /**
+     * Layout mode
+     * @default 'fullscreen'
+     */
+    layout?: ChatLayout;
+    /**
+     * Allow user to switch layouts
+     * @default false
+     */
+    allowLayoutSwitch?: boolean;
+    /**
+     * Initial open state (for sidebar/float layouts)
+     * @default true for fullscreen, false for others
+     */
+    defaultOpen?: boolean;
+    /**
+     * Custom CSS class name
+     */
+    className?: string;
+    /**
+     * Override agent display name
+     */
+    agentName?: string;
+    /**
+     * Override agent icon
+     */
+    agentIconUrl?: string;
+    /**
+     * Show thinking/reasoning accordion
+     * @default true
+     */
+    showThinking?: boolean;
+    /**
+     * Show chain of thought steps
+     * @default true
+     */
+    showChainOfThought?: boolean;
+    /**
+     * Enable streaming cancellation
+     * @default true
+     */
+    allowCancel?: boolean;
+    /**
+     * A2A extension configuration to send with messages
+     */
+    extensions?: A2AExtensionConfig$1;
+    /**
+     * Called when chat is opened
+     */
+    onOpen?: () => void;
+    /**
+     * Called when chat is closed (sidebar/float only)
+     */
+    onClose?: () => void;
+    /**
+     * Called when user sends a message
+     */
+    onSend?: (message: string) => void;
+    /**
+     * Called when agent responds
+     */
+    onResponse?: (response: unknown) => void;
+    /**
+     * Called on connection state change
+     */
+    onConnectionChange?: (state: AgentConnectionState) => void;
+    /**
+     * Called on error
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when user wants to disconnect/switch agents
+     */
+    onDisconnect?: () => void;
+    /**
+     * Custom renderer for citations
+     */
+    renderCitations?: (citations: Citation[], text: string) => ReactNode;
+    /**
+     * Custom renderer for errors
+     */
+    renderError?: (error: ErrorMetadata) => ReactNode;
+    /**
+     * Custom renderer for forms
+     */
+    renderForm?: (form: FormRequestMetadata, onSubmit: (values: Record<string, unknown>) => void) => ReactNode;
+    /**
+     * Custom renderer for user-defined response types
+     */
+    renderUserDefined?: (data: unknown, messageItem: unknown) => ReactNode;
+}
+
+/**
+ * Provider Types
+ */
+
+/**
+ * Props for AgentProvider component
+ */
+interface AgentProviderProps {
+    children: ReactNode;
+    /**
+     * Single agent configuration
+     * Use for simple single-agent apps
+     */
+    agent?: AgentConfig;
+    /**
+     * Multiple agent configurations
+     * Use for apps with multiple agents
+     */
+    agents?: AgentConfig[];
+    /**
+     * Full registry with default selection
+     * Use for complex multi-agent scenarios
+     */
+    registry?: AgentRegistry;
+    /**
+     * Default agent ID when multiple agents provided
+     */
+    defaultAgentId?: string;
+    /**
+     * Persist selected agent to localStorage
+     * @default false
+     */
+    persistSelection?: boolean;
+    /**
+     * Storage key for persisted selection
+     * @default 'a2a-chat-selected-agent'
+     */
+    storageKey?: string;
+}
+/**
+ * Context value provided by AgentProvider
+ */
+interface AgentContextValue {
+    /** Currently selected agent config */
+    currentAgent: AgentConfig | null;
+    /** All available agents */
+    agents: AgentConfig[];
+    /** Select a different agent by ID */
+    selectAgent: (agentId: string) => void;
+    /** Get agent config by ID */
+    getAgent: (agentId: string) => AgentConfig | undefined;
+    /** Check if an agent ID exists */
+    hasAgent: (agentId: string) => boolean;
+}
+
+/**
+ * Types for UI extension renderers
+ */
+
+/**
+ * Processed citation for rendering
+ * Includes computed display properties
+ */
+interface ProcessedCitation extends Citation {
+    id: string;
+    number: number;
+    highlightedText: string;
+}
+/**
+ * Text segment with optional citation reference
+ */
+interface TextSegment {
+    text: string;
+    citation?: ProcessedCitation;
+    isCited: boolean;
+}
+/**
+ * Props for CitationRenderer component
+ */
+interface CitationRendererProps {
+    text: string;
+    citations: Citation[];
+    className?: string;
+}
+/**
+ * Props for ErrorRenderer component
+ */
+interface ErrorRendererProps {
+    error: ErrorMetadata;
+    className?: string;
+}
+/**
+ * Props for FormRenderer component
+ */
+interface FormRendererProps {
+    form: FormRequestMetadata;
+    onSubmit: (values: Record<string, unknown>) => void;
+    onCancel?: () => void;
+    className?: string;
+}
+
+/**
+ * Citation Renderer Component
+ *
+ * Renders text with inline citation highlights and a sources list.
+ * Citations appear as highlighted text with superscript numbers.
+ * Hovering shows a tooltip with source details.
+ * Clicking navigates to the source URL.
+ *
+ * Reference: https://raw.githubusercontent.com/i-am-bee/agentstack/main/docs/development/agent-integration/citations.mdx
+ */
+
+/**
+ * Main Citation Renderer Component
+ */
+declare const CitationRenderer: React.FC<CitationRendererProps>;
+
+/**
+ * Error Renderer Component
+ *
+ * Renders error messages from agent responses with
+ * optional stack trace and context information.
+ */
+
+/**
+ * Error Renderer Component
+ */
+declare const ErrorRenderer: React.FC<ErrorRendererProps>;
+
+/**
+ * Form Renderer Component
+ *
+ * Renders dynamic forms from agent form request metadata.
+ * Supports text, date, file, select, checkbox, and multi-select fields.
+ */
+
+/**
+ * Main Form Renderer Component
+ */
+declare const FormRenderer: React.FC<FormRendererProps>;
+
+/**
+ * Citation processing utilities
+ *
+ * Reference: https://raw.githubusercontent.com/i-am-bee/agentstack/main/docs/development/agent-integration/citations.mdx
+ */
+
+/**
+ * Process raw citations into renderable format
+ * Assigns numbers and extracts highlighted text
+ */
+declare function processCitations(text: string, citations: Citation[]): ProcessedCitation[];
+/**
+ * Segment text into parts with and without citations
+ * Returns array of segments for rendering
+ */
+declare function segmentTextWithCitations(text: string, citations: Citation[]): TextSegment[];
+/**
+ * Get unique citations (deduplicated by URL)
+ */
+declare function getUniqueCitations(citations: ProcessedCitation[]): ProcessedCitation[];
+
+/**
+ * Main A2A Chat component
+ *
+ * Connects to A2A agents and renders chat UI using Carbon AI Chat components.
+ *
+ * @example
+ * // Direct agent config
+ * <A2AChat
+ *   agent={{ id: 'my-agent', name: 'My Agent', url: 'https://...' }}
+ *   layout="sidebar"
+ * />
+ *
+ * @example
+ * // Using AgentProvider context
+ * <AgentProvider agents={[...]}>
+ *   <A2AChat agentId="research" />
+ * </AgentProvider>
+ *
+ * @example
+ * // Simple URL-only
+ * <A2AChat agentUrl="https://my-agent.example.com" layout="fullscreen" />
+ */
+declare function A2AChat({ agent: agentProp, agentId, agentUrl, apiKey, layout, allowLayoutSwitch, defaultOpen, className, agentName, agentIconUrl, showThinking, showChainOfThought, allowCancel, extensions, onOpen, onClose, onSend, onResponse, onConnectionChange, onError, onDisconnect, renderCitations, renderError, renderForm, renderUserDefined, }: A2AChatProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hook to access agent context
+ * Must be used within an AgentProvider
+ */
+declare function useAgentContext(): AgentContextValue;
+/**
+ * Optional hook that returns null if not within provider
+ * Useful for components that work both with and without provider
+ */
+declare function useAgentContextOptional(): AgentContextValue | null;
+/**
+ * Provider for managing agent configurations
+ *
+ * @example
+ * // Single agent
+ * <AgentProvider agent={{ id: 'main', name: 'Assistant', url: '...' }}>
+ *   <App />
+ * </AgentProvider>
+ *
+ * @example
+ * // Multiple agents
+ * <AgentProvider
+ *   agents={[
+ *     { id: 'research', name: 'Research', url: '...' },
+ *     { id: 'code', name: 'Coder', url: '...' },
+ *   ]}
+ *   defaultAgentId="research"
+ *   persistSelection
+ * >
+ *   <App />
+ * </AgentProvider>
+ */
+declare function AgentProvider({ children, agent, agents: agentsProp, registry, defaultAgentId, persistSelection, storageKey, }: AgentProviderProps): ReactNode;
+
+interface AgentSwitcherProps {
+    /** Available agents */
+    agents: AgentConfig[];
+    /** Currently selected agent ID */
+    currentAgentId?: string;
+    /** Called when user selects an agent */
+    onSelect: (agentId: string) => void;
+    /** Variant style */
+    variant?: 'dropdown' | 'tabs' | 'cards';
+    /** Show agent descriptions */
+    showDescriptions?: boolean;
+    /** Show agent icons */
+    showIcons?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Label text */
+    label?: string;
+}
+/**
+ * Component for switching between multiple agents
+ *
+ * @example
+ * const { agents, currentAgent, selectAgent } = useAgentContext();
+ *
+ * <AgentSwitcher
+ *   agents={agents}
+ *   currentAgentId={currentAgent?.id}
+ *   onSelect={selectAgent}
+ * />
+ */
+declare function AgentSwitcher({ agents, currentAgentId, onSelect, variant, showDescriptions, showIcons, className, disabled, label, }: AgentSwitcherProps): react_jsx_runtime.JSX.Element | null;
+
+interface UseA2AAgentOptions {
+    /** Agent configuration (or use agentId with AgentProvider) */
+    agent?: AgentConfig;
+    /** Agent ID to look up from context */
+    agentId?: string;
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** Callbacks */
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onError?: (error: Error) => void;
+    onMessage?: (message: any) => void;
+}
+interface UseA2AAgentReturn {
+    /** Current agent configuration */
+    agent: AgentConfig | null;
+    /** Connection state */
+    state: AgentState;
+    /** Send a message to the agent */
+    sendMessage: (message: string) => Promise<any>;
+    /** Cancel current streaming response */
+    cancelStream: () => void;
+    /** Disconnect from agent */
+    disconnect: () => void;
+    /** Reconnect to agent */
+    reconnect: () => void;
+    /** Clear conversation history */
+    clearHistory: () => void;
+    /** Whether currently streaming */
+    isStreaming: boolean;
+    /** Whether connected */
+    isConnected: boolean;
+    /** Last error */
+    error: Error | null;
+}
+/**
+ * Hook for interacting with an A2A agent programmatically
+ *
+ * @example
+ * // With direct config
+ * const { sendMessage, isStreaming } = useA2AAgent({
+ *   agent: { id: 'my-agent', name: 'My Agent', url: 'https://...' }
+ * });
+ *
+ * @example
+ * // With context provider
+ * const { sendMessage } = useA2AAgent({ agentId: 'research-agent' });
+ */
+declare function useA2AAgent(options?: UseA2AAgentOptions): UseA2AAgentReturn;
+
+interface UseMultiAgentOptions {
+    /** Initial agents to register */
+    agents?: AgentConfig[];
+    /** Default agent ID */
+    defaultAgentId?: string;
+    /** Called when agent changes */
+    onAgentChange?: (agent: AgentConfig) => void;
+}
+interface UseMultiAgentReturn {
+    /** All registered agents */
+    agents: AgentConfig[];
+    /** Currently active agent */
+    currentAgent: AgentConfig | null;
+    /** Switch to a different agent */
+    switchAgent: (agentId: string) => void;
+    /** Register a new agent */
+    registerAgent: (agent: AgentConfig) => void;
+    /** Unregister an agent */
+    unregisterAgent: (agentId: string) => void;
+    /** Update an existing agent's config */
+    updateAgent: (agentId: string, updates: Partial<AgentConfig>) => void;
+    /** Get agent by ID */
+    getAgent: (agentId: string) => AgentConfig | undefined;
+    /** Check if agent exists */
+    hasAgent: (agentId: string) => boolean;
+}
+/**
+ * Hook for managing multiple agents without using AgentProvider
+ *
+ * @example
+ * const { currentAgent, switchAgent, agents } = useMultiAgent({
+ *   agents: [
+ *     { id: 'research', name: 'Research Agent', url: '...' },
+ *     { id: 'code', name: 'Code Agent', url: '...' },
+ *   ],
+ *   defaultAgentId: 'research'
+ * });
+ */
+declare function useMultiAgent(options?: UseMultiAgentOptions): UseMultiAgentReturn;
+
+/**
+ * A2A to Carbon AI Chat Translator
+ *
+ * Translates A2A protocol streaming events to Carbon AI Chat's expected format.
+ *
+ * References:
+ * - Carbon AI Chat streaming: https://github.com/carbon-design-system/carbon-ai-chat/blob/main/examples/react/reasoning-and-chain-of-thought/src/scenarios.ts
+ * - A2A Protocol types: https://github.com/a2aproject/a2a-python/blob/main/src/a2a/types.py
+ */
+
+/**
+ * Carbon message response types
+ */
+declare const MessageResponseTypes: {
+    readonly TEXT: "text";
+    readonly USER_DEFINED: "user_defined";
+    readonly INLINE_ERROR: "inline_error";
+    readonly OPTION: "option";
+};
+type MessageResponseType = typeof MessageResponseTypes[keyof typeof MessageResponseTypes];
+/**
+ * Chain of thought step status
+ */
+declare enum ChainOfThoughtStepStatus {
+    IN_PROGRESS = "in_progress",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+/**
+ * Reasoning step open state
+ */
+declare enum ReasoningStepOpenState {
+    OPEN = "open",
+    CLOSE = "close",
+    DEFAULT = "default"
+}
+/**
+ * User type for response profile
+ */
+declare enum UserType {
+    HUMAN = "human",
+    BOT = "bot",
+    WATSONX = "watsonx"
+}
+/**
+ * Response user profile
+ */
+interface ResponseUserProfile {
+    id: string;
+    nickname: string;
+    user_type: UserType;
+    profile_picture_url?: string;
+}
+/**
+ * Reasoning step structure
+ */
+interface ReasoningStep {
+    title: string;
+    content?: string;
+    open_state?: ReasoningStepOpenState;
+}
+/**
+ * Chain of thought step structure
+ */
+interface ChainOfThoughtStep {
+    title: string;
+    description?: string;
+    tool_name?: string;
+    request?: {
+        args: unknown;
+    };
+    response?: {
+        content: unknown;
+    };
+    status: ChainOfThoughtStepStatus;
+}
+/**
+ * Message response options
+ */
+interface MessageResponseOptions {
+    response_user_profile?: ResponseUserProfile;
+    reasoning?: {
+        open_state?: ReasoningStepOpenState;
+        steps?: ReasoningStep[];
+        content?: string;
+    };
+    chain_of_thought?: ChainOfThoughtStep[];
+}
+/**
+ * Item streaming metadata
+ */
+interface ItemStreamingMetadata {
+    id: string;
+    cancellable?: boolean;
+    stream_stopped?: boolean;
+}
+/**
+ * Generic item (text response)
+ */
+interface TextItem {
+    response_type: typeof MessageResponseTypes.TEXT;
+    text: string;
+    streaming_metadata?: ItemStreamingMetadata;
+    message_item_options?: {
+        feedback?: {
+            is_on?: boolean;
+            id?: string;
+        };
+    };
+}
+/**
+ * User defined item (custom content)
+ */
+interface UserDefinedItem {
+    response_type: typeof MessageResponseTypes.USER_DEFINED;
+    user_defined: Record<string, unknown>;
+}
+/**
+ * Generic item union type
+ */
+type GenericItem = TextItem | UserDefinedItem;
+/**
+ * Partial item chunk for streaming
+ */
+interface PartialItemChunk {
+    partial_item: Partial<GenericItem> & {
+        response_type: MessageResponseType;
+        streaming_metadata?: ItemStreamingMetadata;
+    };
+    partial_response?: {
+        message_options?: Partial<MessageResponseOptions>;
+    };
+    streaming_metadata: {
+        response_id: string;
+    };
+}
+/**
+ * Complete item chunk
+ */
+interface CompleteItemChunk {
+    complete_item: GenericItem;
+    partial_response?: {
+        message_options?: Partial<MessageResponseOptions>;
+    };
+    streaming_metadata: {
+        response_id: string;
+    };
+}
+/**
+ * Final response chunk
+ */
+interface FinalResponseChunk {
+    final_response: {
+        id: string;
+        output: {
+            generic: GenericItem[];
+        };
+        message_options?: MessageResponseOptions;
+    };
+}
+/**
+ * Stream chunk union type
+ */
+type CarbonStreamChunk = PartialItemChunk | CompleteItemChunk | FinalResponseChunk;
+/**
+ * Carbon message for addMessage() API
+ */
+interface CarbonMessage {
+    output: {
+        generic: GenericItem[];
+    };
+    message_options?: MessageResponseOptions;
+}
+/**
+ * Legacy Carbon Message format (used by EnhancedChatWrapper)
+ * This is the older format that works with Carbon's addMessage() API directly
+ */
+interface LegacyCarbonMessage {
+    response_type: string;
+    text?: string;
+    reasoning_steps?: {
+        steps: Array<{
+            content: string;
+        }>;
+        openState?: 'open' | 'closed';
+    };
+    chain_of_thought?: {
+        steps: ChainOfThoughtStep[];
+    };
+    user_defined?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Extended A2A part with metadata support
+ */
+interface A2APartWithMetadata extends A2AMessagePart {
+    metadata?: {
+        content_type?: 'thinking' | 'reasoning_step' | 'response' | 'status' | string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Tool call data structure
+ */
+interface ToolCallData {
+    type: 'tool_call';
+    tool_name?: string;
+    args?: unknown;
+}
+/**
+ * Tool result data structure
+ */
+interface ToolResultData {
+    type: 'tool_result';
+    tool_name?: string;
+    result_preview?: unknown;
+    success?: boolean;
+}
+/**
+ * Translator state for tracking streaming progress
+ */
+interface TranslatorState {
+    responseId: string;
+    itemId: string;
+    accumulatedText: string;
+    reasoningSteps: ReasoningStep[];
+    chainOfThought: ChainOfThoughtStep[];
+    pendingToolCalls: Map<string, number>;
+    hasStartedStreaming: boolean;
+    shellMessageSent: boolean;
+}
+/**
+ * A2A to Carbon AI Chat Translator
+ *
+ * Manages the translation of A2A streaming events to Carbon AI Chat format.
+ * Maintains state across multiple chunks to properly accumulate text and
+ * track reasoning/tool call progress.
+ */
+declare class A2AToCarbonTranslator {
+    private state;
+    private agentProfile;
+    constructor(agentProfile?: Partial<ResponseUserProfile>);
+    /**
+     * Create initial translator state
+     */
+    private createInitialState;
+    /**
+     * Generate unique response ID
+     */
+    private generateResponseId;
+    /**
+     * Reset state for new message
+     */
+    reset(): void;
+    /**
+     * Get current response ID
+     */
+    getResponseId(): string;
+    /**
+     * Get current item ID
+     */
+    getItemId(): string;
+    /**
+     * Update agent profile
+     */
+    setAgentProfile(profile: Partial<ResponseUserProfile>): void;
+    /**
+     * Get current agent profile
+     */
+    getAgentProfile(): ResponseUserProfile;
+    /**
+     * Check if shell message has been sent
+     */
+    hasShellBeenSent(): boolean;
+    /**
+     * Mark shell message as sent
+     */
+    markShellSent(): void;
+    /**
+     * Get accumulated text
+     */
+    getAccumulatedText(): string;
+    /**
+     * Get current reasoning steps
+     */
+    getReasoningSteps(): ReasoningStep[];
+    /**
+     * Get current chain of thought
+     */
+    getChainOfThought(): ChainOfThoughtStep[];
+    /**
+     * Check if streaming has started
+     */
+    hasStartedStreaming(): boolean;
+    /**
+     * Get current state (for debugging/inspection)
+     */
+    getState(): Readonly<TranslatorState>;
+    /**
+     * Create shell message to initialize Carbon's reducer
+     *
+     * IMPORTANT: This MUST be called before sending any other chunks.
+     * It seeds the message shell so reducers create the container before
+     * reasoning steps or text stream in.
+     */
+    createShellMessage(includeReasoning?: boolean): PartialItemChunk;
+    /**
+     * Translate a single streaming A2A part to a legacy Carbon message
+     * Used for real-time streaming updates (backward compatibility with EnhancedChatWrapper)
+     * @param part The A2A part to translate
+     * @param metadata Optional extension metadata from the artifact
+     */
+    translateStreamingPart(part: A2APartWithMetadata, metadata?: Record<string, unknown>): LegacyCarbonMessage | null;
+    /**
+     * Translate an A2A message part to Carbon format
+     *
+     * @param part - The A2A message part to translate
+     * @param artifactMetadata - Optional metadata from artifact level
+     * @returns Carbon stream chunk or null if no action needed
+     */
+    translatePart(part: A2APartWithMetadata, artifactMetadata?: Record<string, unknown>): CarbonStreamChunk | null;
+    /**
+     * Translate thinking/reasoning content to Carbon reasoning step
+     */
+    private translateThinkingPart;
+    /**
+     * Translate trajectory extension to Carbon reasoning step
+     */
+    private translateTrajectoryPart;
+    /**
+     * Translate tool call to Carbon chain of thought (IN_PROGRESS)
+     */
+    private translateToolCallPart;
+    /**
+     * Translate tool result to Carbon chain of thought (SUCCESS/ERROR)
+     */
+    private translateToolResultPart;
+    /**
+     * Translate text part to Carbon partial item
+     */
+    private translateTextPart;
+    /**
+     * Translate file part to Carbon user defined item
+     */
+    private translateFilePart;
+    /**
+     * Create complete item chunk
+     *
+     * Call this to finalize a specific item while other items may still be streaming.
+     * Optional but useful for accessibility and corrections.
+     */
+    createCompleteItem(wasStopped?: boolean): CompleteItemChunk;
+    /**
+     * Create final response chunk
+     *
+     * CRITICAL: This MUST be called to end streaming and clear the typing indicator.
+     * Without this, the UI will remain in a loading state.
+     */
+    createFinalResponse(): FinalResponseChunk;
+    /**
+     * Create error response
+     */
+    createErrorResponse(errorMessage: string): FinalResponseChunk;
+    /**
+     * Create citations message
+     *
+     * Call this after the main response to add a sources list.
+     */
+    createCitationsMessage(citations: Array<{
+        url?: string | null;
+        title?: string | null;
+        description?: string | null;
+    }>): CarbonMessage;
+    /**
+     * Translate a complete A2A stream chunk to Carbon format
+     *
+     * This is the main entry point for processing A2A SSE events.
+     * Returns an array of Carbon chunks since one A2A event may produce
+     * multiple Carbon updates (e.g., multiple parts in a message).
+     */
+    translateStreamChunk(chunk: StreamChunk): CarbonStreamChunk[];
+}
+/**
+ * Create a translator with default settings
+ */
+declare function createTranslator(agentName?: string, agentIconUrl?: string): A2AToCarbonTranslator;
+/**
+ * Check if a Carbon chunk is a final response
+ */
+declare function isFinalResponse(chunk: CarbonStreamChunk): chunk is FinalResponseChunk;
+/**
+ * Check if a Carbon chunk is a partial item
+ */
+declare function isPartialItem(chunk: CarbonStreamChunk): chunk is PartialItemChunk;
+/**
+ * Check if a Carbon chunk is a complete item
+ */
+declare function isCompleteItem(chunk: CarbonStreamChunk): chunk is CompleteItemChunk;
+
+export { A2AChat, type A2AChatProps, A2AClient, type A2AClientConfig, type A2AError, type A2AExtensionConfig$1 as A2AExtensionConfig, type A2AMessage, type A2AMessagePart, type A2APartWithMetadata, A2AToCarbonTranslator, type AgentCard, type AgentConfig, type AgentConnectionState, type AgentContextValue, type AgentDetailMetadata, AgentProvider, type AgentProviderProps, type AgentRegistry, type AgentState, AgentSwitcher, type AgentSwitcherProps, type CanvasEditMetadata, type CarbonMessage, type CarbonStreamChunk, type ChainOfThoughtStep, ChainOfThoughtStepStatus, type ChatLayout, type Citation, type CitationMetadata, CitationRenderer, type CitationRendererProps, type CompleteItemChunk, EXTENSION_URIS, type ErrorMetadata, ErrorRenderer, type ErrorRendererProps, type ExtensionUri, type FinalResponseChunk, type FormField, FormRenderer, type FormRendererProps, type FormRequestMetadata, type GenericItem, type ItemStreamingMetadata, type LegacyCarbonMessage, type MessageResponseOptions, type MessageResponseType, MessageResponseTypes, type ParsedUIExtensions, type PartialItemChunk, type PlatformConfig, type ProcessedCitation, type ReasoningStep, ReasoningStepOpenState, type ResponseUserProfile, type StreamChunk, type TextItem, type TextSegment, type ToolCallData, type ToolResultData, type TrajectoryMetadata, type UseA2AAgentOptions, type UseA2AAgentReturn, type UseMultiAgentOptions, type UseMultiAgentReturn, type UserDefinedItem, UserType, buildFulfillments, createTranslator, extractCitations, extractDemandsFromAgentCard, extractError, extractFormRequest, extractTrajectory, getUniqueCitations, handleAgentCard, isCompleteItem, isFinalResponse, isPartialItem, parseUIExtensions, processCitations, resolveMetadata, segmentTextWithCitations, useA2AAgent, useAgentContext, useAgentContextOptional, useMultiAgent };