@wacht/jsx 1.0.0-beta.4 → 1.0.0-beta.40

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';
@@ -13,12 +15,14 @@ import { ButtonHTMLAttributes } from 'react';
 import { CancelReplayTaskOptions } from '@wacht/types';
 import { CancelReplayTaskResponse } from '@wacht/types';
 import { Client } from '@wacht/types';
-import { ConsentURLResponse } from '@wacht/types';
+import { ComponentPropsWithoutRef } from 'react';
 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';
@@ -28,7 +32,7 @@ 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 { ExternalAgentConnection } from '@wacht/types';
 import { FastOmit } from 'styled-components';
 import { FC } from 'react';
 import { FileData } from '@wacht/types';
@@ -40,8 +44,6 @@ 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';
@@ -54,8 +56,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';
@@ -76,12 +84,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';
@@ -89,7 +102,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';
@@ -134,7 +146,24 @@ 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;
+};
+
+export declare function AuthFormImage({ placement, }: {
+    placement?: "center" | "left" | "right";
+}): JSX.Element | null;
 
 /**
  * Check if user can manage the organization (admin or manage permissions)
@@ -155,6 +184,10 @@ declare const CONNECTION_STATES: {
     readonly ERROR: "error";
 };
 
+declare interface ConnectResponse {
+    redirect_url: string;
+}
+
 export declare const CreateOrganizationForm: React.FC<CreateOrganizationFormProps>;
 
 declare interface CreateOrganizationFormProps {
@@ -191,6 +224,10 @@ declare interface CreateWorkspaceFormProps {
     onCreateOrganization?: () => void;
 }
 
+export declare function DefaultStylesProvider({ children, style, ...props }: DefaultStylesProviderProps): JSX.Element;
+
+declare type DefaultStylesProviderProps = ComponentPropsWithoutRef<"div">;
+
 export declare interface DeploymentContextType {
     loading: boolean;
     deployment: Deployment | null;
@@ -214,13 +251,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> & {
@@ -274,11 +311,13 @@ 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: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 
-export declare const DropdownItem: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
+export declare const DropdownItem: IStyledComponentBase<"web", FastOmit<FastOmit<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "$destructive"> & {
+$destructive?: boolean;
+}, never> & Partial<Pick<FastOmit<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "$destructive"> & {
 $destructive?: boolean;
-}>> & string;
+}, never>>> & string;
 
 export declare const DropdownItems: ({ children, style, }: {
     children: ReactNode;
@@ -310,9 +349,9 @@ declare type EmailSignInParams = {
     password: string;
 };
 
-export declare const Form: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, never>> & string;
+export declare const Form: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, never> & Partial<Pick<DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, never>>> & string;
 
-export declare const FormGroup: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const FormGroup: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 
 /**
  * Unified execution status mapping between frontend and backend
@@ -326,7 +365,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;
@@ -348,7 +387,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;
@@ -360,7 +399,7 @@ declare type InitSSOResponseType = {
     session: Session;
 };
 
-export declare const Input: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
+export declare const Input: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never> & Partial<Pick<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>>> & string;
 
 export declare const isExternalUrl: (url: string) => boolean;
 
@@ -376,9 +415,9 @@ 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: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never> & Partial<Pick<DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>>> & string;
 
-export declare interface MagicLinkParams {
+declare interface MagicLinkParams {
     token?: string;
     attempt?: string;
     redirectUri?: string;
@@ -538,7 +577,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;
@@ -626,6 +665,17 @@ declare interface ProfileUpdateData {
     remove_profile_picture?: boolean;
 }
 
+declare type ProjectTaskDetailOptions = {
+    includeArchived?: boolean;
+};
+
+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;
@@ -638,7 +688,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;
@@ -671,17 +721,6 @@ 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 SignInMagicLink = ({ email, }: MagicLinkSignInParams) => Promise<ApiResult<Session>>;
@@ -699,8 +738,6 @@ 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;
@@ -709,7 +746,7 @@ declare type SignupEmailOTPVerificationParams = {
 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>;
@@ -875,8 +912,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: () => {
@@ -915,22 +952,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, 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>;
@@ -938,73 +1063,36 @@ 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;
     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 {
@@ -1053,9 +1141,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;
@@ -1071,20 +1159,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: () => {
@@ -1095,13 +1196,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;
 }
 
@@ -1164,6 +1263,8 @@ export declare interface UseNotificationStreamOptions {
     maxReconnectAttempts?: number;
 }
 
+export declare function useNotificationUnreadCount(params?: NotificationListParams): UseScopeUnreadReturnType;
+
 export declare const useOrganizationList: () => {
     organizations: Organization[] | undefined;
     loading: boolean;
@@ -1231,10 +1332,93 @@ 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>>;
+    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,8 +1433,6 @@ declare type UsernameSignInParams = {
     password: string;
 };
 
-export declare function useScopeUnread(params?: NotificationListParams): UseScopeUnreadReturnType;
-
 declare type UseScopeUnreadReturnType = {
     loading: true;
     count: number;
@@ -1305,32 +1487,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 = {
@@ -1427,7 +1583,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;
@@ -1450,17 +1606,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): {
@@ -1506,7 +1662,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;