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

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,17 +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 { 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';
@@ -41,8 +43,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';
@@ -57,6 +57,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';
@@ -80,9 +85,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';
@@ -90,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';
@@ -135,7 +146,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)
@@ -331,7 +370,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;
@@ -631,6 +670,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;
@@ -880,8 +930,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 +970,113 @@ 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<ActorMcpServerConnectResponse>;
+    disconnect: (mcpServerId: string) => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useActorProjects(options?: {
+    includeArchived?: boolean;
+    enabled?: boolean;
+}): {
+    projects: ActorProject[];
+    loading: boolean;
+    error: any;
+    createProject: (request: CreateActorProjectRequest) => Promise<ActorProject>;
+    updateProject: (projectId: string, request: UpdateActorProjectRequest) => Promise<ActorProject>;
+    archiveProject: (projectId: string) => Promise<ActorProject>;
+    unarchiveProject: (projectId: string) => Promise<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 useActors(options?: {
+    includeArchived?: boolean;
+    enabled?: boolean;
+}): {
+    actors: Actor[];
+    loading: boolean;
+    error: any;
+    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<AgentThread>;
+    archiveThread: () => Promise<AgentThread>;
+    unarchiveThread: () => Promise<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>;
@@ -943,73 +1084,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 {
@@ -1236,6 +1349,69 @@ export declare const useOrganizationMemberships: () => {
     refetch: () => Promise<void>;
 };
 
+export declare function useProjectTaskBoardItem(itemId?: string, enabled?: boolean, options?: ProjectTaskDetailOptions): {
+    item: ProjectTaskBoardItem | null;
+    events: ProjectTaskBoardItemEvent[];
+    assignments: ProjectTaskBoardItemAssignment[];
+    taskWorkspace: ProjectTaskWorkspaceListing;
+    taskWorkspaceLoading: boolean;
+    taskWorkspaceError: any;
+    loading: boolean;
+    error: any;
+    updateItem: (request: UpdateProjectTaskBoardItemRequest, files?: File[]) => Promise<ProjectTaskBoardItem>;
+    archiveItem: () => Promise<ProjectTaskBoardItem>;
+    unarchiveItem: () => Promise<ProjectTaskBoardItem>;
+    getTaskWorkspaceFile: (path: string) => Promise<ProjectTaskWorkspaceFileContent>;
+    listTaskWorkspaceDirectory: (path?: string) => Promise<ProjectTaskWorkspaceListing>;
+    appendJournal: (request: AppendProjectTaskBoardItemJournalRequest, files?: File[]) => Promise<ProjectTaskBoardItemEvent>;
+    refetch: () => 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<ProjectTaskBoardItem>;
+    archiveTask: (itemId: string) => Promise<ProjectTaskBoardItem>;
+    unarchiveTask: (itemId: string) => Promise<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;
+    createThread: (request: CreateAgentThreadRequest) => Promise<AgentThread>;
+    createThreadForProject: (targetProjectId: string, request: CreateAgentThreadRequest) => Promise<AgentThread>;
+    updateThread: (threadId: string, request: UpdateAgentThreadRequest) => Promise<AgentThread>;
+    archiveThread: (threadId: string) => Promise<AgentThread>;
+    unarchiveThread: (threadId: string) => Promise<AgentThread>;
+    refetch: () => Promise<void>;
+};
+
 export declare const UserButton: default_2.FC<UserButtonProps>;
 
 declare interface UserButtonProps {