@agno-hq/chat-react 0.1.1 → 0.3.1

package/dist/client-DUyVqxU9.d.ts

@@ -0,0 +1,413 @@
+/**
+ * Types for AgentOS run events, messages, and entities.
+ *
+ * These mirror the wire format emitted by Agno's AgentOS when streaming a run
+ * for an agent, team, or workflow. Field names match the JSON sent on the wire.
+ */
+/** Agent run event names. */
+declare enum RunEvent {
+    RunStarted = "RunStarted",
+    RunContent = "RunContent",
+    RunContentCompleted = "RunContentCompleted",
+    RunIntermediateContent = "RunIntermediateContent",
+    RunCompleted = "RunCompleted",
+    RunError = "RunError",
+    RunCancelled = "RunCancelled",
+    RunPaused = "RunPaused",
+    RunContinued = "RunContinued",
+    PreHookStarted = "PreHookStarted",
+    PreHookCompleted = "PreHookCompleted",
+    PostHookStarted = "PostHookStarted",
+    PostHookCompleted = "PostHookCompleted",
+    ToolCallStarted = "ToolCallStarted",
+    ToolCallCompleted = "ToolCallCompleted",
+    ToolCallError = "ToolCallError",
+    ReasoningStarted = "ReasoningStarted",
+    ReasoningStep = "ReasoningStep",
+    ReasoningContentDelta = "ReasoningContentDelta",
+    ReasoningCompleted = "ReasoningCompleted",
+    MemoryUpdateStarted = "MemoryUpdateStarted",
+    MemoryUpdateCompleted = "MemoryUpdateCompleted",
+    SessionSummaryStarted = "SessionSummaryStarted",
+    SessionSummaryCompleted = "SessionSummaryCompleted",
+    ParserModelResponseStarted = "ParserModelResponseStarted",
+    ParserModelResponseCompleted = "ParserModelResponseCompleted",
+    OutputModelResponseStarted = "OutputModelResponseStarted",
+    OutputModelResponseCompleted = "OutputModelResponseCompleted",
+    ModelRequestStarted = "ModelRequestStarted",
+    ModelRequestCompleted = "ModelRequestCompleted",
+    CompressionStarted = "CompressionStarted",
+    CompressionCompleted = "CompressionCompleted",
+    FollowupsStarted = "FollowupsStarted",
+    FollowupsCompleted = "FollowupsCompleted",
+    CustomEvent = "CustomEvent"
+}
+/** Team run event names. */
+declare enum TeamRunEvent {
+    TeamRunStarted = "TeamRunStarted",
+    TeamRunContent = "TeamRunContent",
+    TeamRunIntermediateContent = "TeamRunIntermediateContent",
+    TeamRunContentCompleted = "TeamRunContentCompleted",
+    TeamRunCompleted = "TeamRunCompleted",
+    TeamRunError = "TeamRunError",
+    TeamRunCancelled = "TeamRunCancelled",
+    TeamRunPaused = "TeamRunPaused",
+    TeamRunContinued = "TeamRunContinued",
+    TeamToolCallStarted = "TeamToolCallStarted",
+    TeamToolCallCompleted = "TeamToolCallCompleted",
+    TeamToolCallError = "TeamToolCallError",
+    TeamReasoningStarted = "TeamReasoningStarted",
+    TeamReasoningStep = "TeamReasoningStep",
+    TeamReasoningContentDelta = "TeamReasoningContentDelta",
+    TeamReasoningCompleted = "TeamReasoningCompleted",
+    TeamMemoryUpdateStarted = "TeamMemoryUpdateStarted",
+    TeamMemoryUpdateCompleted = "TeamMemoryUpdateCompleted",
+    TeamFollowupsStarted = "TeamFollowupsStarted",
+    TeamFollowupsCompleted = "TeamFollowupsCompleted",
+    TeamTaskIterationStarted = "TeamTaskIterationStarted",
+    TeamTaskIterationCompleted = "TeamTaskIterationCompleted",
+    TeamTaskStateUpdated = "TeamTaskStateUpdated",
+    TeamTaskCreated = "TeamTaskCreated",
+    TeamTaskUpdated = "TeamTaskUpdated"
+}
+/** Workflow run event names. */
+declare enum WorkflowRunEvent {
+    WorkflowStarted = "WorkflowStarted",
+    WorkflowCompleted = "WorkflowCompleted",
+    WorkflowPaused = "WorkflowPaused",
+    WorkflowCancelled = "WorkflowCancelled",
+    WorkflowError = "WorkflowError",
+    WorkflowAgentStarted = "WorkflowAgentStarted",
+    WorkflowAgentCompleted = "WorkflowAgentCompleted",
+    StepStarted = "StepStarted",
+    StepCompleted = "StepCompleted",
+    StepPaused = "StepPaused",
+    StepContinued = "StepContinued",
+    StepError = "StepError",
+    StepOutput = "StepOutput",
+    StepOutputReview = "StepOutputReview",
+    LoopExecutionStarted = "LoopExecutionStarted",
+    LoopIterationStarted = "LoopIterationStarted",
+    LoopIterationCompleted = "LoopIterationCompleted",
+    LoopExecutionCompleted = "LoopExecutionCompleted",
+    ParallelExecutionStarted = "ParallelExecutionStarted",
+    ParallelExecutionCompleted = "ParallelExecutionCompleted",
+    ConditionExecutionStarted = "ConditionExecutionStarted",
+    ConditionExecutionCompleted = "ConditionExecutionCompleted",
+    ConditionPaused = "ConditionPaused",
+    RouterExecutionStarted = "RouterExecutionStarted",
+    RouterExecutionCompleted = "RouterExecutionCompleted",
+    RouterPaused = "RouterPaused",
+    StepsExecutionStarted = "StepsExecutionStarted",
+    StepsExecutionCompleted = "StepsExecutionCompleted"
+}
+/** Any run event name, across agents, teams and workflows. */
+type AnyRunEventName = RunEvent | TeamRunEvent | WorkflowRunEvent | string;
+interface UserInputField {
+    name: string;
+    field_type?: string;
+    description?: string;
+    value?: unknown;
+}
+interface ToolExecution {
+    tool_call_id?: string;
+    tool_name?: string;
+    tool_args?: Record<string, unknown>;
+    tool_call_error?: boolean;
+    result?: string;
+    metrics?: {
+        time?: number;
+    };
+    created_at?: number;
+    stop_after_tool_call?: boolean;
+    requires_confirmation?: boolean;
+    confirmed?: boolean;
+    confirmation_note?: string;
+    requires_user_input?: boolean;
+    user_input_schema?: UserInputField[];
+    answered?: boolean;
+    external_execution_required?: boolean;
+    role?: string;
+    content?: string | null;
+}
+interface ReasoningStep {
+    title?: string;
+    action?: string;
+    result?: string;
+    reasoning?: string;
+    confidence?: number;
+    next_action?: string;
+}
+interface Reference {
+    content: string;
+    name?: string;
+    meta_data?: Record<string, unknown>;
+}
+interface ReferenceData {
+    query: string;
+    references: Reference[];
+    time?: number;
+}
+interface ImageData {
+    url?: string;
+    revised_prompt?: string;
+    content?: string;
+}
+interface VideoData {
+    id?: number | string;
+    url?: string;
+    eta?: number;
+}
+interface AudioData {
+    id?: string;
+    url?: string;
+    base64_audio?: string;
+    mime_type?: string;
+    content?: string;
+    transcript?: string;
+    channels?: number;
+    sample_rate?: number;
+}
+interface Citations {
+    raw?: unknown;
+    urls?: Array<{
+        url?: string;
+        title?: string;
+    }>;
+}
+/**
+ * A single run event off the wire, normalised to a flat object. The `event`
+ * field is the discriminator; other fields depend on the event type. This is a
+ * permissive superset — most fields are optional and present only for the
+ * events that carry them.
+ */
+interface RunEventData {
+    event: AnyRunEventName;
+    created_at?: number;
+    run_id?: string;
+    parent_run_id?: string;
+    session_id?: string;
+    agent_id?: string;
+    agent_name?: string;
+    team_id?: string;
+    team_name?: string;
+    workflow_id?: string;
+    workflow_name?: string;
+    content?: string | object | null;
+    content_type?: string;
+    reasoning_content?: string;
+    tool?: ToolExecution;
+    tools?: ToolExecution[];
+    reasoning_steps?: ReasoningStep[];
+    references?: ReferenceData[];
+    citations?: Citations;
+    /** `FollowupsCompleted`: the suggested next prompts. */
+    followups?: string[];
+    images?: ImageData[];
+    videos?: VideoData[];
+    audio?: AudioData[];
+    response_audio?: AudioData;
+    step_name?: string;
+    step_index?: number | [number, number];
+    iteration?: number;
+    max_iterations?: number;
+    requirements?: RunRequirement[];
+    requires_confirmation?: boolean;
+    confirmation_message?: string;
+    requires_user_input?: boolean;
+    user_input_message?: string;
+    user_input_schema?: UserInputField[];
+    available_choices?: string[];
+    allow_multiple_selections?: boolean;
+    error?: string;
+    error_type?: string;
+    model?: string;
+    model_provider?: string;
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    metrics?: Record<string, unknown>;
+    extra_data?: {
+        reasoning_steps?: ReasoningStep[];
+        references?: ReferenceData[];
+    };
+    [key: string]: unknown;
+}
+type PauseType = 'confirmation' | 'user_input' | 'user_feedback' | 'external_execution';
+interface RunRequirement {
+    id: string;
+    tool_execution?: ToolExecution;
+    confirmation?: boolean;
+    confirmation_note?: string;
+    user_input_schema?: UserInputField[];
+    external_execution_result?: string;
+    member_agent_id?: string;
+    member_agent_name?: string;
+    pause_type?: PauseType;
+}
+type ChatRole = 'user' | 'agent' | 'system';
+type ChatStatus = 'idle' | 'streaming' | 'paused' | 'completed' | 'error' | 'cancelled';
+type SubRunStatus = 'running' | 'completed' | 'error';
+/**
+ * A nested run inside a team or workflow run — a team member's turn, or the
+ * agent/team that executes a workflow step. Accumulated from events that carry
+ * a `parent_run_id`.
+ */
+interface SubRun {
+    run_id: string;
+    kind: 'member' | 'executor';
+    name?: string;
+    agent_id?: string;
+    content: string;
+    tool_calls?: ToolExecution[];
+    status: SubRunStatus;
+}
+/** A workflow step and its output, accumulated from `Step*` events. */
+interface WorkflowStep {
+    key: string;
+    name?: string;
+    index?: number | [number, number];
+    status: SubRunStatus;
+    content?: string;
+    error?: string;
+}
+interface ChatMessage {
+    id: string;
+    role: ChatRole;
+    content: string;
+    created_at: number;
+    /** Set while this message is being streamed. */
+    streaming?: boolean;
+    /** Run-level status, set for agent messages. */
+    status?: ChatStatus;
+    error?: string;
+    run_id?: string;
+    session_id?: string;
+    tool_calls?: ToolExecution[];
+    reasoning_steps?: ReasoningStep[];
+    references?: ReferenceData[];
+    citations?: Citations;
+    /**
+     * Suggested next prompts, when the agent was built with `followups=True`.
+     * Rendered under the latest answer as "Related questions".
+     */
+    followups?: string[];
+    images?: ImageData[];
+    videos?: VideoData[];
+    audio?: AudioData[];
+    response_audio?: AudioData;
+    /** Live "what is it doing right now" label, e.g. "Calling get_weather". */
+    activity?: string;
+    /** Pause requirements when the run is waiting for a human. */
+    requirements?: RunRequirement[];
+    /** Team member turns / workflow step executors (nested runs). */
+    members?: SubRun[];
+    /** Workflow steps and their outputs. */
+    steps?: WorkflowStep[];
+    /** Every raw event that contributed to this message, in order. */
+    events?: RunEventData[];
+}
+interface Model {
+    name?: string;
+    model?: string;
+    provider?: string;
+}
+type EntityType = 'agent' | 'team' | 'workflow';
+interface Entity {
+    type: EntityType;
+    id: string;
+    name: string;
+    description?: string;
+    model?: Model;
+    db_id?: string;
+}
+interface SessionEntry {
+    session_id: string;
+    session_name?: string;
+    /** Unix seconds, Unix milliseconds, or an ISO date string, depending on the backend. */
+    created_at: number | string;
+    updated_at?: number | string;
+}
+interface Pagination {
+    page: number;
+    limit: number;
+    total_pages: number;
+    total_count: number;
+}
+interface SessionsResponse {
+    data: SessionEntry[];
+    meta?: Pagination;
+}
+
+/**
+ * Thin client for an AgentOS HTTP backend.
+ *
+ * Wraps the discovery, run, continue, cancel and session endpoints. Streaming
+ * runs are handled by `streamRun` from ./stream; everything else is plain JSON.
+ */
+
+/** Normalise a base URL: add a scheme for bare hosts, strip trailing slash. */
+declare function normaliseBaseUrl(value: string | null | undefined): string;
+interface AgnoClientOptions {
+    /** AgentOS base URL, e.g. "http://localhost:7777". */
+    baseUrl: string;
+    /** Optional headers (e.g. Authorization) added to every request. */
+    headers?: Record<string, string>;
+    /** Default db_id used for session listing where the backend requires it. */
+    dbId?: string;
+}
+interface RunArgs {
+    type: EntityType;
+    id: string;
+    message?: string;
+    sessionId?: string;
+    userId?: string;
+    files?: File[];
+    /** Extra form fields appended verbatim. */
+    extra?: Record<string, string>;
+    signal?: AbortSignal;
+    onEvent: (event: RunEventData) => void;
+    onError: (error: Error) => void;
+    onComplete: () => void;
+}
+interface ContinueArgs {
+    type: EntityType;
+    id: string;
+    runId: string;
+    sessionId?: string;
+    userId?: string;
+    /** Resolved tool executions (agents/teams human-in-the-loop). */
+    tools?: ToolExecution[];
+    /** Resolved step requirements (workflow human-in-the-loop). */
+    stepRequirements?: unknown[];
+    signal?: AbortSignal;
+    onEvent: (event: RunEventData) => void;
+    onError: (error: Error) => void;
+    onComplete: () => void;
+}
+declare class AgnoClient {
+    readonly baseUrl: string;
+    readonly headers: Record<string, string>;
+    readonly dbId?: string;
+    constructor(options: AgnoClientOptions);
+    private getJson;
+    /** Liveness check against /health. Returns the HTTP status code. */
+    health(): Promise<number>;
+    getAgents(): Promise<Entity[]>;
+    getTeams(): Promise<Entity[]>;
+    getWorkflows(): Promise<Entity[]>;
+    /** All runnable entities (agents, teams, workflows) in one list. */
+    getEntities(): Promise<Entity[]>;
+    getSessions(type: EntityType, componentId: string, dbId?: string): Promise<SessionsResponse>;
+    /** Runs (with messages/tools/events) for a session — used to rehydrate chat history. */
+    getSessionRuns(type: EntityType, sessionId: string, dbId?: string): Promise<any[]>;
+    deleteSession(sessionId: string, dbId?: string): Promise<boolean>;
+    /** Start a streaming run for an agent, team or workflow. */
+    run(args: RunArgs): Promise<void>;
+    /** Continue a paused run (resolving a human-in-the-loop requirement). */
+    continueRun(args: ContinueArgs): Promise<void>;
+    /** Cancel an in-flight run. */
+    cancelRun(type: EntityType, id: string, runId: string, sessionId?: string): Promise<boolean>;
+}
+
+export { AgnoClient as A, type ChatMessage as C, type Entity as E, type ImageData as I, type Model as M, type Pagination as P, type ReasoningStep as R, type SessionEntry as S, TeamRunEvent as T, type UserInputField as U, type VideoData as V, WorkflowRunEvent as W, type AgnoClientOptions as a, type AnyRunEventName as b, type AudioData as c, type ChatRole as d, type ChatStatus as e, type Citations as f, type EntityType as g, type PauseType as h, type Reference as i, type ReferenceData as j, RunEvent as k, type RunEventData as l, type RunRequirement as m, type SessionsResponse as n, type SubRun as o, type SubRunStatus as p, type ToolExecution as q, type WorkflowStep as r, normaliseBaseUrl as s };

