@distri/core 0.2.3 → 0.2.5

package/dist/index.d.mts

@@ -1,13 +1,20 @@
-import { AgentSkill, Message, TaskStatusUpdateEvent, TaskArtifactUpdateEvent, Task, MessageSendParams, Part } from '@a2a-js/sdk/client';
+import { MessageSendParams, Message, Task, Part, AgentSkill, TaskStatusUpdateEvent, TaskArtifactUpdateEvent } from '@a2a-js/sdk/client';
+export { AgentCard, Message, MessageSendParams, Task, TaskArtifactUpdateEvent, TaskStatus, TaskStatusUpdateEvent } from '@a2a-js/sdk/client';
 
 type Role = 'user' | 'system' | 'assistant';
 interface RunStartedEvent {
     type: 'run_started';
-    data: {};
+    data: {
+        runId?: string;
+        taskId?: string;
+    };
 }
 interface RunFinishedEvent {
     type: 'run_finished';
-    data: {};
+    data: {
+        runId?: string;
+        taskId?: string;
+    };
 }
 interface RunErrorEvent {
     type: 'run_error';
@@ -16,17 +23,38 @@ interface RunErrorEvent {
         code?: string;
     };
 }
+interface PlanStartedEvent {
+    type: 'plan_started';
+    data: {
+        initial_plan?: boolean;
+    };
+}
+interface PlanFinishedEvent {
+    type: 'plan_finished';
+    data: {
+        total_steps?: number;
+    };
+}
+interface PlanPrunedEvent {
+    type: 'plan_pruned';
+    data: {
+        removed_steps?: any;
+    };
+}
 interface TextMessageStartEvent {
     type: 'text_message_start';
     data: {
         message_id: string;
+        step_id: string;
         role: Role;
+        is_final?: boolean;
     };
 }
 interface TextMessageContentEvent {
     type: 'text_message_content';
     data: {
         message_id: string;
+        step_id: string;
         delta: string;
     };
 }
@@ -34,35 +62,29 @@ interface TextMessageEndEvent {
     type: 'text_message_end';
     data: {
         message_id: string;
+        step_id: string;
     };
 }
