import { i as ChatMessage } from './chat-rMlckAQG.js';
export { h as ChatAttachment, j as Composer, k as ComposerProps, l as ContentPart, S as SendOptions, p as Suggestions, q as SuggestionsComponent, r as SuggestionsSlotProps, s as SuggestionsSource, t as TextContentPart, u as ThinkingContentPart, v as Thread, w as ThreadArtifactsConfig, x as ThreadComponents, y as ThreadProps, z as ThreadSuggestion, B as ThreadSuggestionsProps, E as ThreadVariant, F as ThreadWelcomeConfig, G as ThreadWelcomeProps, M as TimbalChat, N as TimbalChatProps, O as TimbalRuntimeProvider, P as TimbalRuntimeProviderProps, V as TimbalStreamApi, W as ToolCallContentPart, ag as UseTimbalStreamOptions, as as useResolvedSuggestions, at as useTimbalRuntime, au as useTimbalStream } from './chat-rMlckAQG.js';
import * as React from 'react';
import { FC } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { ToolCallMessagePartComponent } from '@assistant-ui/react';
import { WorkforceItem } from '@timbal-ai/timbal-sdk';
import { b as ButtonProps } from './button-C9cq2nm3.js';
import 'class-variance-authority/types';
import 'class-variance-authority';

declare const MarkdownText: React.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;

interface ToolStatus {
    type: string;
    reason?: string;
}
declare function useToolRunning(props: {
    status?: ToolStatus;
    result?: unknown;
}): boolean;
declare const ToolFallback: ToolCallMessagePartComponent;

interface WorkforceSelectorProps {
    /** List of workforces to choose from. */
    workforces: WorkforceItem[];
    /** Currently selected workforce id. */
    value: string;
    /** Called when the user picks a different workforce. */
    onChange: (id: string) => void;
    /** Hide the selector when there's only one option. Default: true. */
    hideWhenSingle?: boolean;
    className?: string;
    placeholder?: string;
}
/**
 * Minimal headless workforce picker. Wraps a styled native `<select>` so
 * the SDK doesn't need to depend on `@radix-ui/react-select`, while still
 * matching the Studio chrome (gradient pill, soft border, chevron).
 *
 * Apps that want a richer UI (search, descriptions, agent icons) can build
 * their own using `useWorkforces()`.
 */
declare const WorkforceSelector: FC<WorkforceSelectorProps>;

/** Pill-button intents kept stable for chat-surface toolbars. */
type TooltipIconButtonVariant = "primary" | "secondary" | "ghost" | "informative" | "destructive";
interface TooltipIconButtonProps extends Omit<ButtonProps, "variant" | "color" | "size" | "shape"> {
    /** Visible tooltip + accessible label. Always required. */
    tooltip: string;
    /** Tooltip placement. Default: "bottom". */
    side?: "top" | "bottom" | "left" | "right";
    /** Pill intent. Default: "secondary". */
    variant?: TooltipIconButtonVariant;
}
/**
 * Icon-only pill button with a tooltip. Used by every chat-surface toolbar
 * (composer send/cancel, message action bar, scroll-to-bottom).
 *
 * Defaults to a soft `secondary` variant so it sits cleanly inside composers,
 * message bubbles, and the action bar. Override via `variant`. Renders the
 * shared {@link Button} as a fully-rounded `icon-sm` pill.
 */
declare const TooltipIconButton: React.ForwardRefExoticComponent<Omit<TooltipIconButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

declare const UserMessageAttachments: FC;
declare const ComposerAttachments: FC;
declare const ComposerAddAttachment: FC;

/**
 * Official layout class strings for custom `Thread` message slots.
 *
 * `Thread` sets `--thread-max-width` (default {@link THREAD_DEFAULT_MAX_WIDTH}).
 * Overriding `components.AssistantMessage` or `components.UserMessage` removes
 * the built-in chrome — apply these on `MessagePrimitive.Root`.
 */
/** Default `maxWidth` on `Thread` / `TimbalChatShell`. */
declare const THREAD_DEFAULT_MAX_WIDTH = "44rem";
/** Shared column — aligns custom messages with the composer footer. */
declare const threadMessageColumnClass = "mx-auto w-full max-w-(--thread-max-width)";
/** Matches built-in assistant message root (minus motion utilities). */
declare const assistantMessageRootClass: string;
/** Inner content padding for assistant text / artifacts. */
declare const assistantMessageContentClass = "wrap-break-word px-2 text-foreground leading-relaxed";
/** Matches built-in user message root. */
declare const userMessageRootClass: string;

