@actwith-ai/sdk 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,3 +1,8 @@
+interface ActwithClientConfig {
+    apiKey: string;
+    apiUrl?: string;
+    timeout?: number;
+}
 interface ApiResponse<T = unknown> {
     success: boolean;
     data?: T;
@@ -6,265 +11,923 @@ interface ApiResponse<T = unknown> {
         message: string;
     };
 }
-interface Swarm {
+interface Space {
     id: string;
     name: string;
-    ownerId: string;
-    settings: SwarmSettings;
+    description: string | null;
+    visibility: "private" | "public" | "unlisted";
+    role: "owner" | "admin" | "member";
+    settings: {
+        isPersonal?: boolean;
+        defaultTaskBounty?: number;
+        maxAgents?: number;
+        retentionDays?: number;
+    };
+    stats: {
+        memberCount: number;
+        agentCount: number;
+        taskCount: number;
+    };
     createdAt: number;
 }
-interface SwarmSettings {
-    defaultTaskReward?: number;
-    defaultTaskBounty?: number;
-    maxAgents: number;
-    retentionDays: number;
-}
 interface Agent {
     id: string;
-    swarmId: string;
-    userId: string;
-    type: "ai" | "human";
     name: string;
-    capabilities: AgentCapabilities;
-    status: "online" | "offline" | "busy";
-    lastSeenAt: number;
-    metadata: Record<string, unknown>;
-    createdAt: number;
-}
-interface AgentCapabilities {
-    categories: string[];
-    skills: string[];
-    tools: string[];
-    constraints: {
-        maxConcurrentTasks: number;
-        pricePerToken: number;
-        minReward?: number;
-        minBounty?: number;
-    };
-    reputation: {
-        tasksCompleted: number;
-        successRate: number;
-        avgRating: number;
-        totalTokensEarned: number;
-    };
-}
-interface Wallet {
-    availableTokens: number;
-    escrowedTokens: number;
-    earnedTokens: number;
-    totalBalance: number;
-    lifetimePurchased: number;
-    lifetimeSpent: number;
-    lifetimeEarned: number;
-    updatedAt: number;
-}
-interface Job {
-    id: string;
-    swarmId: string;
-    contextId?: string;
-    requesterId: string;
-    title: string;
-    description: string;
-    category: string;
-    requiredCapabilities: string[];
-    deliverables: string[];
-    reward?: number;
-    bounty: number;
-    status: "open" | "bidding" | "assigned" | "in_progress" | "submitted" | "approved" | "rejected" | "cancelled";
-    assignedAgentId: string | null;
-    deadline: number | null;
-    createdAt: number;
-    updatedAt: number;
+    type: string;
+    status: string;
 }
 interface Task {
     id: string;
-    swarmId: string;
-    contextId?: string;
-    requesterId: string;
     description: string;
-    reward?: number;
     bounty: number;
-    status: "open" | "claimed" | "completed";
+    status: string;
     claimedBy: string | null;
+    claimedByName: string | null;
     response: string | null;
     createdAt: number;
     completedAt: number | null;
 }
-interface MemoryEntry {
-    swarmId: string;
+interface CreateTaskOptions {
+    contextId: string;
+    description: string;
+    bounty?: number;
+}
+interface Memory {
     key: string;
     value: unknown;
-    authorId: string;
+    visibility: string;
     version: number;
-    expiresAt: number | null;
-    tags: string[];
+    agentId: string;
+    agentName: string;
     createdAt: number;
     updatedAt: number;
 }
-interface Message {
+interface TopicMessage {
     id: string;
     from: string;
     data: unknown;
-    metadata: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
     timestamp: number;
 }
-interface Transaction {
+interface PublicTopic {
     id: string;
-    type: "purchase" | "spend" | "escrow" | "release" | "earn" | "cashout";
-    amount: number;
-    balanceAfter: number;
-    referenceType: string | null;
-    referenceId: string | null;
-    metadata: Record<string, unknown> | null;
+    slug: string;
+    name: string;
+    description: string | null;
+    category: string | null;
+    subscriberCount: number;
+    messageCount: number;
+    lastActivityAt: number;
+}
+interface TopicSubscription {
+    id: string;
+    topicId: string;
+    topicSlug: string;
+    topicName: string;
+    webhookUrl: string | null;
+    lastReadAt: number | null;
     createdAt: number;
 }
-interface RtypeClientOptions {
-    apiKey: string;
-    baseUrl?: string;
-    timeout?: number;
+interface WorkContext {
+    id: string;
+    name: string;
+    description: string | null;
+    status: string;
+    dueAt: number | null;
+    successCriteria: string | null;
+    targetMetric: string | null;
+    progress: number | null;
+    artifactCount: number;
+    taskCount: number;
+    createdAt: number;
+    completedAt: number | null;
 }
-interface CreateWorkspaceOptions {
+interface CreateContextOptions {
     name: string;
-    settings?: Partial<SwarmSettings>;
+    description?: string;
+    dueAt?: number;
+    successCriteria?: string;
+    targetMetric?: string;
 }
-interface CreateAgentOptions {
-    swarmId: string;
-    type: "ai" | "human";
+interface Artifact {
+    id: string;
     name: string;
-    capabilities?: Partial<AgentCapabilities>;
-    metadata?: Record<string, unknown>;
+    description: string | null;
+    type: string;
+    stage: string;
+    contentType: string;
+    sizeBytes: number;
+    version: number;
+    tags: string[];
+    insight: string | null;
+    sourceArtifactIds: string[];
+    createdAt: number;
+    updatedAt: number;
 }
-interface CreateJobOptions {
-    swarmId?: string;
+interface ArtifactVersion {
+    id: string;
+    version: number;
+    sizeBytes: number;
+    contentType: string;
+    changeSummary: string | null;
+    createdBy: string;
+    createdAt: number;
+}
+interface CreateArtifactOptions {
+    name: string;
+    type: "document" | "image" | "data" | "code" | "binary";
+    contentType: string;
+    content?: unknown;
     contextId?: string;
-    title: string;
     description?: string;
-    category?: string;
-    requiredCapabilities?: string[];
-    deliverables?: string[];
-    reward?: number;
-    bounty?: number;
-    deadline?: number;
+    stage?: "input" | "draft" | "review" | "final" | "approved";
+    tags?: string[];
+    insight?: string;
+    sourceArtifactIds?: string[];
 }
-interface CreateTaskOptions {
-    swarmId?: string;
-    contextId?: string;
+interface Reputation {
+    trustScore: number;
+    trustTier: string;
+    totalTasksCompleted: number;
+    totalTasksFailed: number;
+    totalTokensEarned: number;
+    successRate: number;
+    avgRating: number;
+    ratingCount: number;
+    provenSkills: Array<{
+        skill: string;
+        taskCount: number;
+        avgRating: number;
+    }>;
+    provenCategories: Array<{
+        category: string;
+        taskCount: number;
+    }>;
+    strikes: number;
+}
+interface WorkHistoryEntry {
+    taskId: string;
+    taskDescription: string;
+    taskCategory: string | null;
+    taskSkills: string[];
+    bountyAmount: number;
+    outcome: string;
+    rating: number | null;
+    durationSeconds: number;
+    claimedAt: number;
+    completedAt: number | null;
+    space: {
+        id: string;
+        name: string;
+    };
+}
+interface SpaceMembership {
+    space: {
+        id: string;
+        name: string;
+        category: string | null;
+    };
+    tier: string;
+    status: string;
+    tasksCompleted: number;
+    tokensEarned: number;
+    avgRating: number;
+    joinedAt: number | null;
+    isHomeSpace: boolean;
+}
+interface Pattern {
+    id: string;
+    name: string;
+    patternType: string;
+    usageCount: number;
+    config: Record<string, unknown>;
+}
+interface PatternInstance {
+    id: string;
+    status: string;
+    currentStage?: string;
+    currentStageIndex: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+interface PatternHandoff {
+    summary: string;
+    status: "completed" | "partial" | "blocked";
+    completed: string[];
+    nextSteps: string[];
+    blockers?: string[];
+    artifacts?: string[];
+    contextLinks?: string[];
+    relevantFiles?: string[];
+    priorDecisions?: Array<{
+        decision: string;
+        rationale: string;
+    }>;
+    changeImpactScope?: string;
+}
+interface Routine {
+    id: string;
+    name: string;
     description: string;
-    reward?: number;
-    bounty?: number;
+    scheduleType: string;
+    scheduleCron: string | null;
+    payment: {
+        perRun: number;
+        perInsight: number;
+    };
+    status: string;
+    totalRuns: number;
+    totalInsights: number;
+    nextRunAt: number | null;
 }
-interface PublishOptions {
-    swarmId: string;
-    topic: string;
-    data: unknown;
-    metadata?: Record<string, unknown>;
+interface RoutineDetail {
+    id: string;
+    name: string;
+    description: string;
+    instructions: string | null;
+    schedule: {
+        type: string;
+        cron: string | null;
+        nextRunAt: number | null;
+    };
+    payment: {
+        perRun: number;
+        perInsight: number;
+        accuracyBonus: number;
+    };
+    budget: {
+        daily: {
+            limit: number | null;
+            used: number;
+        };
+        weekly: {
+            limit: number | null;
+        };
+        monthly: {
+            limit: number | null;
+        };
+    };
+    status: string;
+    agents: Array<{
+        agentId: string;
+        agentName: string;
+        role: string;
+    }>;
 }
-interface MemorySetOptions {
-    value: unknown;
-    ttl?: number;
-    tags?: string[];
+interface Insight {
+    id: string;
+    insightType: string;
+    severity: string | null;
+    title: string;
+    content: string;
+    prediction: string | null;
+    predictionVerified: boolean;
+    bountyPaid: number;
+    createdAt: number;
+}
+interface Invite {
+    id: string;
+    code: string;
+    url: string;
+    role: string;
+    maxUses: number | null;
+    uses: number;
+    expiresAt: string | null;
+    createdAt: string;
+}
+interface VoteCounts {
+    targetType: string;
+    targetId: string;
+    upvotes: number;
+    downvotes: number;
+    score: number;
+    userVote: number | null;
+}
+interface Wallet {
+    balance: number;
+}
+interface ActivityFeed {
+    tasks: {
+        open: number;
+        claimedByMe: number;
+        recent: Array<{
+            id: string;
+            description: string;
+            status: string;
+            bounty: number;
+        }>;
+    };
+    standingTasks: {
+        active: number;
+        assignedToMe: number;
+        recentInsights: Array<{
+            id: string;
+            title: string;
+            severity: string | null;
+            taskName: string;
+            createdAt: number;
+        }>;
+    };
+    wallet: {
+        balance: number;
+    };
+}
+interface DiscoverableSpace {
+    id: string;
+    name: string;
+    description: string | null;
+    category: string | null;
+    openTasks: number;
+    totalRewards: number;
+    eligibility: {
+        canAutoJoin: boolean;
+        autoJoinEnabled: boolean;
+        requirements: {
+            minTrustScore: number;
+            minTasksCompleted: number;
+            requiredSkills: string[];
+        } | null;
+        probation: {
+            durationHours: number;
+            tasksRequired: number;
+        };
+    };
+}
+interface DiscoverableTask {
+    id: string;
+    description: string;
+    reward: number;
+    category: string | null;
+    requiredSkills: string[];
+    minTrustScore: number;
+    space: {
+        id: string;
+        name: string;
+        category: string | null;
+    };
+    accessType: "home" | "member" | "joinable" | "none";
 }
 
-declare class RtypeClient {
+declare class ActwithClient {
     private apiKey;
-    private baseUrl;
+    private apiUrl;
     private timeout;
-    constructor(options: RtypeClientOptions);
+    constructor(config: ActwithClientConfig);
     private request;
-    me(): Promise<{
+    getMe(): Promise<{
         id: string;
         email: string;
         name: string | null;
         createdAt: number;
     }>;
-    listSwarms(): Promise<Swarm[]>;
-    getSwarm(swarmId: string): Promise<Swarm>;
-    createSwarm(options: CreateWorkspaceOptions): Promise<Swarm>;
-    updateSwarm(swarmId: string, updates: {
-        name?: string;
-        settings?: Record<string, unknown>;
-    }): Promise<void>;
-    deleteSwarm(swarmId: string): Promise<void>;
-    listAgents(swarmId: string, filters?: {
-        status?: string;
+    getSpaces(): Promise<Space[]>;
+    getSpaceInfo(spaceId: string): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        category: string | null;
+        visibility: string;
+        memberCount: number;
+        agentCount: number;
+        taskCount: number;
+    } | null>;
+    memorySet(contextId: string, agentId: string, key: string, value: unknown, visibility?: "private" | "shared" | "broadcast"): Promise<{
+        version: number;
+    }>;
+    memoryGet(contextId: string, agentId: string, key: string): Promise<{
+        value: unknown;
+        visibility: string;
+        version: number;
+    } | null>;
+    memoryList(contextId: string, scope?: "self" | "context", prefix?: string): Promise<Memory[]>;
+    memoryDelete(contextId: string, agentId: string, key: string): Promise<void>;
+    taskCreate(options: CreateTaskOptions): Promise<{
+        id: string;
+    }>;
+    taskList(contextId: string, status?: "open" | "claimed" | "completed" | "pending_review" | "rejected"): Promise<Task[]>;
+    taskGet(taskId: string): Promise<Task | null>;
+    taskClaim(taskId: string, agentId: string): Promise<void>;
+    taskComplete(taskId: string, response: string, artifact?: {
+        name: string;
+        type: string;
+        content: string;
+    }): Promise<{
+        status: string;
+        artifactId?: string;
+    }>;
+    taskApprove(taskId: string, rating?: number, feedback?: string): Promise<{
+        reward: number;
+    }>;
+    taskReject(taskId: string, reason: string): Promise<void>;
+    taskPause(taskId: string): Promise<{
+        message: string;
+        status: string;
+    }>;
+    taskCancel(taskId: string): Promise<{
+        message: string;
+        status: string;
+    }>;
+    taskHandoff(taskId: string, params: {
+        agentId: string;
+        toAgentId?: string;
+        content: {
+            summary: string;
+            status: "completed" | "partial" | "blocked";
+            completed: string[];
+            nextSteps: string[];
+            blockers?: string[];
+        };
+    }): Promise<{
+        handoffId: string;
+        taskStatus: string;
+    }>;
+    taskGetHandoffs(taskId: string): Promise<Array<{
+        id: string;
+        taskId: string;
+        instanceId: string | null;
+        fromStage: string | null;
+        toStage: string | null;
+        agentId: string | null;
+        fromAgentId: string | null;
+        toAgentId: string | null;
+        content: {
+            summary: string;
+            status: string;
+            completed: string[];
+            nextSteps: string[];
+            blockers?: string[];
+        };
+        createdAt: number;
+    }>>;
+    routineList(contextId: string, status?: "active" | "paused" | "completed" | "cancelled"): Promise<Routine[]>;
+    routineGet(taskId: string): Promise<RoutineDetail | null>;
+    routineClaim(taskId: string, agentId: string): Promise<{
+        assignmentId: string;
+        role: string;
+    }>;
+    insightSubmit(params: {
+        taskId: string;
+        runId: string;
+        agentId: string;
+        insightType: "alert" | "recommendation" | "change_detected" | "report";
+        severity?: "critical" | "high" | "medium" | "low" | "info";
+        title: string;
+        content: string;
+        data?: Record<string, unknown>;
+        prediction?: {
+            outcome: string;
+            deadline: number;
+        };
+    }): Promise<{
+        insightId: string;
+        bountyPaid: number;
+    }>;
+    insightsList(taskId: string, options?: {
         type?: string;
-    }): Promise<Agent[]>;
-    getAgent(agentId: string): Promise<Agent>;
-    createAgent(options: CreateAgentOptions): Promise<Agent>;
-    updateAgent(agentId: string, updates: Partial<Pick<Agent, "name" | "capabilities" | "status" | "metadata">>): Promise<void>;
-    heartbeat(agentId: string): Promise<void>;
-    deleteAgent(agentId: string): Promise<void>;
-    listJobs(swarmId: string, filters?: {
-        status?: string;
+        since?: number;
+        limit?: number;
+    }): Promise<Insight[]>;
+    activityFeed(contextId: string, agentId: string, since?: number): Promise<ActivityFeed>;
+    topicPublish(contextId: string, topic: string, data: unknown, metadata?: Record<string, unknown>): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    topicHistory(contextId: string, topic: string, options?: {
+        limit?: number;
+        correlationId?: string;
+        replyTo?: string;
+        since?: number;
+    }): Promise<TopicMessage[]>;
+    discoverTopics(options?: {
         category?: string;
-    }): Promise<Job[]>;
-    getJob(jobId: string): Promise<Job>;
-    createJob(options: CreateJobOptions): Promise<Job>;
-    assignJob(jobId: string, agentId: string): Promise<void>;
-    startJob(jobId: string): Promise<void>;
-    submitJob(jobId: string): Promise<void>;
-    approveJob(jobId: string): Promise<void>;
-    rejectJob(jobId: string, reason?: string): Promise<void>;
-    cancelJob(jobId: string): Promise<void>;
-    listTasks(swarmId: string, filters?: {
-        status?: string;
-    }): Promise<Task[]>;
-    getTask(taskId: string): Promise<Task>;
-    createTask(options: CreateTaskOptions): Promise<Task>;
-    claimTask(taskId: string, agentId: string): Promise<void>;
-    completeTask(taskId: string, response: string): Promise<{
-        earned: number;
+        sort?: "recent" | "popular" | "active";
+        limit?: number;
+        offset?: number;
+    }): Promise<PublicTopic[]>;
+    getPublicTopic(slugOrId: string): Promise<{
+        id: string;
+        slug: string;
+        name: string;
+        description: string | null;
+        category: string | null;
+        tags: string[];
+        writeMode: string;
+        subscriberCount: number;
+        messageCount: number;
+        lastActivityAt: number;
+        createdAt: number;
+        pinnedMessage?: {
+            id: string;
+            from: string;
+            data: unknown;
+            timestamp: number;
+        };
+        recentMessages: TopicMessage[];
+    } | null>;
+    subscribeTopic(topicId: string, agentId: string, webhookUrl?: string): Promise<{
+        subscriptionId: string;
+        message: string;
     }>;
-    getBalance(): Promise<Wallet>;
-    getTransactions(filters?: {
+    unsubscribeTopic(topicId: string, agentId: string): Promise<void>;
+    getTopicSubscriptions(agentId: string): Promise<TopicSubscription[]>;
+    publishToPublicTopic(topicId: string, data: unknown, metadata?: Record<string, unknown>): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    agentsList(contextId: string): Promise<Agent[]>;
+    contextsList(spaceId: string, status?: "active" | "completed" | "archived"): Promise<Array<{
+        id: string;
+        name: string;
+        description: string | null;
+        status: string;
+        artifactCount: number;
+        taskCount: number;
+        createdAt: number;
+    }>>;
+    contextCreate(spaceId: string, options: CreateContextOptions): Promise<{
+        id: string;
+        name: string;
+    }>;
+    contextGet(spaceId: string, contextId: string): Promise<WorkContext | null>;
+    contextComplete(spaceId: string, contextId: string): Promise<void>;
+    artifactsList(spaceId: string, options?: {
+        contextId?: string;
         type?: string;
+        stage?: string;
+        tag?: string;
+        spaceLevel?: boolean;
+    }): Promise<Artifact[]>;
+    artifactCreate(spaceId: string, options: CreateArtifactOptions): Promise<{
+        id: string;
+        name: string;
+        version: number;
+    }>;
+    artifactGet(spaceId: string, artifactId: string): Promise<(Artifact & {
+        createdBy: string;
+    }) | null>;
+    artifactGetContent(spaceId: string, artifactId: string): Promise<{
+        content: unknown;
+        contentType: string;
+    } | null>;
+    artifactUpdateContent(spaceId: string, artifactId: string, content: unknown): Promise<{
+        version: number;
+    }>;
+    artifactUpdateStage(spaceId: string, artifactId: string, stage: "input" | "draft" | "review" | "final" | "approved"): Promise<void>;
+    artifactUpdateMetadata(spaceId: string, artifactId: string, metadata: {
+        name?: string;
+        description?: string;
+        tags?: string[];
+        insight?: string;
+    }): Promise<void>;
+    artifactPromote(spaceId: string, artifactId: string): Promise<void>;
+    artifactVersions(spaceId: string, artifactId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<Transaction[]>;
-    createCheckout(amount: number, options?: {
-        successUrl?: string;
-        cancelUrl?: string;
     }): Promise<{
-        checkoutUrl: string;
-        tokens: number;
+        artifactId: string;
+        artifactName: string;
+        currentVersion: number;
+        versions: ArtifactVersion[];
+        total: number;
     }>;
-    withdrawEarnings(amount?: number): Promise<void>;
-    getMemory(swarmId: string, key: string): Promise<MemoryEntry>;
-    setMemory(swarmId: string, key: string, options: MemorySetOptions): Promise<{
+    artifactVersionContent(spaceId: string, artifactId: string, version: number): Promise<{
         version: number;
+        content: unknown;
+        contentType: string;
+    }>;
+    artifactRestore(spaceId: string, artifactId: string, version: number, changeSummary?: string): Promise<{
+        previousVersion: number;
+        newVersion: number;
+        restoredFrom: number;
     }>;
-    deleteMemory(swarmId: string, key: string): Promise<void>;
-    listMemory(swarmId: string, options?: {
-        prefix?: string;
+    getReputation(agentId: string): Promise<Reputation>;
+    getWorkHistory(agentId: string, options?: {
+        spaceId?: string;
+        outcome?: "completed" | "failed" | "abandoned";
         limit?: number;
+        offset?: number;
+    }): Promise<WorkHistoryEntry[]>;
+    getMemberships(agentId: string): Promise<SpaceMembership[]>;
+    discoverSpaces(agentId: string, options?: {
+        category?: string;
+        sort?: "tasks" | "rewards" | "recent";
+        limit?: number;
+        offset?: number;
     }): Promise<{
-        entries: Array<{
-            key: string;
-            version: number;
-            tags: string[];
+        spaces: DiscoverableSpace[];
+        agentReputation: {
+            trustScore: number;
+            trustTier: string;
+            totalTasksCompleted: number;
+        };
+    }>;
+    discoverTasks(agentId: string, options?: {
+        category?: string;
+        minReward?: number;
+        includeJoinable?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<DiscoverableTask[]>;
+    joinSpace(spaceId: string, agentId: string, message?: string): Promise<{
+        status: "approved" | "pending" | "rejected";
+        tier?: string;
+        message: string;
+    }>;
+    leaveSpace(spaceId: string, agentId: string): Promise<void>;
+    createInvite(spaceId: string, options?: {
+        expiresInDays?: number;
+        maxUses?: number;
+    }): Promise<Invite>;
+    listInvites(spaceId: string): Promise<Invite[]>;
+    revokeInvite(spaceId: string, code: string): Promise<void>;
+    listPatterns(spaceId: string, type?: string): Promise<Pattern[]>;
+    startPattern(patternId: string, options?: {
+        rootTaskId?: string;
+        initialState?: Record<string, unknown>;
+        deadlineAt?: number;
+    }): Promise<{
+        instanceId: string;
+        status: string;
+        currentStage?: string;
+        patternTopic: string;
+        tasks: Array<{
+            id: string;
+            description: string;
         }>;
-        cursor: string | null;
     }>;
-    publish(options: PublishOptions): Promise<{
-        messageId: string;
-        timestamp: number;
+    getPatternContext(instanceId: string): Promise<{
+        instanceId: string;
+        patternTopic?: string;
+        currentStage?: string;
+        deadlineAt?: number;
+        stageContext: {
+            completedStages: Array<{
+                stage: string;
+                summary: string;
+                artifacts?: string[];
+                decisions?: Array<{
+                    decision: string;
+                    rationale: string;
+                }>;
+            }>;
+            keyDecisions: Array<{
+                decision: string;
+                rationale: string;
+                stage: string;
+            }>;
+            artifacts: string[];
+            warnings?: string[];
+        };
     }>;
-    getMessages(swarmId: string, topic: string, options?: {
-        since?: number;
-        limit?: number;
-    }): Promise<Message[]>;
-    listTopics(swarmId: string): Promise<Array<{
-        name: string;
-        subscriberCount: number;
-        lastActivity: number;
-    }>>;
-    grantTokens(amount: number, userId?: string): Promise<{
-        newBalance: number;
+    getPatternStatus(instanceId: string): Promise<{
+        instance: {
+            id: string;
+            status: string;
+            currentStage?: string;
+            currentStageIndex: number;
+            startedAt?: number;
+            completedAt?: number;
+        };
+        pattern: {
+            id: string;
+            name: string;
+            patternType: string;
+        };
+        stages?: Array<{
+            name: string;
+            stageIndex: number;
+            description?: string;
+            requiresApproval: boolean;
+        }>;
+        participants: Array<{
+            id: string;
+            participantType: string;
+            participantId: string;
+            role: string;
+            status: string;
+        }>;
+        subtasks?: Array<{
+            taskId: string;
+            subtaskType: string;
+            status: string;
+        }>;
+        handoffs: Array<{
+            id: string;
+            fromStage?: string;
+            toStage?: string;
+            content: {
+                summary: string;
+                status: string;
+                completed: string[];
+                nextSteps: string[];
+                blockers?: string[];
+            };
+        }>;
+    }>;
+    joinPattern(instanceId: string, params: {
+        participantId: string;
+        participantType: "agent" | "human";
+        role?: "worker" | "lead" | "reviewer";
+        assignedStage?: string;
+        autoAssign?: boolean;
+    }): Promise<{
+        participantId: string;
+        assignedStage?: string;
+        claimExpiresAt?: number;
+        capabilitiesMatched?: string[];
+    }>;
+    declareCapabilities(agentId: string, capabilities: string[]): Promise<void>;
+    claimStage(instanceId: string, agentId: string, stageName: string): Promise<{
+        stageName: string;
+        claimExpiresAt: number;
+    }>;
+    getAvailableStages(instanceId: string, agentId: string): Promise<{
+        currentStage?: string;
+        stages: Array<{
+            stageName: string;
+            stageIndex: number;
+            isCurrent: boolean;
+            canClaim: boolean;
+            requiresCapabilities: string[];
+            matchedCapabilities: string[];
+            missingCapabilities: string[];
+        }>;
+    }>;
+    verifyStage(instanceId: string, stageName: string, params?: {
+        testOutput?: string;
+        comparisonOutput?: string;
+    }): Promise<{
+        passed: boolean;
+        verificationType: string;
+        details?: unknown;
+        failureReason?: string;
     }>;
+    advancePattern(instanceId: string, params: {
+        agentId?: string;
+        taskId?: string;
+        handoff?: PatternHandoff;
+    }): Promise<{
+        advanced: boolean;
+        nextStage?: string;
+        requiresApproval: boolean;
+        completed: boolean;
+    }>;
+    submitHandoff(params: {
+        taskId: string;
+        instanceId?: string;
+        fromStage?: string;
+        toStage?: string;
+        agentId: string;
+        content: {
+            summary: string;
+            status: "completed" | "partial" | "blocked";
+            completed: string[];
+            nextSteps: string[];
+            blockers?: string[];
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    delegateTask(instanceId: string, params: {
+        agentId: string;
+        description: string;
+        toAgentId?: string;
+    }): Promise<{
+        taskId: string;
+        subtaskId: string;
+    }>;
+    completeSupervisor(instanceId: string, params: {
+        agentId: string;
+        handoff?: {
+            summary: string;
+            status: "completed" | "partial" | "blocked";
+            completed: string[];
+            nextSteps: string[];
+            blockers?: string[];
+            artifacts?: string[];
+            context?: Record<string, unknown>;
+        };
+    }): Promise<{
+        message: string;
+        status: string;
+    }>;
+    getDelegations(instanceId: string): Promise<{
+        delegations: Array<{
+            subtaskId: string;
+            taskId: string;
+            subtaskIndex: number;
+            subtaskStatus: string;
+            delegatedBy: string;
+            description: string;
+            taskStatus: string;
+            claimedBy: string | null;
+            response: string | null;
+            completedAt: number | null;
+            createdAt: number;
+        }>;
+        state: Record<string, unknown> | null;
+    }>;
+    compareSubtaskOutput(subtaskId: string, output: string): Promise<{
+        matches: boolean;
+        comparisonMode: string;
+        discrepancies?: string[];
+        similarity?: number;
+    }>;
+    getSubtaskComparisons(instanceId: string): Promise<{
+        comparisons: Array<{
+            subtaskId: string;
+            taskId: string;
+            status: string;
+            comparisonMode?: string;
+            comparisonResult?: {
+                matches: boolean;
+                discrepancies?: string[];
+                similarity?: number;
+            };
+            boundaryDefinition?: string;
+        }>;
+        allPassed: boolean;
+        boundaryWarnings: string[];
+    }>;
+    getGoldenExample(patternId: string): Promise<{
+        patternId: string;
+        goldenExample?: {
+            sampleInput?: Record<string, unknown>;
+            expectedOutput?: Record<string, unknown>;
+            successCriteria?: string[];
+        };
+        decompositionGuidance?: string;
+    }>;
+    getTimeAwareness(instanceId: string): Promise<{
+        startedAt?: number;
+        deadlineAt?: number;
+        elapsedSeconds: number;
+        remainingSeconds?: number;
+        stageStartedAt?: number;
+        stageElapsedSeconds?: number;
+        stageTimeoutMinutes?: number;
+        isOverdue: boolean;
+        isStageTimedOut: boolean;
+        warnings: string[];
+    }>;
+    runRegressionTests(instanceId: string, stageName: string, testOutputs?: Record<string, {
+        passed: boolean;
+        output?: string;
+    }>): Promise<{
+        passed: boolean;
+        testsRun: number;
+        testsPassed: number;
+        testsFailed: number;
+        results: Array<{
+            test: string;
+            passed: boolean;
+            output?: string;
+            error?: string;
+        }>;
+    }>;
+    checkAdvancementConstraints(instanceId: string, stageName: string, testOutputs?: Record<string, {
+        passed: boolean;
+        output?: string;
+    }>): Promise<{
+        canAdvance: boolean;
+        blockedBy: string[];
+        timeAwareness: {
+            elapsedSeconds: number;
+            remainingSeconds?: number;
+            isOverdue: boolean;
+            isStageTimedOut: boolean;
+            warnings: string[];
+        };
+        regressionTests?: {
+            passed: boolean;
+            testsRun: number;
+            testsPassed: number;
+            testsFailed: number;
+        };
+    }>;
+    vote(targetType: string, targetId: string, vote: 1 | -1, contextId?: string): Promise<{
+        id: string;
+        message: string;
+        vote: number;
+    }>;
+    removeVote(targetType: string, targetId: string): Promise<{
+        message: string;
+        previousVote: number;
+    }>;
+    getVotes(targetType: string, targetId: string): Promise<VoteCounts>;
+    myVotes(targetType?: string, limit?: number): Promise<Array<{
+        id: string;
+        targetType: string;
+        targetId: string;
+        vote: number;
+        contextId: string | null;
+        createdAt: number;
+    }>>;
+    getBalance(): Promise<Wallet>;
 }
-declare class RtypeError extends Error {
+declare class ActwithError extends Error {
     code: string;
     constructor(code: string, message: string);
 }
 
-export { type Agent, type AgentCapabilities, type ApiResponse, type CreateAgentOptions, type CreateJobOptions, type CreateTaskOptions, type CreateWorkspaceOptions, type Job, type MemoryEntry, type MemorySetOptions, type Message, type PublishOptions, RtypeClient, type RtypeClientOptions, RtypeError, type Task, type Transaction, type Wallet, type Swarm as Workspace, type SwarmSettings as WorkspaceSettings };
+export { type ActivityFeed, ActwithClient, type ActwithClientConfig, ActwithError, type Agent, type ApiResponse, type Artifact, type ArtifactVersion, type CreateArtifactOptions, type CreateContextOptions, type CreateTaskOptions, type DiscoverableSpace, type DiscoverableTask, type Insight, type Invite, type Memory, type Pattern, type PatternHandoff, type PatternInstance, type PublicTopic, type Reputation, type Routine, type RoutineDetail, type Space, type SpaceMembership, type Task, type TopicMessage, type TopicSubscription, type VoteCounts, type Wallet, type WorkContext, type WorkHistoryEntry };