-interface ToolCallStartEvent {
-    type: 'tool_call_start';
+interface ToolExecutionStartEvent {
+    type: 'tool_execution_start';
     data: {
         tool_call_id: string;
         tool_call_name: string;
         parent_message_id?: string;
-        is_external?: boolean;
-    };
-}
-interface ToolCallArgsEvent {
-    type: 'tool_call_args';
-    data: {
-        tool_call_id: string;
-        delta: string;
+        input?: any;
     };
 }
-interface ToolCallEndEvent {
-    type: 'tool_call_end';
+interface ToolExecutionEndEvent {
+    type: 'tool_execution_end';
     data: {
         tool_call_id: string;
     };
 }
-interface ToolCallResultEvent {
-    type: 'tool_call_result';
+interface ToolRejectedEvent {
+    type: 'tool_rejected';
     data: {
-        tool_call_id: string;
-        result: string;
+        reason?: string;
+        tool_call_id?: string;
     };
 }
 interface AgentHandoverEvent {
@@ -73,7 +95,445 @@ interface AgentHandoverEvent {
         reason?: string;
     };
 }
-type DistriEvent = RunStartedEvent | RunFinishedEvent | RunErrorEvent | TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent | ToolCallResultEvent | AgentHandoverEvent;
+interface StepStartedEvent {
+    type: 'step_started';
+    data: {
+        step_id: string;
+        step_title: string;
+        step_index: number;
+    };
+}
+interface StepCompletedEvent {
+    type: 'step_completed';
+    data: {
+        step_id: string;
+        step_title: string;
+        step_index: number;
+    };
+}
+interface FeedbackReceivedEvent {
+    type: 'feedback_received';
+    data: {
+        feedback: string;
+    };
+}
+interface ToolCallsEvent {
+    type: 'tool_calls';
+    data: {
+        tool_calls: Array<{
+            tool_call_id: string;
+            tool_name: string;
+            input: any;
+        }>;
+    };
+}
+interface ToolResultsEvent {
+    type: 'tool_results';
+    data: {
+        results: Array<ToolResult>;
+    };
+}
+interface BrowserScreenshotEvent {
+    type: 'browser_screenshot';
+    data: {
+        image: string;
+        format?: string;
+        filename?: string;
+        size?: number;
+        timestamp_ms?: number;
+    };
+}
+interface InlineHookRequestedEvent {
+    type: 'inline_hook_requested';
+    data: {
+        hook_id: string;
+        hook: string;
+        context: {
+            agent_id: string;
+            thread_id: string;
+            task_id: string;
+            run_id: string;
+        };
+        timeout_ms?: number;
+        fire_and_forget?: boolean;
+        message?: any;
+        plan?: any;
+        result?: any;
+    };
+}
+type DistriEvent = RunStartedEvent | RunFinishedEvent | RunErrorEvent | PlanStartedEvent | PlanFinishedEvent | PlanPrunedEvent | TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | ToolExecutionStartEvent | ToolExecutionEndEvent | ToolRejectedEvent | StepStartedEvent | StepCompletedEvent | AgentHandoverEvent | FeedbackReceivedEvent | ToolCallsEvent | ToolResultsEvent | BrowserScreenshotEvent | InlineHookRequestedEvent;
+
+type ChatCompletionRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ChatCompletionMessage {
+    role: ChatCompletionRole;
+    content: string;
+}
+type ChatCompletionResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+interface ChatCompletionRequest {
+    model?: string;
+    messages: ChatCompletionMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    response_format?: ChatCompletionResponseFormat;
+    tools?: unknown[];
+    tool_choice?: 'none' | 'auto' | Record<string, unknown>;
+}
+interface ChatCompletionChoice {
+    index: number;
+    finish_reason?: string | null;
+    message: ChatCompletionMessage;
+}
+interface ChatCompletionResponse {
+    id: string;
+    created: number;
+    model: string;
+    object: string;
+    choices: ChatCompletionChoice[];
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+/**
+ * Enhanced Distri Client that wraps A2AClient and adds Distri-specific features
+ *
+ * @example
+ * // Local development
+ * const client = new DistriClient({ baseUrl: 'http://localhost:3033' });
+ *
+ * // Cloud with default URL (https://api.distri.dev)
+ * const client = DistriClient.create();
+ */
+declare class DistriClient {
+    private config;
+    private accessToken?;
+    private refreshToken?;
+    private tokenRefreshSkewMs;
+    private onTokenRefresh?;
+    private refreshPromise?;
+    private agentClients;
+    constructor(config: DistriClientConfig);
+    /**
+     * Create a client with default cloud configuration.
+     *
+     * @param overrides - Optional overrides for the default config
+     */
+    static create(overrides?: Partial<DistriClientConfig>): DistriClient;
+    /**
+     * Check if this client has authentication configured.
+     */
+    hasAuth(): boolean;
+    /**
+     * Check if this client is configured for local development.
+     */
+    isLocal(): boolean;
+    /**
+     * Session store: set a value (optionally with expiry)
+     */
+    setSessionValue(sessionId: string, key: string, value: unknown, expiry?: Date | string): Promise<void>;
+    /**
+     * Session store: get a single value
+     */
+    getSessionValue<T = unknown>(sessionId: string, key: string): Promise<T | null>;
+    /**
+     * Session store: get all values in a session
+     */
+    getSessionValues(sessionId: string): Promise<Record<string, unknown>>;
+    /**
+     * Session store: delete a single key
+     */
+    deleteSessionValue(sessionId: string, key: string): Promise<void>;
+    /**
+     * Session store: clear all keys in a session
+     */
+    clearSession(sessionId: string): Promise<void>;
+    private static readonly ADDITIONAL_PARTS_KEY;
+    /**
+     * Set additional user message parts for the next agent iteration.
+     * These parts will be appended to the user message in the prompt.
+     * @param sessionId - The thread/session ID
+     * @param parts - Array of DistriPart objects to append to user message
+     */
+    setAdditionalUserParts(sessionId: string, parts: DistriPart[]): Promise<void>;
+    /**
+     * Get the current additional user message parts.
+     * @param sessionId - The thread/session ID
+     * @returns Array of DistriPart objects or null if not set
+     */
+    getAdditionalUserParts(sessionId: string): Promise<DistriPart[] | null>;
+    /**
+     * Clear/delete the additional user message parts.
+     * @param sessionId - The thread/session ID
+     */
+    clearAdditionalUserParts(sessionId: string): Promise<void>;
+    /**
+     * Response from the token endpoint
+     */
+    static readonly TokenType: {
+        readonly Main: "main";
+        readonly Short: "short";
+    };
+    /**
+     * Issue an access token + refresh token for temporary authentication.
+     * Requires an existing authenticated session (bearer token).
+     *
+     * @returns Token response with access/refresh token strings
+     * @throws ApiError if not authenticated or token issuance fails
+     *
+     * @example
+     * ```typescript
+     * const { access_token, refresh_token } = await client.issueToken();
+     * // Persist the refresh token and use access_token for requests
+     * ```
+     */
+    issueToken(): Promise<{
+        access_token: string;
+        refresh_token: string;
+        expires_at: number;
+    }>;
+    /**
+     * Get the current access/refresh tokens.
+     */
+    getTokens(): {
+        accessToken?: string;
+        refreshToken?: string;
+    };
+    /**
+     * Update the access/refresh tokens in memory.
+     */
+    setTokens(tokens: {
+        accessToken?: string;
+        refreshToken?: string;
+    }): void;
+    /**
+     * Start streaming speech-to-text transcription via WebSocket
+     */
+    streamingTranscription(options?: StreamingTranscriptionOptions): Promise<{
+        sendAudio: (audioData: ArrayBuffer) => void;
+        sendText: (text: string) => void;
+        stop: () => void;
+        close: () => void;
+    }>;
+    /**
+     * Transcribe audio blob to text using speech-to-text API
+     */
+    transcribe(audioBlob: Blob, config?: SpeechToTextConfig): Promise<string>;
+    getConfiguration(): Promise<ConfigurationResponse>;
+    updateConfiguration(configuration: DistriConfiguration): Promise<ConfigurationResponse>;
+    /**
+     * Minimal LLM helper that proxies to the Distri server using Distri messages.
+     */
+    llm(messages: DistriMessage[], tools?: unknown[], options?: LlmExecuteOptions): Promise<LLMResponse>;
+    /**
+     * Get all available agents from the Distri server
+     */
+    getAgents(): Promise<AgentDefinition[]>;
+    /**
+     * Get specific agent by ID
+     */
+    getAgent(agentId: string): Promise<AgentDefinition>;
+    /**
+     * Get or create A2AClient for an agent
+     */
+    private getA2AClient;
+    /**
+     * Send a message to an agent
+     */
+    sendMessage(agentId: string, params: MessageSendParams): Promise<Message | Task>;
+    /**
+     * Send a streaming message to an agent
+     */
+    sendMessageStream(agentId: string, params: MessageSendParams): AsyncGenerator<A2AStreamEventData>;
+    /**
+     * Get task details
+     */
+    getTask(agentId: string, taskId: string): Promise<Task>;
+    /**
+     * Cancel a task
+     */
+    cancelTask(agentId: string, taskId: string): Promise<void>;
+    /**
+     * Get threads from Distri server
+     */
+    getThreads(): Promise<DistriThread[]>;
+    getThread(threadId: string): Promise<DistriThread>;
+    /**
+     * Get thread messages
+     */
+    getThreadMessages(threadId: string): Promise<Message[]>;
+    /**
+     * Get messages from a thread as DistriMessage format
+     */
+    getThreadMessagesAsDistri(threadId: string): Promise<DistriMessage[]>;
+    /**
+     * Send a DistriMessage to a thread
+     */
+    sendDistriMessage(threadId: string, message: DistriMessage, context: InvokeContext): Promise<void>;
+    /**
+     * Complete an external tool call
+     */
+    completeTool(agentId: string, result: ToolResult): Promise<void>;
+    /**
+     * Complete an inline hook with a mutation payload.
+     */
+    completeInlineHook(hookId: string, mutation: any): Promise<void>;
+    /**
+     * Get the base URL for making direct requests
+     */
+    get baseUrl(): string;
+    private applyTokens;
+    private ensureAccessToken;
+    private refreshTokens;
+    private performTokenRefresh;
+    private isTokenExpiring;
+    private getTokenExpiry;
+    private decodeJwtPayload;
+    private decodeBase64Url;
+    private applyAuthHeader;
+    /**
+     * Enhanced fetch with retry logic
+     */
+    private fetchAbsolute;
+    /**
+     * Enhanced fetch with retry logic
+     */
+    private fetch;
+    /**
+     * Delay utility
+     */
+    private delay;
+    /**
+     * Debug logging
+     */
+    private debug;
+    /**
+     * Helper method to create A2A messages
+     */
+    static initMessage(parts: Part[] | string, role: "agent" | "user" | undefined, message: Omit<Partial<Message>, 'parts' | 'role' | 'kind'>): Message;
+    /**
+     * Create a DistriMessage instance
+     */
+    static initDistriMessage(role: DistriMessage['role'], parts: DistriPart[], id?: string, created_at?: number): DistriMessage;
+    /**
+     * Helper method to create message send parameters
+     */
+    static initMessageParams(message: Message, configuration?: MessageSendParams['configuration'], metadata?: any): MessageSendParams;
+    /**
+     * Create MessageSendParams from a DistriMessage using InvokeContext
+     */
+    static initDistriMessageParams(message: DistriMessage, context: InvokeContext): MessageSendParams;
+}
+declare function uuidv4(): string;
+
+/**
+ * Configuration for Agent invoke method
+ */
+interface InvokeConfig {
+    /** Configuration for the message */
+    configuration?: MessageSendParams['configuration'];
+    /** Context/thread ID */
+    contextId?: string;
+    /** Metadata for the requests */
+    metadata?: any;
+}
+/**
+ * Result from agent invoke
+ */
+interface InvokeResult {
+    /** Final response message */
+    message?: Message;
+    /** Task if created */
+    task?: any;
+    /** Whether the response was streamed */
+    streamed: boolean;
+}
+interface ExternalToolValidationResult {
+    isValid: boolean;
+    requiredTools: string[];
+    providedTools: string[];
+    missingTools: string[];
+    message?: string;
+}
+declare class ExternalToolValidationError extends DistriError {
+    missingTools: string[];
+    requiredTools: string[];
+    providedTools: string[];
+    agentName: string;
+    constructor(agentName: string, result: ExternalToolValidationResult);
+}
+/**
+ * Enhanced Agent class with simple tool system following AG-UI pattern
+ */
+declare class Agent {
+    private client;
+    private agentDefinition;
+    private hookHandlers;
+    private defaultHookHandler;
+    constructor(agentDefinition: AgentDefinition, client: DistriClient);
+    /**
+     * Get agent information
+     */
+    get id(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get agentType(): string | undefined;
+    get iconUrl(): string | undefined;
+    /**
+     * Get the full agent definition (including backend tools)
+     */
+    getDefinition(): AgentDefinition;
+    /**
+     * Fetch messages for a thread (public method for useChat)
+     */
+    getThreadMessages(threadId: string): Promise<Message[]>;
+    /**
+     * Direct (non-streaming) invoke
+     */
+    invoke(params: MessageSendParams, tools?: DistriBaseTool[], hooks?: Record<string, HookHandler>): Promise<Message>;
+    /**
+     * Streaming invoke
+     */
+    invokeStream(params: MessageSendParams, tools?: DistriBaseTool[], hooks?: Record<string, HookHandler>): Promise<AsyncGenerator<DistriChatMessage>>;
+    /**
+     * Validate that required external tools are registered before invoking.
+     */
+    validateExternalTools(tools?: DistriBaseTool[]): ExternalToolValidationResult;
+    /**
+     * Enhance message params with tool definitions
+     */
+    private enhanceParamsWithTools;
+    private assertExternalTools;
+    private getRequiredExternalTools;
+    private resolveToolConfig;
+    private extractToolConfig;
+    private formatExternalToolValidationMessage;
+    /**
+     * Register multiple hooks at once.
+     */
+    registerHooks(hooks: Record<string, HookHandler>, defaultHandler?: HookHandler): void;
+    /**
+     * Create an agent instance from an agent ID
+     */
+    static create(agentIdOrDef: string | AgentDefinition, client: DistriClient): Promise<Agent>;
+    /**
+     * Complete an external tool call by sending the result back to the server
+     */
+    completeTool(result: ToolResult): Promise<void>;
+    /**
+     * List all available agents
+     */
+    static list(client: DistriClient): Promise<Agent[]>;
+}
 
 /**
  * Message roles supported by Distri
@@ -86,7 +546,122 @@ interface DistriMessage {
     id: string;
     role: MessageRole;
     parts: DistriPart[];
-    created_at?: string;
+    created_at: number;
+    step_id?: string;
+    is_final?: boolean;
+}
+interface LlmExecuteOptions {
+    thread_id?: string;
+    parent_task_id?: string;
+    run_id?: string;
+    model_settings?: any;
+    is_sub_task?: boolean;
+}
+interface AssistantWithToolCalls {
+    id: string;
+    type: 'llm_response';
+    timestamp: number;
+    content: string;
+    tool_calls: any[];
+    step_id?: string;
+    success: boolean;
+    rejected: boolean;
+    is_external: boolean;
+    reason: string | null;
+}
+interface UseToolsOptions {
+    agent?: Agent;
+    externalTools?: DistriBaseTool[];
+    executionOptions?: ToolExecutionOptions;
+}
+interface ToolExecutionOptions {
+    autoExecute?: boolean;
+}
+interface HookMutation {
+    dynamic_values: Record<string, any>;
+}
+interface HookContext {
+    agent_id: string;
+    thread_id: string;
+    task_id: string;
+    run_id: string;
+}
+interface InlineHookRequest {
+    hook_id: string;
+    hook: string;
+    context: HookContext;
+    timeout_ms?: number;
+    fire_and_forget?: boolean;
+    message?: any;
+    plan?: any;
+    result?: any;
+}
+interface InlineHookEventData extends InlineHookRequest {
+}
+type HookHandler = (req: InlineHookRequest) => Promise<HookMutation> | HookMutation;
+interface ToolResults {
+    id: string;
+    type: 'tool_results';
+    timestamp: number;
+    results: any[];
+    step_id?: string;
+    success: boolean;
+    rejected: boolean;
+    reason: string | null;
+}
+interface DistriPlan {
+    id: string;
+    type: 'plan';
+    timestamp: number;
+    reasoning: string;
+    steps: PlanStep[];
+}
+interface BasePlanStep {
+    id: string;
+}
+interface ThoughtPlanStep extends BasePlanStep {
+    type: 'thought';
+    message: string;
+}
+interface ActionPlanStep extends BasePlanStep {
+    type: 'action';
+    action: PlanAction;
+}
+interface CodePlanStep extends BasePlanStep {
+    type: 'code';
+    code: string;
+    language: string;
+}
+interface FinalResultPlanStep extends BasePlanStep {
+    type: 'final_result';
+    content: string;
+    tool_calls: any[];
+}
+interface PlanAction {
+    tool_name?: string;
+    input?: string;
+    prompt?: string;
+    context?: any[];
+    tool_calling_config?: any;
+}
+type PlanStep = ThoughtPlanStep | ActionPlanStep | CodePlanStep | FinalResultPlanStep;
+interface LlmPlanStep extends BasePlanStep {
+    type: 'llm_call';
+    prompt: string;
+    context: any[];
+}
+interface BatchToolCallsStep extends BasePlanStep {
+    type: 'batch_tool_calls';
+    tool_calls: any[];
+}
+interface ThoughtStep extends BasePlanStep {
+    type: 'thought';
+    message: string;
+}
+interface ReactStep extends BasePlanStep {
+    type: 'react_step';
+    thought: string;
+    action: string;
 }
 type DistriStreamEvent = DistriMessage | DistriEvent;
 /**
@@ -95,55 +670,44 @@ type DistriStreamEvent = DistriMessage | DistriEvent;
 interface InvokeContext {
     thread_id: string;
     run_id?: string;
+    task_id?: string;
     getMetadata?: () => any;
 }
 /**
  * Distri message parts - equivalent to Rust enum Part
  */
 type TextPart = {
-    type: 'text';
-    text: string;
+    part_type: 'text';
+    data: string;
 };
-type CodeObservationPart = {
-    type: 'code_observation';
-    thought: string;
-    code: string;
+type ToolCallPart = {
+    part_type: 'tool_call';
+    data: ToolCall;
 };
-type ImageUrlPart = {
-    type: 'image_url';
-    image: FileUrl;
+type ToolResultRefPart = {
+    part_type: 'tool_result';
+    data: ToolResult;
 };
-type ImageBytesPart = {
-    type: 'image_bytes';
-    image: FileBytes;
+type ImagePart = {
+    part_type: 'image';
+    data: FileType;
 };
-type ImagePart = ImageUrlPart | ImageBytesPart;
 type DataPart = {
-    type: 'data';
-    data: any;
-};
-type ToolCallPart = {
-    type: 'tool_call';
-    tool_call: ToolCall;
+    part_type: 'data';
+    data: object;
 };
-type ToolResultPart = {
-    type: 'tool_result';
-    tool_result: ToolResult;
-};
-type PlanPart = {
-    type: 'plan';
-    plan: string;
-};
-type DistriPart = TextPart | CodeObservationPart | ImagePart | DataPart | ToolCallPart | ToolResultPart | PlanPart;
+type DistriPart = TextPart | ToolCallPart | ToolResultRefPart | ImagePart | DataPart;
 /**
  * File type for images
  */
 interface FileBytes {
+    type: 'bytes';
     mime_type: string;
     data: string;
     name?: string;
 }
 interface FileUrl {
+    type: 'url';
     mime_type: string;
     url: string;
     name?: string;
@@ -156,7 +720,10 @@ interface DistriBaseTool {
     name: string;
     type: 'function' | 'ui';
     description: string;
-    input_schema: object;
+    parameters: object;
+    is_final?: boolean;
+    autoExecute?: boolean;
+    isExternal?: boolean;
 }
 interface DistriFnTool extends DistriBaseTool {
     type: 'function';
@@ -167,7 +734,7 @@ interface DistriFnTool extends DistriBaseTool {
  * Tool handler function
  */
 interface ToolHandler {
-    (input: any): Promise<string | number | boolean | null | object>;
+    (input: any): Promise<string | number | boolean | null | DistriPart[] | object>;
 }
 /**
  * Tool call from agent
@@ -178,21 +745,46 @@ interface ToolCall {
     input: any;
 }
 /**
- * Tool result for responding to tool calls
+ * Tool result structure that can come from backend or frontend
  */
 interface ToolResult {
-    tool_call_id: string;
-    result: string | number | boolean | null;
+    readonly tool_call_id: string;
+    readonly tool_name: string;
+    readonly parts: readonly DistriPart[];
+}
+/**
+ * Tool result data that goes inside the parts array
+ */
+interface ToolResultData {
+    result: string | number | boolean | null | object;
     success: boolean;
     error?: string;
 }
+declare function isArrayParts(result: any): boolean;
+/**
+ * Type-safe helper to create a successful ToolResult
+ * Uses proper DistriPart structure - conversion to backend format happens in encoder
+ */
+declare function createSuccessfulToolResult(toolCallId: string, toolName: string, result: string | number | boolean | null | object | DistriPart[]): ToolResult;
+/**
+ * Type-safe helper to create a failed ToolResult
+ * Uses proper DistriPart structure - conversion to backend format happens in encoder
+ */
+declare function createFailedToolResult(toolCallId: string, toolName: string, error: string, result?: string | number | boolean | null | object): ToolResult;
+/**
+ * Type-safe helper to extract ToolResultData from a ToolResult
+ * Handles both frontend DistriPart format and backend BackendPart format
+ */
+declare function extractToolResultData(toolResult: ToolResult): ToolResultData | null;
 /**
  * Distri-specific Agent type that wraps A2A AgentCard
  */
-interface DistriAgent {
+interface AgentDefinition {
     /** The name of the agent. */
     name: string;
     id: string;
+    /** Optional package identifier (workspace/plugin) that registered the agent */
+    package_name?: string | null;
     /** A brief description of the agent's purpose. */
     description?: string;
     /** The version of the agent. */
@@ -213,6 +805,21 @@ interface DistriAgent {
     skills?: AgentSkill[];
     /** List of sub-agents that this agent can transfer control to */
     sub_agents?: string[];
+    agentType?: string;
+    agent_type?: string;
+    tools?: DistriBaseTool[];
+    browser_config?: BrowserAgentConfig;
+}
+interface BrowserAgentConfig {
+    enabled?: boolean;
+    persist_session?: boolean;
+    runtime?: DistriBrowserRuntimeConfig | null;
+}
+interface DistriBrowserRuntimeConfig {
+    window_size?: [number, number];
+    headless?: boolean;
+    enable_stealth_mode?: boolean;
+    enable_real_emulation?: boolean;
 }
 interface McpDefinition {
     /** The filter applied to the tools in this MCP definition. */
@@ -226,18 +833,31 @@ interface ModelSettings {
     model: string;
     temperature: number;
     max_tokens: number;
+    context_size: number;
     top_p: number;
     frequency_penalty: number;
     presence_penalty: number;
-    max_iterations: number;
-    provider: ModelProvider;
+    provider: ModelProviderConfig;
     /** Additional parameters for the agent, if any. */
     parameters?: any;
     /** The format of the response, if specified. */
     response_format?: any;
 }
 type McpServerType = 'tool' | 'agent';
-type ModelProvider = 'openai' | 'aigateway';
+type ModelProviderName = 'openai' | 'openai_compat' | 'vllora' | string;
+type ModelProviderConfig = {
+    name: 'openai';
+} | {
+    name: 'openai_compat';
+    base_url: string;
+    project_id?: string;
+} | {
+    name: 'vllora';
+    base_url?: string;
+} | {
+    name: string;
+    [key: string]: any;
+};
 /**
  * Distri Thread type for conversation management
  */
@@ -261,208 +881,169 @@ interface Thread {
 }
 interface ChatProps {
     thread: Thread;
-    agent: DistriAgent;
+    agent: AgentDefinition;
     onThreadUpdate?: () => void;
 }
+interface SpeechToTextConfig {
+    model?: 'whisper-1';
+    language?: string;
+    temperature?: number;
+}
+interface StreamingTranscriptionOptions {
+    onTranscript?: (text: string, isFinal: boolean) => void;
+    onError?: (error: Error) => void;
+    onStart?: () => void;
+    onEnd?: () => void;
+}
 /**
  * Connection Status
  */
 type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
 /**
- * Distri Client Configuration
+ * Default base URL for the Distri cloud service
  */
-interface DistriClientConfig {
-    baseUrl: string;
-    apiVersion?: string;
-    timeout?: number;
-    retryAttempts?: number;
-    retryDelay?: number;
-    debug?: boolean;
-    headers?: Record<string, string>;
-    interceptor?: (init?: RequestInit) => Promise<RequestInit | undefined>;
-}
-type A2AStreamEventData = Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent | Task;
-declare function isDistriMessage(event: DistriStreamEvent): event is DistriMessage;
-declare function isDistriEvent(event: DistriStreamEvent): event is DistriEvent;
-
+declare const DEFAULT_BASE_URL = "https://api.distri.dev";
 /**
- * Enhanced Distri Client that wraps A2AClient and adds Distri-specific features
+ * Distri Client Configuration
  */
-declare class DistriClient {
-    private config;
-    private agentClients;
-    constructor(config: DistriClientConfig);
-    /**
-     * Get all available agents from the Distri server
-     */
-    getAgents(): Promise<DistriAgent[]>;
-    /**
-     * Get specific agent by ID
-     */
-    getAgent(agentId: string): Promise<DistriAgent>;
-    /**
-     * Get or create A2AClient for an agent
-     */
-    private getA2AClient;
-    /**
-     * Send a message to an agent
-     */
-    sendMessage(agentId: string, params: MessageSendParams): Promise<Message | Task>;
-    /**
-     * Send a streaming message to an agent
-     */
-    sendMessageStream(agentId: string, params: MessageSendParams): AsyncGenerator<A2AStreamEventData>;
-    /**
-     * Get task details
-     */
-    getTask(agentId: string, taskId: string): Promise<Task>;
-    /**
-     * Cancel a task
-     */
-    cancelTask(agentId: string, taskId: string): Promise<void>;
-    /**
-     * Get threads from Distri server
-     */
-    getThreads(): Promise<DistriThread[]>;
-    getThread(threadId: string): Promise<DistriThread>;
+interface DistriClientConfig {
     /**
-     * Get thread messages
+     * Base URL of the Distri server
+     * Default: https://api.distri.dev
      */
-    getThreadMessages(threadId: string): Promise<Message[]>;
+    baseUrl: string;
     /**
-     * Get messages from a thread as DistriMessage format
+     * API version (currently unused)
      */
-    getThreadMessagesAsDistri(threadId: string): Promise<DistriMessage[]>;
+    apiVersion?: string;
     /**
-     * Send a DistriMessage to a thread
+     * Request timeout in milliseconds (default: 30000)
      */
-    sendDistriMessage(threadId: string, message: DistriMessage, context: InvokeContext): Promise<void>;
+    timeout?: number;
     /**
-     * Get the base URL for making direct requests
+     * Number of retry attempts for failed requests (default: 3)
      */
-    get baseUrl(): string;
+    retryAttempts?: number;
     /**
-     * Enhanced fetch with retry logic
+     * Delay between retry attempts in milliseconds (default: 1000)
      */
-    private fetchAbsolute;
+    retryDelay?: number;
     /**
-     * Enhanced fetch with retry logic
+     * Enable debug logging
      */
-    private fetch;
+    debug?: boolean;
     /**
-     * Delay utility
+     * Custom headers to include in all requests
      */
-    private delay;
+    headers?: Record<string, string>;
     /**
-     * Debug logging
+     * Request interceptor for modifying requests before sending
      */
-    private debug;
+    interceptor?: (init?: RequestInit) => Promise<RequestInit | undefined>;
     /**
-     * Helper method to create A2A messages
+     * Access token for bearer auth (optional)
      */
-    static initMessage(parts: Part[] | string, role: "agent" | "user" | undefined, message: Omit<Partial<Message>, 'parts' | 'role' | 'kind'>): Message;
+    accessToken?: string;
     /**
-     * Create a DistriMessage instance
+     * Refresh token for bearer auth (optional)
      */
-    static initDistriMessage(role: DistriMessage['role'], parts: DistriPart[], id?: string, created_at?: string): DistriMessage;
+    refreshToken?: string;
     /**
-     * Helper method to create message send parameters
+     * Token refresh skew in milliseconds (default: 60000)
      */
-    static initMessageParams(message: Message, configuration?: MessageSendParams['configuration'], metadata?: any): MessageSendParams;
+    tokenRefreshSkewMs?: number;
     /**
-     * Create MessageSendParams from a DistriMessage using InvokeContext
+     * Callback invoked when tokens are refreshed
      */
-    static initDistriMessageParams(message: DistriMessage, context: InvokeContext): MessageSendParams;
+    onTokenRefresh?: (tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }) => void;
 }
-declare function uuidv4(): string;
-
-/**
- * Configuration for Agent invoke method
- */
-interface InvokeConfig {
-    /** Configuration for the message */
-    configuration?: MessageSendParams['configuration'];
-    /** Context/thread ID */
-    contextId?: string;
-    /** Metadata for the requests */
-    metadata?: any;
+interface LLMResponse {
+    finish_reason: string;
+    content: string;
+    tool_calls: ToolCall[];
+    token_usage: number;
+    tools?: any[];
 }
-/**
- * Result from agent invoke
- */
-interface InvokeResult {
-    /** Final response message */
-    message?: Message;
-    /** Task if created */
-    task?: any;
-    /** Whether the response was streamed */
-    streamed: boolean;
+interface ExternalMcpServer {
+    name: string;
+    [key: string]: any;
+}
+interface ServerConfig {
+    base_url?: string;
+    host?: string;
+    port?: number;
+    [key: string]: any;
+}
+interface DistriConfiguration {
+    name: string;
+    version: string;
+    description?: string;
+    license?: string;
+    working_directory?: string;
+    agents?: string[];
+    mcp_servers?: ExternalMcpServer[];
+    server?: ServerConfig;
+    model_settings?: ModelSettings;
+    analysis_model_settings?: ModelSettings;
+    keywords?: string[];
+    [key: string]: any;
+}
+interface ConfigurationMeta {
+    base_path: string;
+    overrides_path: string;
+    overrides_active: boolean;
+}
+interface ConfigurationResponse {
+    configuration: DistriConfiguration;
+    meta: ConfigurationMeta;
 }
 /**
- * Enhanced Agent class with simple tool system following AG-UI pattern
+ * Error Types
  */
-declare class Agent {
-    private client;
-    private agentDefinition;
-    private tools;
-    constructor(agentDefinition: DistriAgent, client: DistriClient);
-    /**
-     * Add a tool to the agent (AG-UI style)
-     */
-    registerTool(tool: DistriBaseTool): void;
-    /**
-     * Add multiple tools at once
-     */
-    registerTools(tools: DistriBaseTool[]): void;
-    /**
-     * Remove a tool
-     */
-    unregisterTool(toolName: string): void;
-    /**
-     * Get all registered tools
-     */
-    getTools(): DistriBaseTool[];
-    /**
-     * Check if a tool is registered
-     */
-    hasTool(toolName: string): boolean;
-    /**
-     * Get agent information
-     */
-    get id(): string;
-    get name(): string;
-    get description(): string | undefined;
-    get iconUrl(): string | undefined;
-    /**
-     * Fetch messages for a thread (public method for useChat)
-     */
-    getThreadMessages(threadId: string): Promise<Message[]>;
-    /**
-     * Direct (non-streaming) invoke
-     */
-    invoke(params: MessageSendParams): Promise<Message>;
-    /**
-     * Streaming invoke
-     */
-    invokeStream(params: MessageSendParams): Promise<AsyncGenerator<DistriEvent | DistriMessage>>;
-    /**
-     * Enhance message params with tool definitions
-     */
-    private enhanceParamsWithTools;
-    /**
-     * Create an agent instance from an agent ID
-     */
-    static create(agentId: string, client: DistriClient): Promise<Agent>;
-    /**
-     * List all available agents
-     */
-    static list(client: DistriClient): Promise<Agent[]>;
+declare class DistriError extends Error {
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, code: string, details?: any | undefined);
 }
+declare class A2AProtocolError extends DistriError {
+    constructor(message: string, details?: any);
+}
+declare class ApiError extends DistriError {
+    statusCode: number;
+    constructor(message: string, statusCode: number, details?: any);
+}
+declare class ConnectionError extends DistriError {
+    constructor(message: string, details?: any);
+}
+
+type A2AStreamEventData = Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent | Task;
+declare function isDistriMessage(event: DistriStreamEvent): event is DistriMessage;
+declare function isDistriEvent(event: DistriStreamEvent): event is DistriEvent;
+type DistriChatMessage = DistriEvent | DistriMessage;
 
 /**
  * Converts an A2A Message to a DistriMessage
  */
 declare function convertA2AMessageToDistri(a2aMessage: Message): DistriMessage;
+/**
+ * Converts A2A status-update events to DistriEvent based on metadata type
+ */
+declare function convertA2AStatusUpdateToDistri(statusUpdate: any): DistriEvent | null;
+/**
+ * Enhanced decoder for A2A stream events that properly handles all event types
+ */
+declare function decodeA2AStreamEvent(event: any): DistriChatMessage | null;
+/**
+ * Process A2A stream data (like from stream.json) and convert to DistriMessage/DistriEvent/DistriArtifact array
+ */
+declare function processA2AStreamData(streamData: any[]): (DistriMessage | DistriEvent)[];
+/**
+ * Process A2A messages.json data and convert to DistriMessage array
+ */
+declare function processA2AMessagesData(data: any[]): DistriMessage[];
 /**
  * Converts an A2A Part to a DistriPart
  */
@@ -488,4 +1069,4 @@ declare function extractToolCallsFromDistriMessage(message: DistriMessage): any[
  */
 declare function extractToolResultsFromDistriMessage(message: DistriMessage): any[];
 
-export { Agent, type AgentHandoverEvent, type ChatProps, type CodeObservationPart, type ConnectionStatus, type DataPart, type DistriAgent, type DistriBaseTool, DistriClient, type DistriClientConfig, type DistriEvent, type DistriFnTool, type DistriMessage, type DistriPart, type DistriStreamEvent, type DistriThread, type FileType, type ImagePart, type InvokeConfig, type InvokeContext, type InvokeResult, type McpDefinition, type McpServerType, type MessageRole, type ModelProvider, type ModelSettings, type PlanPart, type RunErrorEvent, type RunFinishedEvent, type RunStartedEvent, type TextMessageContentEvent, type TextMessageEndEvent, type TextMessageStartEvent, type TextPart, type Thread, type ToolCall, type ToolCallArgsEvent, type ToolCallEndEvent, type ToolCallPart, type ToolCallResultEvent, type ToolCallStartEvent, type ToolResult, type ToolResultPart, convertA2AMessageToDistri, convertA2APartToDistri, convertDistriMessageToA2A, convertDistriPartToA2A, extractTextFromDistriMessage, extractToolCallsFromDistriMessage, extractToolResultsFromDistriMessage, isDistriEvent, isDistriMessage, uuidv4 };
+export { A2AProtocolError, type A2AStreamEventData, type ActionPlanStep, Agent, type AgentDefinition, type AgentHandoverEvent, ApiError, type AssistantWithToolCalls, type BasePlanStep, type BatchToolCallsStep, type BrowserAgentConfig, type BrowserScreenshotEvent, type ChatCompletionChoice, type ChatCompletionMessage, type ChatCompletionRequest, type ChatCompletionResponse, type ChatCompletionResponseFormat, type ChatCompletionRole, type ChatProps, type CodePlanStep, type ConfigurationMeta, type ConfigurationResponse, ConnectionError, type ConnectionStatus, DEFAULT_BASE_URL, type DataPart, type DistriBaseTool, type DistriBrowserRuntimeConfig, type DistriChatMessage, DistriClient, type DistriClientConfig, type DistriConfiguration, DistriError, type DistriEvent, type DistriFnTool, type DistriMessage, type DistriPart, type DistriPlan, type DistriStreamEvent, type DistriThread, type ExternalMcpServer, ExternalToolValidationError, type ExternalToolValidationResult, type FeedbackReceivedEvent, type FileBytes, type FileType, type FileUrl, type FinalResultPlanStep, type HookContext, type HookHandler, type HookMutation, type ImagePart, type InlineHookEventData, type InlineHookRequest, type InlineHookRequestedEvent, type InvokeConfig, type InvokeContext, type InvokeResult, type LLMResponse, type LlmExecuteOptions, type LlmPlanStep, type McpDefinition, type McpServerType, type MessageRole, type ModelProviderConfig, type ModelProviderName, type ModelSettings, type PlanAction, type PlanFinishedEvent, type PlanPrunedEvent, type PlanStartedEvent, type PlanStep, type ReactStep, type Role, type RunErrorEvent, type RunFinishedEvent, type RunStartedEvent, type ServerConfig, type SpeechToTextConfig, type StepCompletedEvent, type StepStartedEvent, type StreamingTranscriptionOptions, type TextMessageContentEvent, type TextMessageEndEvent, type TextMessageStartEvent, type TextPart, type ThoughtPlanStep, type ThoughtStep, type Thread, type ToolCall, type ToolCallPart, type ToolCallsEvent, type ToolExecutionEndEvent, type ToolExecutionOptions, type ToolExecutionStartEvent, type ToolHandler, type ToolRejectedEvent, type ToolResult, type ToolResultData, type ToolResultRefPart, type ToolResults, type ToolResultsEvent, type UseToolsOptions, convertA2AMessageToDistri, convertA2APartToDistri, convertA2AStatusUpdateToDistri, convertDistriMessageToA2A, convertDistriPartToA2A, createFailedToolResult, createSuccessfulToolResult, decodeA2AStreamEvent, extractTextFromDistriMessage, extractToolCallsFromDistriMessage, extractToolResultData, extractToolResultsFromDistriMessage, isArrayParts, isDistriEvent, isDistriMessage, processA2AMessagesData, processA2AStreamData, uuidv4 };