type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;
/** Mirrors BE `RunSortBy` — `created_at` is an alias of `id`. */
type RunSortBy = "id" | "created_at" | "duration_ms" | "cost_usd" | "cost_credits";
/** Mirrors BE `SortOrder`. */
type RunSortOrder = "asc" | "desc";
type RunStatus = "running" | "success" | "error" | "cancelled" | "timeout" | (string & {});
interface RunUser {
    id?: string | number;
    name?: string | null;
    email?: string | null;
    photo_url?: string | null;
}
interface RunWorkforce {
    id?: string | number;
    name?: string | null;
    type?: string | null;
    deleted_at?: number | null;
}
/**
 * One run row as returned by the list endpoint. Root rows (`roots=true`)
 * intentionally do **not** carry thread aggregates (turn count, last message,
 * total cost) — fetch the trace via {@link getRun} when you need them.
 */
interface RunPreview {
    id: string | number;
    /** Conversation handle. Equals `id` on the root run. */
    group_id?: string | number | null;
    /** Parent turn id; `null`/absent on the thread root. */
    parent_id?: string | number | null;
    /** Older alias some surfaces emit. */
    parent_run_id?: string | number | null;
    created_at?: string;
    status?: RunStatus;
    duration_ms?: number | null;
    cost_usd?: number | null;
    cost_credits?: number | null;
    last_reaction_sentiment?: "positive" | "negative" | null;
    user?: RunUser | null;
    workforce?: RunWorkforce | null;
    [key: string]: unknown;
}
/** A single span inside a run's flat `trace` array. */
interface TraceSpan {
    call_id?: string | null;
    parent_call_id?: string | null;
    path?: string | null;
    metadata?: {
        type?: string | null;
    } & Record<string, unknown>;
    input?: unknown;
    output?: unknown;
    error?: unknown;
    usage?: unknown;
    cost_usd?: number | null;
    cost_credits?: number | null;
    start_time?: number | null;
    end_time?: number | null;
    t0?: number | null;
    t1?: number | null;
    [key: string]: unknown;
}
/** Full run detail — the list `RunPreview` plus the span `trace`. */
interface RunDetail extends RunPreview {
    trace?: TraceSpan[] | null;
}
interface ListRunsResult {
    runs: RunPreview[];
    next_page_token?: string | null;
}
interface ListRunsParams {
    /** Base URL for API calls. Default: `/api`. */
    baseUrl?: string;
    /** Custom fetch (defaults to `authFetch`). */
    fetch?: FetchFn;
    /** Path segment for the runs collection under `baseUrl`. Default: `runs`. */
    runsPath?: string;
    /** Abort signal forwarded to the request. */
    signal?: AbortSignal;
    /** Only return thread roots (`parent_id IS NULL`) — one row per conversation. */
    roots?: boolean;
    /** Scope to a single workforce component (legacy `app_id`). */
    workforceId?: string | null;
    /** Return every turn in one conversation (pass the root run's id). */
    groupId?: string | number | null;
    /** Offset pagination cursor (`0`, `50`, `100`, …). */
    pageToken?: string | null;
    /** Filter to a single user's runs (requires `projects.runs.list`). */
    userId?: string | null;
    status?: RunStatus | null;
    /** Git branch the runs executed against (query key `rev`). */
    rev?: string | null;
    sortBy?: RunSortBy | null;
    sortOrder?: RunSortOrder | null;
}
/**
 * List runs. Pass `roots: true` to list conversation entry points, or
 * `groupId` to list every turn inside one conversation.
 */
declare function listRuns(params?: ListRunsParams): Promise<ListRunsResult>;
interface GetRunParams {
    runId: string | number;
    baseUrl?: string;
    fetch?: FetchFn;
    runsPath?: string;
    signal?: AbortSignal;
}
/** Fetch one run's full detail, including its span `trace`. */
declare function getRun(params: GetRunParams): Promise<RunDetail>;
/** Normalize the parent pointer across the `parent_id` / `parent_run_id` aliases. */
declare function runParentId(run: RunPreview): string | null;
/** True when the run is a conversation root (no parent; `group_id === id`). */
declare function isRootRun(run: RunPreview): boolean;
/**
 * Order runs into thread sequence: depth-first by `parent_id` when present,
 * otherwise chronological by `created_at`. Mirrors the platform's
 * `orderRunsForThread`.
 */
declare function orderRunsForThread<T extends RunPreview>(runs: T[]): T[];

/** Flatten Anthropic-style content (string | block[] | nested) to plain text. */
declare function normalizeContentToText(content: unknown): string;
interface RunTraceToMessagesOptions {
    /** Stamp this run id onto produced messages (enables thread continuation). */
    runId?: string | number | null;
    /** Drop the user message (e.g. when the run carries only system output). */
    includeUser?: boolean;
}
/**
 * Convert a single run's `trace` into `[userMessage?, assistantMessage]`.
 * Returns `[]` when the trace yields no usable content.
 */
