@wacht/jsx 1.0.0-beta.6 → 1.0.0-beta.61

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { AgentContext } from '@wacht/types';
-import { AgentIntegration } from '@wacht/types';
-import { AgentMcpServer } from '@wacht/types';
-import { AgentWithIntegrations } from '@wacht/types';
+import { Actor } from '@wacht/types';
+import { ActorMcpServerSummary } from '@wacht/types';
+import { ActorProject } from '@wacht/types';
+import { Agent } from '@wacht/types';
+import { AgentThread } from '@wacht/types';
+import { AnswerSubmission } from '@wacht/types';
 import { ApiAuditAnalyticsResponse } from '@wacht/types';
 import { ApiAuditLogsResponse } from '@wacht/types';
 import { ApiAuditTimeseriesResponse } from '@wacht/types';
@@ -14,35 +16,31 @@ import { CancelReplayTaskOptions } from '@wacht/types';
 import { CancelReplayTaskResponse } from '@wacht/types';
 import { Client } from '@wacht/types';
 import { ComponentPropsWithoutRef } from 'react';
-import { ConsentURLResponse } from '@wacht/types';
 import { ConversationMessage } from '@wacht/types';
+import { CreateActorProjectRequest } from '@wacht/types';
+import { CreateAgentThreadRequest } from '@wacht/types';
 import { CreateApiAuthKeyInput } from '@wacht/types';
-import { CreateContextRequest } from '@wacht/types';
 import { CreateEndpointOptions } from '@wacht/types';
 import { CreateEnterpriseConnectionPayload } from '@wacht/types';
+import { CreateProjectTaskBoardItemRequest } from '@wacht/types';
 import { CSSProperties } from 'react';
 import { CurrentUser } from '@wacht/types';
 import { default as default_2 } from 'react';
 import { DeleteEndpointResponse } from '@wacht/types';
 import { Deployment } from '@wacht/types';
 import { DeploymentUISettings } from '@wacht/types';
-import { DetailedHTMLProps } from 'react';
 import { EndpointWithSubscriptions } from '@wacht/types';
 import { EnterpriseConnection } from '@wacht/types';
-import { ErrorInterface } from '@wacht/types';
-import { FastOmit } from 'styled-components';
+import { ExternalAgentConnection } from '@wacht/types';
 import { FC } from 'react';
 import { FileData } from '@wacht/types';
 import { FormHTMLAttributes } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { HTMLAttributes } from 'react';
 import { InputHTMLAttributes } from 'react';
-import { IStyledComponentBase } from 'styled-components/dist/types';
 import { JSX } from 'react/jsx-runtime';
 import { KeyedMutator } from 'swr';
 import { LabelHTMLAttributes } from 'react';
-import { ListContextsOptions } from '@wacht/types';
-import { McpConnectResponse } from '@wacht/types';
 import { NewDomain } from '@wacht/types';
 import { NewOrgnization } from '@wacht/types';
 import { Notification as Notification_2 } from '@wacht/types';
@@ -55,8 +53,14 @@ import { OrganizationMembership } from '@wacht/types';
 import { OrganizationMembershipWithOrganization } from '@wacht/types';
 import { OrganizationRole } from '@wacht/types';
 import { OrganizationUpdate } from '@wacht/types';
+import { PendingQuestion } from '@wacht/types';
 import { ProfileCompletionData } from '@wacht/types';
 import { ProfileCompletionProps } from '@wacht/types';
+import { ProjectTaskBoardItem } from '@wacht/types';
+import { ProjectTaskBoardItemAssignment } from '@wacht/types';
+import { ProjectTaskBoardItemComment } from '@wacht/types';
+import { ProjectTaskWorkspaceFileContent } from '@wacht/types';
+import { ProjectTaskWorkspaceListing } from '@wacht/types';
 import { ReactNode } from 'react';
 import { RefAttributes } from 'react';
 import { ReplayTaskListOptions } from '@wacht/types';
@@ -77,12 +81,17 @@ import { SigninAttempt } from '@wacht/types';
 import { SignupAttempt } from '@wacht/types';
 import { SignUpParams } from '@wacht/types';
 import { SocialConnection } from '@wacht/types';
-import { Substitute } from 'styled-components/dist/types';
 import { TestEndpointOptions } from '@wacht/types';
 import { TestEndpointResponse } from '@wacht/types';
+import { ThreadPendingApprovalRequestState } from '@wacht/types';
+import { ThreadTaskGraphBundle } from '@wacht/types';
 import { TimeseriesPoint } from '@wacht/types';
+import { ToolApprovalDecision } from '@wacht/types';
+import { UpdateActorProjectRequest } from '@wacht/types';
+import { UpdateAgentThreadRequest } from '@wacht/types';
 import { UpdateEndpointOptions } from '@wacht/types';
 import { UpdateEnterpriseConnectionPayload } from '@wacht/types';
+import { UpdateProjectTaskBoardItemRequest } from '@wacht/types';
 import { UpdateWebhookSettingsOptions } from '@wacht/types';
 import { UseApiAuthAuditAnalyticsOptions } from '@wacht/types';
 import { UseApiAuthAuditLogsOptions } from '@wacht/types';
@@ -90,7 +99,6 @@ import { UseApiAuthAuditTimeseriesOptions } from '@wacht/types';
 import { UseApiAuthKeysFilters } from '@wacht/types';
 import { UserAuthenticator } from '@wacht/types';
 import { UserEmailAddress } from '@wacht/types';
-import { UserInputRequestContent } from '@wacht/types';
 import { UserPasskey } from '@wacht/types';
 import { UserPhoneNumber } from '@wacht/types';
 import { UseWebhookAnalyticsOptions } from '@wacht/types';
