@wacht/jsx 1.0.0-beta.2 → 1.0.0-beta.23

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-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 { ActorProject } from '@wacht/types';
+import { Agent } from '@wacht/types';
+import { AgentThread } from '@wacht/types';
 import { ApiAuditAnalyticsResponse } from '@wacht/types';
 import { ApiAuditLogsResponse } from '@wacht/types';
 import { ApiAuditTimeseriesResponse } from '@wacht/types';
@@ -9,16 +9,19 @@ import { ApiAuthAppInfo } from '@wacht/types';
 import { ApiKey } from '@wacht/types';
 import { ApiKeyWithSecret } from '@wacht/types';
 import { ApiResult } from '@wacht/types';
+import { AppendProjectTaskBoardItemJournalRequest } from '@wacht/types';
 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 +31,6 @@ 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 { FC } from 'react';
 import { FileData } from '@wacht/types';
@@ -40,8 +42,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';
@@ -56,6 +56,11 @@ import { OrganizationRole } from '@wacht/types';
 import { OrganizationUpdate } from '@wacht/types';
 import { ProfileCompletionData } from '@wacht/types';
 import { ProfileCompletionProps } from '@wacht/types';
+import { ProjectTaskBoardItem } from '@wacht/types';
+import { ProjectTaskBoardItemAssignment } from '@wacht/types';
+import { ProjectTaskBoardItemEvent } 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';
@@ -79,9 +84,16 @@ import { SocialConnection } from '@wacht/types';
 import { Substitute } from 'styled-components/dist/types';
 import { TestEndpointOptions } from '@wacht/types';
 import { TestEndpointResponse } from '@wacht/types';
+import { ThreadEvent } 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 +101,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 +145,35 @@ declare interface AcceptInviteProps {
     onError?: (error: string) => void;
 }
 
-export declare function AuthFormImage(): JSX.Element | null;
+declare interface ActorMcpServerConnectResponse {
+    auth_url: string;
+}
+
+export declare interface ActorMcpServerSummary {
+    id: string;
+    name: string;
+    endpoint: string;
+    auth_type: string;
+    requires_user_connection: boolean;
+    connection_status: "ready" | "connected" | "not_connected" | "expired";
+    connected_at?: string;
+    expires_at?: 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)
@@ -191,6 +230,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;
@@ -326,7 +369,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 +391,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;
@@ -378,7 +421,7 @@ export declare function isWorkspaceAdmin(membership: WithWsRoles): boolean;
 
 export declare const Label: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>> & string;
 
-export declare interface MagicLinkParams {
+declare interface MagicLinkParams {
     token?: string;
     attempt?: string;
     redirectUri?: string;
@@ -474,7 +517,7 @@ export declare function NotificationBell({ className, showBadge, scope, onAction
 declare interface NotificationBellProps {
     className?: string;
     showBadge?: boolean;
-    scope?: "all" | "current" | "user";
+    scope?: NotificationListParams["scope"];
     onAction?: (payload: any) => void;
 }
 
@@ -502,7 +545,7 @@ export declare interface NotificationMessage {
 export declare const NotificationPanel: ForwardRefExoticComponent<NotificationPanelProps & RefAttributes<HTMLDivElement>>;
 
 declare interface NotificationPanelProps {
-    scope?: "all" | "current" | "user";
+    scope?: NotificationListParams["scope"];
     onAction?: (payload: any) => void;
     fullWidth?: boolean;
     maxHeight?: string;
@@ -626,6 +669,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;
@@ -671,17 +725,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 +742,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 +750,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 +916,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 +956,105 @@ 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>>;
+    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, platformAdapter, }: UseAgentThreadConversationProps): {
+    threadState: AgentThread | null;
     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;
+    activeApprovalRequestId: string | null;
     hasMoreMessages: boolean;
     isLoadingMore: boolean;
+    messagesLoading: boolean;
+    messagesError: Error | null;
+    refreshMessages: () => Promise<void>;
     sendMessage: (message: string, files?: File[]) => Promise<void>;
-    submitUserInput: (input: string) => Promise<void>;
+    submitApprovalResponse: (requestMessageId: string, approvals: ToolApprovalDecision[]) => Promise<boolean>;
     clearMessages: () => void;
     loadMoreMessages: () => Promise<void>;
     cancelExecution: () => Promise<void>;
@@ -938,73 +1062,45 @@ 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;
     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[];
+export declare function useAgentThreadEvents(threadId?: string, options?: AgentThreadHookOptions): {
+    events: ThreadEvent[];
     loading: boolean;
-    error: Error | null;
+    error: any;
     hasMore: boolean;
-    createContext: (request: CreateContextRequest) => Promise<AgentContext>;
-    deleteContext: (id: string) => Promise<void>;
-    updateContext: (id: string, updates: {
-        title?: string;
-    }) => Promise<void>;
+    loadingMore: boolean;
+    loadMore: () => 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 +1149,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,7 +1167,7 @@ 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;
 }
@@ -1080,11 +1176,11 @@ export declare function useDeployment(): DeploymentContextType;
 
 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 +1191,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 +1258,8 @@ export declare interface UseNotificationStreamOptions {
     maxReconnectAttempts?: number;
 }
 
+export declare function useNotificationUnreadCount(params?: NotificationListParams): UseScopeUnreadReturnType;
+
 export declare const useOrganizationList: () => {
     organizations: Organization[] | undefined;
     loading: boolean;
@@ -1231,6 +1327,79 @@ export declare const useOrganizationMemberships: () => {
     refetch: () => Promise<void>;
 };
 
+export declare function useProjectTaskBoardItem(projectId?: string, itemId?: string, enabled?: boolean, options?: ProjectTaskDetailOptions): {
+    item: ProjectTaskBoardItem | null;
+    events: ProjectTaskBoardItemEvent[];
+    assignments: ProjectTaskBoardItemAssignment[];
+    eventsHasMore: boolean;
+    eventsLoadingMore: boolean;
+    loadMoreEvents: () => Promise<void>;
+    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>>;
+    getTaskWorkspaceFile: (path: string) => Promise<ApiResult<ProjectTaskWorkspaceFileContent>>;
+    listTaskWorkspaceDirectory: (path?: string) => Promise<ApiResult<ProjectTaskWorkspaceListing>>;
+    appendJournal: (request: AppendProjectTaskBoardItemJournalRequest, files?: File[]) => Promise<ApiResult<ProjectTaskBoardItemEvent>>;
+    refetch: () => Promise<void>;
+    refetchEvents: () => Promise<void>;
+    refetchAssignments: () => Promise<void>;
+    refetchTaskWorkspace: () => 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 {
@@ -1249,8 +1418,6 @@ declare type UsernameSignInParams = {
     password: string;
 };
 
-export declare function useScopeUnread(params?: NotificationListParams): UseScopeUnreadReturnType;
-
 declare type UseScopeUnreadReturnType = {
     loading: true;
     count: number;
@@ -1305,32 +1472,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 +1568,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 +1591,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): {