package/dist/core/index.cjs

@@ -0,0 +1,94 @@
+'use client';
+'use strict';
+
+var chunk2WM3CCFE_cjs = require('../chunk-2WM3CCFE.cjs');
+var chunk55HQJGLP_cjs = require('../chunk-55HQJGLP.cjs');
+
+
+
+Object.defineProperty(exports, "RunEvent", {
+  enumerable: true,
+  get: function () { return chunk2WM3CCFE_cjs.RunEvent; }
+});
+Object.defineProperty(exports, "TeamRunEvent", {
+  enumerable: true,
+  get: function () { return chunk2WM3CCFE_cjs.TeamRunEvent; }
+});
+Object.defineProperty(exports, "WorkflowRunEvent", {
+  enumerable: true,
+  get: function () { return chunk2WM3CCFE_cjs.WorkflowRunEvent; }
+});
+Object.defineProperty(exports, "AgnoClient", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.AgnoClient; }
+});
+Object.defineProperty(exports, "activityLabel", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.activityLabel; }
+});
+Object.defineProperty(exports, "applyStepEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.applyStepEvent; }
+});
+Object.defineProperty(exports, "applySubRunEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.applySubRunEvent; }
+});
+Object.defineProperty(exports, "isCompletedEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isCompletedEvent; }
+});
+Object.defineProperty(exports, "isContentEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isContentEvent; }
+});
+Object.defineProperty(exports, "isErrorEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isErrorEvent; }
+});
+Object.defineProperty(exports, "isFollowupsCompletedEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isFollowupsCompletedEvent; }
+});
+Object.defineProperty(exports, "isPausedEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isPausedEvent; }
+});
+Object.defineProperty(exports, "isReasoningStepEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isReasoningStepEvent; }
+});
+Object.defineProperty(exports, "isStepEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isStepEvent; }
+});
+Object.defineProperty(exports, "isSubRunEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isSubRunEvent; }
+});
+Object.defineProperty(exports, "isToolEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.isToolEvent; }
+});
+Object.defineProperty(exports, "mergeTool", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.mergeTool; }
+});
+Object.defineProperty(exports, "normaliseBaseUrl", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.normaliseBaseUrl; }
+});
+Object.defineProperty(exports, "sessionRunsToMessages", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.sessionRunsToMessages; }
+});
+Object.defineProperty(exports, "streamRun", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.streamRun; }
+});
+Object.defineProperty(exports, "toolsFromEvent", {
+  enumerable: true,
+  get: function () { return chunk55HQJGLP_cjs.toolsFromEvent; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/core/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/core/index.d.cts

@@ -0,0 +1,108 @@
+import { k as RunEvent, l as RunEventData, q as ToolExecution, C as ChatMessage, R as ReasoningStep, j as ReferenceData, o as SubRun } from '../client-DUyVqxU9.cjs';
+export { A as AgnoClient, a as AgnoClientOptions, b as AnyRunEventName, c as AudioData, d as ChatRole, e as ChatStatus, f as Citations, E as Entity, g as EntityType, I as ImageData, M as Model, P as Pagination, h as PauseType, i as Reference, m as RunRequirement, S as SessionEntry, n as SessionsResponse, p as SubRunStatus, T as TeamRunEvent, U as UserInputField, V as VideoData, W as WorkflowRunEvent, r as WorkflowStep, s as normaliseBaseUrl } from '../client-DUyVqxU9.cjs';
+
+/**
+ * Streaming parser for AgentOS run endpoints.
+ *
+ * AgentOS streams a run as a sequence of JSON objects concatenated on the wire
+ * (not strictly newline-delimited). Each object is one "run event". This module
+ * reads the response body incrementally, extracts complete JSON objects as they
+ * arrive, and hands each one to a callback.
+ *
+ * It supports both the legacy shape (the event object sent directly) and the
+ * newer envelope shape ({ event: string, data: string | object }), normalising
+ * both into a flat event object with an `event` discriminator field.
+ */
+
+/** A parsed, normalised run event. Shape varies by `event` type — see types.ts. */
+interface StreamEvent {
+    event: RunEvent | string;
+    [key: string]: unknown;
+}
+interface StreamRunOptions {
+    url: string;
+    body: FormData | Record<string, unknown>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    onEvent: (event: StreamEvent) => void;
+    onError: (error: Error) => void;
+    onComplete: () => void;
+}
+/**
+ * POSTs a run request and streams the response, calling `onEvent` for every
+ * run event as it arrives. Resolves when the stream ends.
+ */
+declare function streamRun(options: StreamRunOptions): Promise<void>;
+
+/**
+ * Helpers for turning AgentOS session history into render-ready chat messages.
+ *
+ * `GET /sessions/{id}/runs` returns an array of run records. Each run carries
+ * the user input plus the agent's content, tools, reasoning, references and
+ * media — enough to reconstruct the transcript for a past session.
+ */
+
+interface SessionRun {
+    run_id?: string;
+    session_id?: string;
+    run_input?: unknown;
+    content?: unknown;
+    created_at?: number;
+    status?: string;
+    /** Present when the agent was configured with `store_events`. */
+    events?: RunEventData[];
+    tools?: ToolExecution[];
+    images?: ChatMessage['images'];
+    videos?: ChatMessage['videos'];
+    audio?: ChatMessage['audio'];
+    response_audio?: ChatMessage['response_audio'];
+    extra_data?: {
+        reasoning_steps?: ReasoningStep[];
+        references?: ReferenceData[];
+    };
+    reasoning_steps?: ReasoningStep[];
+    references?: ReferenceData[];
+    followups?: string[];
+}
+/** Convert the runs of a session into an ordered list of chat messages. */
+declare function sessionRunsToMessages(runs: SessionRun[]): ChatMessage[];
+
+/**
+ * Helpers for classifying run events and turning them into UI labels.
+ *
+ * Agent, team and workflow events share shapes but use different name prefixes
+ * (e.g. `RunContent` vs `TeamRunContent`). These helpers let the rest of the
+ * library treat them uniformly.
+ */
+
+declare const isContentEvent: (e: RunEventData) => boolean;
+declare const isCompletedEvent: (e: RunEventData) => boolean;
+declare const isErrorEvent: (e: RunEventData) => boolean;
+declare const isPausedEvent: (e: RunEventData) => boolean;
+declare const isToolEvent: (e: RunEventData) => boolean;
+declare const isReasoningStepEvent: (e: RunEventData) => boolean;
+/** The follow-up prompts an agent built with `followups=True` suggests. */
+declare const isFollowupsCompletedEvent: (e: RunEventData) => boolean;
+/**
+ * A nested-run event — a team member's turn or a workflow step executor.
+ * Identified by a `parent_run_id` on an agent/team content/tool/run event.
+ */
+declare function isSubRunEvent(e: RunEventData): boolean;
+/** A workflow step lifecycle event (start / output / complete / error). */
+declare function isStepEvent(e: RunEventData): boolean;
+/** Tool executions carried by an event, from either the single or array field. */
+declare function toolsFromEvent(e: RunEventData): ToolExecution[];
+/**
+ * A short human-readable label describing what a run is doing at the moment of
+ * this event — for a live status line ("Calling get_weather", "Reasoning…").
+ * Returns null for events that don't warrant a status change.
+ */
+declare function activityLabel(e: RunEventData): string | null;
+/** Apply a nested member/executor run event into a message's `members`. */
+declare function applySubRunEvent(message: ChatMessage, e: RunEventData, kind: SubRun['kind']): ChatMessage;
+/** Apply a workflow `Step*` event into a message's `steps`. */
+declare function applyStepEvent(message: ChatMessage, e: RunEventData): ChatMessage;
+/** Merge a tool execution into a list, updating an existing entry by id/name. */
+declare function mergeTool(list: ToolExecution[], tool: ToolExecution): ToolExecution[];
+
+export { ChatMessage, ReasoningStep, ReferenceData, RunEvent, RunEventData, type StreamEvent, type StreamRunOptions, SubRun, ToolExecution, activityLabel, applyStepEvent, applySubRunEvent, isCompletedEvent, isContentEvent, isErrorEvent, isFollowupsCompletedEvent, isPausedEvent, isReasoningStepEvent, isStepEvent, isSubRunEvent, isToolEvent, mergeTool, sessionRunsToMessages, streamRun, toolsFromEvent };