@@ -135,7 +143,32 @@ declare interface AcceptInviteProps {
     onError?: (error: string) => void;
 }
 
-export declare function AuthFormImage(): JSX.Element | null;
+declare interface ActorMcpServerConnectResponse {
+    auth_url: string;
+}
+
+declare type AgentSearchOptions = {
+    enabled?: boolean;
+    query?: string;
+    limit?: number;
+};
+
+declare type AgentThreadHookOptions = {
+    enabled?: boolean;
+    limit?: number;
+    /**
+     * Order in which thread-assignment rows are returned. `"asc"` (default) =
+     * oldest first; `"desc"` = newest first. Combine with `limit: 1` to fetch
+     * only the latest assignment.
+     */
+    order?: AssignmentListOrder;
+};
+
+declare type AssignmentListOrder = "asc" | "desc";
+
+export declare function AuthFormImage({ placement, }: {
+    placement?: "center" | "left" | "right";
+}): JSX.Element | null;
 
 /**
  * Check if user can manage the organization (admin or manage permissions)
@@ -147,6 +180,10 @@ export declare function canManageOrganization(membership: WithOrgRoles): boolean
  */
 export declare function canManageWorkspace(membership: WithWsRoles): boolean;
 
+declare type ChallengeParams = {
+    challenge_token?: string;
+};
+
 export declare function clearTokenCache(): void;
 
 declare const CONNECTION_STATES: {
@@ -156,6 +193,10 @@ declare const CONNECTION_STATES: {
     readonly ERROR: "error";
 };
 
+declare interface ConnectResponse {
+    redirect_url: string;
+}
+
 export declare const CreateOrganizationForm: React.FC<CreateOrganizationFormProps>;
 
 declare interface CreateOrganizationFormProps {
@@ -183,7 +224,7 @@ declare interface CreateWorkspaceDialogProps {
     organizationId?: string;
 }
 
-export declare const CreateWorkspaceForm: default_2.FC<CreateWorkspaceFormProps>;
+export declare const CreateWorkspaceForm: React.FC<CreateWorkspaceFormProps>;
 
 declare interface CreateWorkspaceFormProps {
     organizationId?: string;
@@ -192,7 +233,13 @@ declare interface CreateWorkspaceFormProps {
     onCreateOrganization?: () => void;
 }
 
-export declare function DefaultStylesProvider({ children, style, ...props }: DefaultStylesProviderProps): JSX.Element;
+/**
+ * Scopes the Wacht SDK token contract (`--wa-*`, defined in tokens.css under
+ * `.wacht-root`) to its subtree, and makes the `.w-*` component layer available.
+ * Renders a `display: contents` wrapper so it adds no box of its own. Dark mode
+ * is driven by a `.dark` class on any ancestor (or on this element).
+ */
+export declare function DefaultStylesProvider({ children, className, style, ...props }: DefaultStylesProviderProps): JSX.Element | null;
 
 declare type DefaultStylesProviderProps = ComponentPropsWithoutRef<"div">;
 
@@ -219,13 +266,13 @@ export declare interface DeploymentInvitationData {
     error_code?: string;
 }
 
-export declare function DeploymentProvider({ children, publicKey, adapter, uiOverwrites, }: DeploymentProviderProps): JSX.Element;
+export declare function DeploymentProvider({ children, publicKey, adapter, uiOverrides, }: DeploymentProviderProps): JSX.Element;
 
 declare interface DeploymentProviderProps {
     children: ReactNode;
     publicKey: string;
     adapter: PlatformAdapter;
-    uiOverwrites?: Partial<DeploymentUISettings>;
+    uiOverrides?: Partial<DeploymentUISettings>;
 }
 
 export declare const Dialog: FC<DialogProps> & {
@@ -279,15 +326,18 @@ declare interface DialogTriggerProps {
 
 export declare const Dropdown: ({ children, open, openChange, style, }: DropdownProps) => JSX.Element;
 
-export declare const DropdownDivider: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DropdownDivider: () => JSX.Element;
 
-export declare const DropdownItem: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
-$destructive?: boolean;
-}>> & string;
+export declare const DropdownItem: ForwardRefExoticComponent<DropdownItemProps & RefAttributes<HTMLButtonElement>>;
 
-export declare const DropdownItems: ({ children, style, }: {
+declare interface DropdownItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    $destructive?: boolean;
+}
+
+export declare const DropdownItems: ({ children, style, className, }: {
     children: ReactNode;
     style?: React.CSSProperties;
+    className?: string;
 }) => JSX.Element | null;
 
 declare interface DropdownProps {
@@ -301,23 +351,23 @@ export declare const DropdownTrigger: ({ children }: {
     children: ReactNode;
 }) => JSX.Element;
 
-declare type EmailOTPSignInParams = {
+declare type EmailOTPSignInParams = ChallengeParams & {
     email: string;
 };
 
-declare type EmailOTPVerificationParams = {
+declare type EmailOTPVerificationParams = ChallengeParams & {
     strategy: "email_otp";
     redirectUri?: string;
 };
 
-declare type EmailSignInParams = {
+declare type EmailSignInParams = ChallengeParams & {
     email: string;
     password: string;
 };
 
-export declare const Form: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, never>> & string;
+export declare const Form: ForwardRefExoticComponent<FormHTMLAttributes<HTMLFormElement> & RefAttributes<HTMLFormElement>>;
 
-export declare const FormGroup: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FormGroup: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
 
 /**
  * Unified execution status mapping between frontend and backend
@@ -331,7 +381,7 @@ declare const FRONTEND_STATUS: {
     readonly FAILED: "failed";
 };
 
-declare type FrontendStatus = typeof FRONTEND_STATUS[keyof typeof FRONTEND_STATUS];
+declare type FrontendStatus = (typeof FRONTEND_STATUS)[keyof typeof FRONTEND_STATUS];
 
 declare type GenericSignInParams = {
     email?: string;
@@ -339,6 +389,7 @@ declare type GenericSignInParams = {
     password?: string;
     phone?: string;
     strategy?: string;
+    challenge_token?: string;
 };
 
 export declare function hasIncompleteProfile(session: Session): boolean;
@@ -353,7 +404,7 @@ export declare function hasOrgPermission(membership: WithOrgRoles, requiredPermi
  */
 export declare function hasWorkspacePermission(membership: WithWsRoles, requiredPermissions: string[]): boolean;
 
-export declare interface IdentifyResult {
+declare interface IdentifyResult {
     strategy: "sso" | "social" | "password";
     connection_id?: string;
     idp_url?: string;
@@ -365,7 +416,9 @@ declare type InitSSOResponseType = {
     session: Session;
 };
 
-export declare const Input: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
+export declare const Input: ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & {
+as?: "input" | "textarea";
+} & RefAttributes<HTMLInputElement>>;
 
 export declare const isExternalUrl: (url: string) => boolean;
 
@@ -381,21 +434,21 @@ export declare const isSafeUrl: (url: string) => boolean;
  */
 export declare function isWorkspaceAdmin(membership: WithWsRoles): boolean;
 
-export declare const Label: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>> & string;
+export declare const Label: ForwardRefExoticComponent<LabelHTMLAttributes<HTMLLabelElement> & RefAttributes<HTMLLabelElement>>;
 
-export declare interface MagicLinkParams {
+declare interface MagicLinkParams {
     token?: string;
     attempt?: string;
     redirectUri?: string;
 }
 
-declare type MagicLinkSignInParams = {
+declare type MagicLinkSignInParams = ChallengeParams & {
     email: string;
 };
 
 export declare function MagicLinkVerification({ onSuccess, onError, }?: MagicLinkVerificationProps): JSX.Element;
 
-declare type MagicLinkVerificationParams = {
+declare type MagicLinkVerificationParams = ChallengeParams & {
     strategy: "magic_link";
     redirectUri?: string;
 };
@@ -491,9 +544,9 @@ declare interface NotificationItemProps {
 }
 
 export declare interface NotificationMessage {
-    id: number;
-    user_id: number;
-    deployment_id: number;
+    id: string;
+    user_id: string;
+    deployment_id: string;
     title: string;
     body: string;
     severity: string;
@@ -543,7 +596,7 @@ export declare const ORG_ADMIN_PERMISSIONS: string[];
 
 export declare const ORG_MANAGEMENT_PERMISSIONS: string[];
 
-export declare const OrganizationSwitcher: ({ showPersonal, }: OrganizationSwitcherProps) => JSX.Element | null;
+export declare const OrganizationSwitcher: ({ showPersonal }: OrganizationSwitcherProps) => JSX.Element | null;
 
 declare interface OrganizationSwitcherProps {
     showPersonal?: boolean;
@@ -576,12 +629,12 @@ export declare const PhoneNumberInput: ({ value, onChange, error, countryCode, s
     setCountryCode: React.Dispatch<React.SetStateAction<string | undefined>>;
 }) => JSX.Element;
 
-declare type PhoneOTPVerificationParams = {
+declare type PhoneOTPVerificationParams = ChallengeParams & {
     strategy: "phone_otp";
     lastDigits?: string;
 };
 
-declare type PhoneSignInParams = {
+declare type PhoneSignInParams = ChallengeParams & {
     phone: string;
 };
 
@@ -631,6 +684,27 @@ declare interface ProfileUpdateData {
     remove_profile_picture?: boolean;
 }
 
+declare type ProjectTaskDetailOptions = {
+    includeArchived?: boolean;
+    /**
+     * Order in which assignments are returned. `"asc"` (default) lists oldest
+     * first; `"desc"` lists newest first which is convenient when you only need
+     * the most recent assignment (combine with `assignmentsLimit: 1`).
+     */
+    assignmentsOrder?: AssignmentListOrder;
+    /**
+     * Page size for the assignments list. Default 40, max 200 (server-side cap).
+     */
+    assignmentsLimit?: number;
+};
+
+declare type ProjectTaskListOptions = {
+    statuses?: string[];
+    includeArchived?: boolean;
+    archivedOnly?: boolean;
+    limit?: number;
+};
+
 export declare function redirectToProfileCompletion(returnUrl?: string): void;
 
 export declare const RequireActiveTenancy: ({ children, }: RequireActiveTenancyProps) => JSX.Element | null;
@@ -643,7 +717,7 @@ declare type SecondFactorPolicy_2 = "none" | "optional" | "enforced";
 
 export declare const SignedIn: ({ children }: SignedInProps) => JSX.Element | null;
 
-export declare const SignedInAccounts: React.FC<SignedInAccountsProps>;
+export declare const SignedInAccounts: default_2.FC<SignedInAccountsProps>;
 
 declare interface SignedInAccountsProps {
     onAccountSelect?: (signInId: string) => void;
@@ -665,8 +739,8 @@ declare type SignIn = {
     prepareVerification: (params: VerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
     completeVerification: (verificationCode: string) => Promise<Session>;
     completeProfile: (data: ProfileCompletionData) => Promise<Session>;
-    identify: (identifier: string) => Promise<IdentifyResult>;
-    initEnterpriseSso: (connectionId: string, redirectUri?: string) => Promise<{
+    identify: (identifier: string, challengeToken?: string) => Promise<IdentifyResult>;
+    initEnterpriseSso: (connectionId: string, redirectUri?: string, challengeToken?: string) => Promise<{
         sso_url: string;
         session: Session;
     }>;
@@ -676,27 +750,17 @@ declare type SignInEmailOTP = ({ email, }: EmailOTPSignInParams) => Promise<ApiR
 
 export declare function SignInForm(): JSX.Element;
 
-declare type SignInFunction<T extends SignInStrategy> = {
-    ["username"]: SignInPlainUsername;
-    ["email"]: SignInPlainEmail;
-    ["phone"]: SignInPhone;
-    ["email_otp"]: SignInEmailOTP;
-    ["magic_link"]: SignInMagicLink;
-    ["oauth"]: SignInOauth;
-    ["passkey"]: SignInPasskey;
-    ["generic"]: SignInGeneric;
-}[T];
-
-declare type SignInGeneric = ({ email, username, password, phone, strategy, }: GenericSignInParams) => Promise<ApiResult<Session>>;
+declare type SignInGeneric = ({ email, username, password, phone, strategy, challenge_token, }: GenericSignInParams) => Promise<ApiResult<Session>>;
 
 declare type SignInMagicLink = ({ email, }: MagicLinkSignInParams) => Promise<ApiResult<Session>>;
 
 declare type SignInOauth = ({ provider, redirectUri, }: {
     provider: OAuthProvider;
     redirectUri?: string;
+    challenge_token?: string;
 }) => Promise<ApiResult<InitSSOResponseType>>;
 
-declare type SignInPasskey = () => Promise<ApiResult<Session>>;
+declare type SignInPasskey = (params?: ChallengeParams) => Promise<ApiResult<Session>>;
 
 declare type SignInPhone = ({ phone, }: PhoneSignInParams) => Promise<ApiResult<Session>>;
 
@@ -704,17 +768,16 @@ declare type SignInPlainEmail = ({ email, password, }: EmailSignInParams) => Pro
 
 declare type SignInPlainUsername = ({ username, password, }: UsernameSignInParams) => Promise<ApiResult<Session>>;
 
-declare type SignInStrategy = "username" | "email" | "phone" | "email_otp" | "magic_link" | "oauth" | "passkey" | "generic";
-
 declare type SignupEmailOTPVerificationParams = {
     strategy: "email_otp";
     redirectUri?: string;
+    challenge_token?: string;
 };
 
 export declare function SignUpForm(): JSX.Element;
 
 export declare type SignUpFunction = {
-    create: (params: SignUpParams) => Promise<ApiResult<unknown, ErrorInterface>>;
+    create: (params: SignUpParams) => Promise<ApiResult<unknown>>;
     prepareVerification: (params: SignupVerificationParams) => Promise<ApiResult<PrepareVerificationResponse_2>>;
     completeVerification: (verificationCode: string) => Promise<ApiResult<Session>>;
     validateDeploymentInvitation: (token: string) => Promise<DeploymentInvitationData>;
@@ -723,6 +786,7 @@ export declare type SignUpFunction = {
 declare type SignupPhoneOTPVerificationParams = {
     strategy: "phone_otp";
     lastDigits?: string;
+    challenge_token?: string;
 };
 
 declare type SignupVerificationParams = SignupEmailOTPVerificationParams | SignupPhoneOTPVerificationParams;
@@ -739,16 +803,9 @@ declare interface SimpleDialogProps {
     showCloseButton?: boolean;
 }
 
-export declare const Spinner: ({ size, className }: SpinnerProps) => JSX.Element;
+export declare function SocialCallback(): JSX.Element;
 
-declare interface SpinnerProps {
-    size?: number;
-    className?: string;
-}
-
-export declare function SSOCallback(): JSX.Element;
-
-declare interface SSOCallbackState {
+declare interface SocialCallbackState {
     loading: boolean;
     error: Error | null;
     session: Session | null;
@@ -757,6 +814,13 @@ declare interface SSOCallbackState {
     signinAttempt: SigninAttempt | null;
 }
 
+export declare const Spinner: ({ size, className }: SpinnerProps) => JSX.Element;
+
+declare interface SpinnerProps {
+    size?: number;
+    className?: string;
+}
+
 export declare const Switch: default_2.FC<SwitchProps>;
 
 declare interface SwitchProps {
@@ -880,8 +944,8 @@ export declare const useActiveOrganization: () => {
 
 export declare function useActiveTenancy(): {
     loading: boolean;
-    orgMembership: OrganizationMembershipWithOrganization | null | undefined;
-    workspaceMembership: WorkspaceMembership | null | undefined;
+    orgMembership: OrganizationMembershipWithOrganization | null;
+    workspaceMembership: WorkspaceMembership | null;
 };
 
 export declare const useActiveWorkspace: () => {
@@ -920,22 +984,110 @@ export declare const useActiveWorkspace: () => {
     resendInvitation: (invitationId: string) => Promise<unknown>;
 };
 
-export declare function useAgentContext({ contextId, agentName, platformAdapter, }: UseAgentContextProps): {
+export declare function useActorMcpServers(enabled?: boolean): {
+    servers: ActorMcpServerSummary[];
+    loading: boolean;
+    error: any;
+    connect: (mcpServerId: string) => Promise<ApiResult<ActorMcpServerConnectResponse>>;
+    disconnect: (mcpServerId: string) => Promise<ApiResult<    {
+    success: boolean;
+    }>>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useActorProjects(options?: {
+    includeArchived?: boolean;
+    enabled?: boolean;
+}): {
+    projects: ActorProject[];
+    loading: boolean;
+    error: any;
+    createProject: (request: CreateActorProjectRequest) => Promise<ApiResult<ActorProject>>;
+    updateProject: (projectId: string, request: UpdateActorProjectRequest) => Promise<ApiResult<ActorProject>>;
+    archiveProject: (projectId: string) => Promise<ApiResult<ActorProject>>;
+    unarchiveProject: (projectId: string) => Promise<ApiResult<ActorProject>>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useActorProjectSearch(options?: AgentSearchOptions): {
+    projects: ActorProject[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    nextCursor: string | undefined;
+    refetch: () => Promise<void>;
+};
+
+export declare function useActorThreadSearch(options?: AgentSearchOptions): {
+    threads: AgentThread[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    nextCursor: string | undefined;
+    refetch: () => Promise<void>;
+};
+
+export declare function useAgentSession(ticket?: string | null): UseAgentSessionResult;
+
+declare interface UseAgentSessionResult {
+    hasSession: boolean;
+    sessionLoading: boolean;
+    sessionError: Error | null;
+    sessionId: string | null;
+    actor: Actor | null;
+    agents: Agent[];
+    ticketExchanged: boolean;
+    ticketLoading: boolean;
+    refetch: () => Promise<void>;
+}
+
+export declare function useAgentThread(threadId?: string, enabled?: boolean): {
+    thread: AgentThread | null;
+    loading: boolean;
+    error: any;
+    updateThread: (request: UpdateAgentThreadRequest) => Promise<ApiResult<AgentThread>>;
+    archiveThread: () => Promise<ApiResult<AgentThread>>;
+    unarchiveThread: () => Promise<ApiResult<AgentThread>>;
+    submitAnswer: (submission: AnswerSubmission) => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useAgentThreadAssignments(threadId?: string, options?: AgentThreadHookOptions): {
+    assignments: ProjectTaskBoardItemAssignment[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    loadingMore: boolean;
+    loadMore: () => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useAgentThreadConversation({ threadId, initialThread, boardItemId, platformAdapter, }: UseAgentThreadConversationProps): {
+    thread: AgentThread | null;
+    threadState: AgentThread | null;
+    threadStatus: string | undefined;
     messages: ConversationMessage[];
-    quickQuestions: string[];
     pendingMessage: string | null;
     pendingFiles: File[] | null;
     connectionState: {
         status: (typeof CONNECTION_STATES)[keyof typeof CONNECTION_STATES];
     };
     isConnected: boolean;
-    isExecuting: boolean;
+    hasActiveRun: boolean;
+    isRunning: boolean;
     executionStatus: FrontendStatus;
     isWaitingForInput: boolean;
+    pendingApprovalRequest: ThreadPendingApprovalRequestState | null;
+    pendingClarificationRequest: PendingQuestion | null;
     hasMoreMessages: boolean;
     isLoadingMore: boolean;
+    messagesLoading: boolean;
+    messagesError: Error | null;
+    refreshThread: () => Promise<void>;
+    refreshMessages: () => Promise<void>;
     sendMessage: (message: string, files?: File[]) => Promise<void>;
-    submitUserInput: (input: string) => Promise<void>;
+    submitApprovalResponse: (requestMessageId: string, approvals: ToolApprovalDecision[]) => Promise<boolean>;
+    submitAnswer: (submission: AnswerSubmission) => Promise<boolean>;
     clearMessages: () => void;
     loadMoreMessages: () => Promise<void>;
     cancelExecution: () => Promise<void>;
@@ -943,73 +1095,38 @@ export declare function useAgentContext({ contextId, agentName, platformAdapter,
     downloadMessageFile: (file: FileData | null | undefined) => void;
 };
 
-declare interface UseAgentContextProps {
-    contextId: string;
-    agentName: string;
+declare interface UseAgentThreadConversationProps {
+    threadId: string;
+    initialThread?: AgentThread | null;
+    /** Scope the conversation to a single task (board item). Omit = whole thread. */
+    boardItemId?: string;
     platformAdapter?: {
         onPlatformEvent?: (eventName: string, eventData: unknown) => void;
-        onPlatformFunction?: (functionName: string, parameters: unknown, executionId: string) => Promise<unknown>;
     };
-    onUserInputRequest?: (request: UserInputRequestContent) => Promise<string>;
-}
-
-export declare function useAgentContexts(options?: UseAgentContextsOptions): UseAgentContextsReturnType;
-
-declare interface UseAgentContextsOptions extends ListContextsOptions {
-    enabled?: boolean;
 }
 
-declare type UseAgentContextsReturnType = {
-    contexts: AgentContext[];
-    loading: boolean;
-    error: Error | null;
-    hasMore: boolean;
-    createContext: (request: CreateContextRequest) => Promise<AgentContext>;
-    deleteContext: (id: string) => Promise<void>;
-    updateContext: (id: string, updates: {
-        title?: string;
-    }) => Promise<void>;
-    refetch: () => Promise<void>;
-};
-
-export declare function useAgentIntegrations(agentName: string | null): UseAgentIntegrationsReturnType;
-
-declare type UseAgentIntegrationsReturnType = {
-    integrations: AgentIntegration[];
-    loading: boolean;
-    error: Error | null;
-    generateConsentURL: (integrationId: string, redirectUrl?: string) => Promise<ConsentURLResponse>;
-    removeIntegration: (integrationId: string) => Promise<void>;
+export declare function useAgentThreadFilesystem(threadId?: string, enabled?: boolean): {
+    filesystem: ProjectTaskWorkspaceListing;
+    filesystemLoading: boolean;
+    filesystemError: any;
+    getFile: (path: string) => Promise<ProjectTaskWorkspaceFileContent & {
+        blob: Blob;
+    }>;
+    listDirectory: (path?: string) => Promise<ProjectTaskWorkspaceListing>;
     refetch: () => Promise<void>;
 };
 
-export declare function useAgentMcpServers(agentName: string | null): UseAgentMcpServersReturnType;
-
-declare type UseAgentMcpServersReturnType = {
-    mcpServers: AgentMcpServer[];
+export declare function useAgentThreadTaskGraphs(threadId?: string, enabled?: boolean): {
+    graphs: ThreadTaskGraphBundle[];
+    latestGraph: ThreadTaskGraphBundle;
+    has_more: boolean;
+    loadingMore: boolean;
     loading: boolean;
-    error: Error | null;
-    connect: (mcpServerId: string) => Promise<McpConnectResponse>;
-    disconnect: (mcpServerId: string) => Promise<void>;
+    error: any;
+    loadMore: () => Promise<void>;
     refetch: () => Promise<void>;
 };
 
-export declare function useAgentSession(ticket?: string | null): UseAgentSessionResult;
-
-declare interface UseAgentSessionResult {
-    hasSession: boolean;
-    sessionLoading: boolean;
-    sessionError: Error | null;
-    sessionId: string | null;
-    contextGroup: string | null;
-    agents: AgentWithIntegrations[];
-    activeAgent: AgentWithIntegrations | null;
-    setActiveAgent: (agent: AgentWithIntegrations) => void;
-    ticketExchanged: boolean;
-    ticketLoading: boolean;
-    refetch: () => Promise<void>;
-}
-
 export declare function useApiAuthAppSession(ticket?: string | null): UseApiAuthAppSessionResult;
 
 declare interface UseApiAuthAppSessionResult {
@@ -1058,9 +1175,9 @@ export declare function useApiAuthKeys(filters?: UseApiAuthKeysFilters): UseApiA
 
 declare interface UseApiAuthKeysReturn {
     keys: ApiKey[];
-    createKey: (input: CreateApiAuthKeyInput) => Promise<ApiKeyWithSecret>;
-    rotateKey: (input: RotateApiAuthKeyInput) => Promise<ApiKeyWithSecret>;
-    revokeKey: (input: RevokeApiAuthKeyInput) => Promise<void>;
+    createKey: (input: CreateApiAuthKeyInput) => Promise<ApiResult<ApiKeyWithSecret>>;
+    rotateKey: (input: RotateApiAuthKeyInput) => Promise<ApiResult<ApiKeyWithSecret>>;
+    revokeKey: (input: RevokeApiAuthKeyInput) => Promise<ApiResult<void>>;
     loading: boolean;
     error: unknown;
     refetch: () => void;
@@ -1076,20 +1193,33 @@ declare type UseClientReturnType = {
 export declare function useCreateWebhookEndpoint(): UseCreateWebhookEndpointReturn;
 
 declare interface UseCreateWebhookEndpointReturn {
-    createEndpoint: (options: CreateEndpointOptions) => Promise<EndpointWithSubscriptions>;
+    createEndpoint: (options: CreateEndpointOptions) => Promise<ApiResult<EndpointWithSubscriptions>>;
     loading: boolean;
     error: unknown;
 }
 
 export declare function useDeployment(): DeploymentContextType;
 
+export declare function useExternalAgentConnections(enabled?: boolean): {
+    connections: ExternalAgentConnection[];
+    loading: boolean;
+    error: any;
+    connect: (provider: string, slug: string, options?: {
+        returnUrl?: string;
+    }) => Promise<ConnectResponse>;
+    disconnect: (provider: string, slug: string) => Promise<{
+        success: boolean;
+    }>;
+    refetch: () => Promise<void>;
+};
+
 export declare function useForgotPassword(): {
     loading: boolean;
-    forgotPassword: (email: string) => Promise<ApiResult<{}, ErrorInterface>>;
+    forgotPassword: (email: string) => Promise<ApiResult<{}>>;
     verifyOtp: (email: string, otp: string) => Promise<ApiResult<{
         token: string;
-    }, ErrorInterface>>;
-    resetPassword: (token: string, password: string) => Promise<ApiResult<Session, ErrorInterface>>;
+    }>>;
+    resetPassword: (token: string, password: string) => Promise<ApiResult<Session>>;
 };
 
 export declare const useInvitation: () => {
@@ -1100,13 +1230,11 @@ export declare const useInvitation: () => {
     reset: () => void;
 };
 
-export declare function useMagicLinkParams(): MagicLinkParams;
-
 export declare function useMagicLinkVerification(): UseMagicLinkVerificationReturnType;
 
-export declare interface UseMagicLinkVerificationReturnType {
+declare interface UseMagicLinkVerificationReturnType {
     loading: boolean;
-    verifyMagicLink: (params: MagicLinkParams) => Promise<ApiResult<{}, ErrorInterface>>;
+    verifyMagicLink: (params: MagicLinkParams) => Promise<ApiResult<{}>>;
     success: boolean | null;
 }
 
@@ -1161,14 +1289,16 @@ export declare function useNotificationStream({ enabled, channels, organizationI
 export declare interface UseNotificationStreamOptions {
     enabled?: boolean;
     channels?: string[];
-    organizationIds?: number[];
-    workspaceIds?: number[];
+    organizationIds?: string[];
+    workspaceIds?: string[];
     onNotification?: (notification: NotificationMessage) => void;
     onError?: (error: string) => void;
     reconnectDelay?: number;
     maxReconnectAttempts?: number;
 }
 
+export declare function useNotificationUnreadCount(params?: NotificationListParams): UseScopeUnreadReturnType;
+
 export declare const useOrganizationList: () => {
     organizations: Organization[] | undefined;
     loading: boolean;
@@ -1236,10 +1366,94 @@ export declare const useOrganizationMemberships: () => {
     refetch: () => Promise<void>;
 };
 
+export declare function useProjectTaskBoardItem(projectId?: string, itemId?: string, enabled?: boolean, options?: ProjectTaskDetailOptions): {
+    item: ProjectTaskBoardItem | null;
+    assignments: ProjectTaskBoardItemAssignment[];
+    assignmentsHasMore: boolean;
+    assignmentsLoadingMore: boolean;
+    loadMoreAssignments: () => Promise<void>;
+    taskWorkspace: ProjectTaskWorkspaceListing;
+    taskWorkspaceLoading: boolean;
+    taskWorkspaceError: any;
+    loading: boolean;
+    error: any;
+    updateItem: (request: UpdateProjectTaskBoardItemRequest, files?: File[]) => Promise<ApiResult<ProjectTaskBoardItem>>;
+    archiveItem: () => Promise<ApiResult<ProjectTaskBoardItem>>;
+    unarchiveItem: () => Promise<ApiResult<ProjectTaskBoardItem>>;
+    cancelItem: () => Promise<ApiResult<ProjectTaskBoardItem>>;
+    submitAnswer: (submission: AnswerSubmission) => Promise<ApiResult<ProjectTaskBoardItem>>;
+    submitApproval: (approvals: ToolApprovalDecision[]) => Promise<boolean>;
+    getTaskWorkspaceFile: (path: string) => Promise<ApiResult<ProjectTaskWorkspaceFileContent>>;
+    downloadTaskWorkspaceFile: (path: string) => Promise<void>;
+    listTaskWorkspaceDirectory: (path?: string) => Promise<ApiResult<ProjectTaskWorkspaceListing>>;
+    refetch: () => Promise<void>;
+    refetchAssignments: () => Promise<void>;
+    refetchTaskWorkspace: () => Promise<void>;
+};
+
+export declare function useProjectTaskBoardItemComments(projectId?: string, itemId?: string, enabled?: boolean): {
+    comments: ProjectTaskBoardItemComment[];
+    loading: boolean;
+    error: any;
+    createComment: (body: string, files?: File[]) => Promise<ApiResult<ProjectTaskBoardItemComment>>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useProjectTasks(projectId?: string, enabled?: boolean, options?: ProjectTaskListOptions): {
+    tasks: ProjectTaskBoardItem[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    loadingMore: boolean;
+    loadMore: () => Promise<void>;
+    createTask: (request: CreateProjectTaskBoardItemRequest, files?: File[]) => Promise<ApiResult<ProjectTaskBoardItem>>;
+    archiveTask: (itemId: string) => Promise<ApiResult<ProjectTaskBoardItem>>;
+    unarchiveTask: (itemId: string) => Promise<ApiResult<ProjectTaskBoardItem>>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useProjectThreadFeed(projectId?: string, options?: {
+    includeArchived?: boolean;
+    archivedOnly?: boolean;
+    enabled?: boolean;
+    query?: string;
+    limit?: number;
+}): {
+    threads: AgentThread[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    loadingMore: boolean;
+    loadMore: () => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useProjectThreads(projectId?: string, options?: {
+    includeArchived?: boolean;
+    enabled?: boolean;
+}): {
+    threads: AgentThread[];
+    loading: boolean;
+    error: any;
+    hasMore: boolean;
+    nextCursor: string;
+    createThread: (request: CreateAgentThreadRequest) => Promise<ApiResult<AgentThread>>;
+    createThreadForProject: (targetProjectId: string, request: CreateAgentThreadRequest) => Promise<ApiResult<AgentThread>>;
+    updateThread: (threadId: string, request: UpdateAgentThreadRequest) => Promise<ApiResult<AgentThread>>;
+    archiveThread: (threadId: string) => Promise<ApiResult<AgentThread>>;
+    unarchiveThread: (threadId: string) => Promise<ApiResult<AgentThread>>;
+    refetch: () => Promise<void>;
+};
+
 export declare const UserButton: default_2.FC<UserButtonProps>;
 
 declare interface UserButtonProps {
     showName?: boolean;
+    onCreateOrg?: () => void;
+    /** Show the org/workspace chip row and side panel. Defaults to true. */
+    showOrgSwitcher?: boolean;
+    /** Viewport width threshold (px) below which the side panel replaces the main dropdown. Defaults to 640. */
+    narrowBreakpoint?: number;
 }
 
 export declare const UserControls: default_2.FC<UserControlsProps>;
@@ -1249,13 +1463,11 @@ declare interface UserControlsProps {
     showNotifications?: boolean;
 }
 
-declare type UsernameSignInParams = {
+declare type UsernameSignInParams = ChallengeParams & {
     username: string;
     password: string;
 };
 
-export declare function useScopeUnread(params?: NotificationListParams): UseScopeUnreadReturnType;
-
 declare type UseScopeUnreadReturnType = {
     loading: true;
     count: number;
@@ -1310,32 +1522,6 @@ declare type UseSignInReturnType = {
     setSignInAttempt: (attempt: SigninAttempt | null) => void;
 };
 
-export declare function useSignInWithStrategy<T extends SignInStrategy>(strategy: T): UseSignInWithStrategyReturnType<T>;
-
-export declare type UseSignInWithStrategyReturnType<T extends SignInStrategy> = {
-    loading: true;
-    signIn: never;
-    signinAttempt: null;
-    discardSignInAttempt: () => void;
-    setSignInAttempt: (attempt: SigninAttempt | null) => void;
-} | {
-    loading: false;
-    signIn: {
-        create: SignInFunction<T>;
-        completeVerification: (verificationCode: string) => Promise<Session>;
-        prepareVerification: (params: VerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
-        completeProfile: (data: ProfileCompletionData) => Promise<Session>;
-        identify: (identifier: string) => Promise<IdentifyResult>;
-        initEnterpriseSso: (connectionId: string, redirectUri?: string) => Promise<{
-            sso_url: string;
-            session: Session;
-        }>;
-    };
-    signinAttempt: SigninAttempt | null;
-    discardSignInAttempt: () => void;
-    setSignInAttempt: (attempt: SigninAttempt | null) => void;
-};
-
 export declare function useSignUp(): UseSignUpReturnType;
 
 export declare type UseSignUpReturnType = {
@@ -1351,10 +1537,20 @@ export declare type UseSignUpReturnType = {
 };
 
 /**
- * Headless hook for handling SSO OAuth callback
+ * Headless hook for handling social OAuth callback
  * Automatically processes URL parameters and handles the callback flow
  */
-export declare function useSSOCallback(): SSOCallbackState;
+export declare function useSocialCallback(): SocialCallbackState;
+
+/**
+ * Inline `--wa-ov-*` override vars for the current deployment's theme_tokens.
+ * Apply to any `.wacht-root` element that lives OUTSIDE the main provider's DOM
+ * subtree — i.e. portalled popovers/dropdowns/dialogs rendered to `document.body`.
+ * Those re-wrap in `.wacht-root` (restoring base tokens) but don't inherit the
+ * overrides, which are set inline on the provider's root; this re-applies them.
+ * React context flows through portals, so this reads the same deployment.
+ */
+export declare function useThemeOverrideVars(): Record<string, string>;
 
 export declare function useUser(): {
     user: {
@@ -1432,7 +1628,7 @@ export declare function useUserSignins(): {
 
 export declare function useWaitlist(): {
     loading: boolean;
-    joinWaitlist: (params: WaitlistParams) => Promise<ApiResult<WaitlistResponse, ErrorInterface>>;
+    joinWaitlist: (params: WaitlistParams) => Promise<ApiResult<WaitlistResponse>>;
 };
 
 export declare function useWebhookAnalytics(options?: UseWebhookAnalyticsOptions): UseWebhookAnalyticsReturn;
@@ -1455,17 +1651,17 @@ declare interface UseWebhookAppSessionResult {
     ticketExchanged: boolean;
     ticketLoading: boolean;
     refetch: () => Promise<void>;
-    createEndpoint: (options: CreateEndpointOptions) => Promise<EndpointWithSubscriptions>;
-    updateEndpoint: (endpointId: string, options: UpdateEndpointOptions) => Promise<EndpointWithSubscriptions>;
-    deleteEndpoint: (endpointId: string) => Promise<DeleteEndpointResponse>;
-    testEndpoint: (endpointId: string, options: TestEndpointOptions) => Promise<TestEndpointResponse>;
-    rotateSecret: () => Promise<WebhookAppInfo>;
-    updateSettings: (options: UpdateWebhookSettingsOptions) => Promise<WebhookSettingsResponse>;
-    replayDelivery: (options: ReplayWebhookDeliveryOptions) => Promise<ReplayWebhookDeliveryResponse>;
-    fetchReplayTaskStatus: (options: ReplayTaskStatusOptions) => Promise<ReplayTaskStatusResponse>;
-    fetchReplayTasks: (options?: ReplayTaskListOptions) => Promise<ReplayTaskListResponse>;
-    cancelReplayTask: (options: CancelReplayTaskOptions) => Promise<CancelReplayTaskResponse>;
-    fetchDeliveryDetail: (deliveryId: string) => Promise<WebhookDeliveryDetail[]>;
+    createEndpoint: (options: CreateEndpointOptions) => Promise<ApiResult<EndpointWithSubscriptions>>;
+    updateEndpoint: (endpointId: string, options: UpdateEndpointOptions) => Promise<ApiResult<EndpointWithSubscriptions>>;
+    deleteEndpoint: (endpointId: string) => Promise<ApiResult<DeleteEndpointResponse>>;
+    testEndpoint: (endpointId: string, options: TestEndpointOptions) => Promise<ApiResult<TestEndpointResponse>>;
+    rotateSecret: () => Promise<ApiResult<WebhookAppInfo>>;
+    updateSettings: (options: UpdateWebhookSettingsOptions) => Promise<ApiResult<WebhookSettingsResponse>>;
+    replayDelivery: (options: ReplayWebhookDeliveryOptions) => Promise<ApiResult<ReplayWebhookDeliveryResponse>>;
+    fetchReplayTaskStatus: (options: ReplayTaskStatusOptions) => Promise<ApiResult<ReplayTaskStatusResponse>>;
+    fetchReplayTasks: (options?: ReplayTaskListOptions) => Promise<ApiResult<ReplayTaskListResponse>>;
+    cancelReplayTask: (options: CancelReplayTaskOptions) => Promise<ApiResult<CancelReplayTaskResponse>>;
+    fetchDeliveryDetail: (deliveryId: string) => Promise<ApiResult<WebhookDeliveryDetail[]>>;
 }
 
 export declare function useWebhookDeliveries(options?: UseWebhookDeliveriesOptions): {
@@ -1511,7 +1707,7 @@ export declare const useWorkspaceList: () => {
     loading: boolean;
     error: any;
     refetch: () => Promise<void>;
-    leaveWorkspace: (id: string, userId: string) => Promise<void>;
+    leaveWorkspace: (id: string) => Promise<void>;
     createWorkspace: (organizationId: string, name: string, image?: File, description?: string) => Promise<{
         workspace: Workspace;
         membership: WorkspaceMembership;
@@ -1553,7 +1749,7 @@ declare type VerificationParams = EmailOTPVerificationParams | PhoneOTPVerificat
 
 export declare interface WaitlistEntry {
     id: string;
-    deployment_id: number;
+    deployment_id: string;
     email_address: string;
     first_name: string;
     last_name: string;