declare function runTraceToMessages(trace: TraceSpan[] | null | undefined, options?: RunTraceToMessagesOptions): ChatMessage[];
/**
 * Stitch a whole conversation (all runs sharing a `group_id`) into one ordered
 * `ChatMessage[]`. Pass the run list from `listRuns({ groupId })` plus a map of
 * run id → `RunDetail` (with `trace`) from {@link getRun}.
 */
declare function conversationRunsToMessages(runs: RunPreview[], detailByRunId: Map<string, RunDetail> | Record<string, RunDetail>): ChatMessage[];

interface UseConversationsOptions {
    /** Base URL for API calls. Default: `/api`. */
    baseUrl?: string;
    /** Custom fetch (defaults to `authFetch`). */
    fetch?: FetchFn;
    /** Path segment for the runs collection under `baseUrl`. Default: `runs`. */
    runsPath?: string;
    /** Scope to a single workforce component. Strongly recommended. */
    workforceId?: string | null;
    /** Restrict to one user (requires `projects.runs.list`). */
    userId?: string | null;
    /** Default `created_at`. */
    sortBy?: RunSortBy | null;
    /** Default `desc` (newest first). */
    sortOrder?: RunSortOrder | null;
    /** When false, skips fetching and returns an empty list. */
    enabled?: boolean;
}
interface UseConversationsResult {
    /** Thread roots — one row per conversation. */
    conversations: RunPreview[];
    isLoading: boolean;
    /** True while a `loadMore()` page is in flight. */
    isLoadingMore: boolean;
    error: Error | null;
    /** True when another page is available. */
    hasMore: boolean;
    /** Fetch the next page and append to `conversations`. */
    loadMore: () => Promise<void>;
    /** Reload from the first page. Resets pagination + error. */
    refresh: () => Promise<void>;
}
/**
 * List conversation entry points (thread roots) for a workforce, with offset
 * pagination. Each item is a root `RunPreview` whose `id` is the thread handle
 * to pass to {@link useConversation}.
 *
 * Roots are ordered by thread creation time (the API caveat: not last
 * activity), and root rows don't carry thread aggregates — fetch the trace via
 * `useConversation` / `getRun` for a title or message preview.
 */
declare function useConversations(options?: UseConversationsOptions): UseConversationsResult;

interface UseConversationOptions {
    /** Root run id (the conversation handle). `null` clears the result. */
    conversationId?: string | number | null;
    baseUrl?: string;
    fetch?: FetchFn;
    runsPath?: string;
    /** Scope to a single workforce component (matches the conversation list). */
    workforceId?: string | null;
    /** Max turns to hydrate traces for. Default: 60. Extra turns set `truncated`. */
    maxTurns?: number;
    /** When false, skips fetching. */
    enabled?: boolean;
}
interface UseConversationResult {
    /** Every turn (run) in the thread, ordered oldest → newest. */
    runs: RunPreview[];
    /** `<Thread>`-ready messages reconstructed from the per-turn traces. */
    messages: ChatMessage[];
    isLoading: boolean;
    error: Error | null;
    /** True when the thread has more turns than `maxTurns`. */
    truncated: boolean;
    refresh: () => Promise<void>;
}
/**
 * Load a single conversation thread and reconstruct it as `ChatMessage[]`.
 *
 * Fetches every turn sharing the conversation's `group_id`, pulls each turn's
 * trace, and stitches them into ordered messages (see
 * `conversationRunsToMessages`). Feed `messages` into a `<Thread>` via
 * `useTimbalRuntime().loadMessages(messages)` to reopen the conversation; the
 * last assistant `runId` lets the next send continue the same thread.
 */
declare function useConversation(options?: UseConversationOptions): UseConversationResult;

export { ChatMessage, ComposerAddAttachment, ComposerAttachments, type GetRunParams, type ListRunsParams, type ListRunsResult, MarkdownText, type RunDetail, type RunPreview, type RunSortBy, type RunSortOrder, type RunStatus, type RunTraceToMessagesOptions, type RunUser, type RunWorkforce, THREAD_DEFAULT_MAX_WIDTH, ToolFallback, TooltipIconButton, type TooltipIconButtonProps, type TooltipIconButtonVariant, type TraceSpan, type UseConversationOptions, type UseConversationResult, type UseConversationsOptions, type UseConversationsResult, UserMessageAttachments, WorkforceSelector, type WorkforceSelectorProps, assistantMessageContentClass, assistantMessageRootClass, conversationRunsToMessages, getRun, isRootRun, listRuns, normalizeContentToText, orderRunsForThread, runParentId, runTraceToMessages, threadMessageColumnClass, useConversation, useConversations, useToolRunning, userMessageRootClass };