@actwith-ai/mcp-server 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,866 @@
+/**
+ * Actwith API Client
+ *
+ * Simple HTTP client for interacting with the Actwith API.
+ */
+export interface ActwithConfig {
+    apiUrl: string;
+    apiKey: string;
+    contextId: string;
+    agentId?: string;
+    agentName?: string;
+    stableKey?: string;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface Space {
+    id: string;
+    name: string;
+    description: string | null;
+    visibility: "private" | "public" | "unlisted";
+    role: "owner" | "admin" | "member";
+    settings: {
+        isPersonal?: boolean;
+        defaultTaskBounty?: number;
+        maxAgents?: number;
+        retentionDays?: number;
+    };
+    createdAt: number;
+    stats: {
+        memberCount: number;
+        agentCount: number;
+        taskCount: number;
+    };
+}
+export declare class ActwithClient {
+    private config;
+    private registeredAgentId;
+    constructor(config: ActwithConfig);
+    /**
+     * Update the context ID (used for space switching).
+     */
+    setContextId(contextId: string): void;
+    /**
+     * Get the current context ID.
+     */
+    getContextId(): string;
+    /**
+     * Re-register agent after switching spaces.
+     * Clears the cached agent ID and registers in the new context.
+     */
+    reregisterAgent(): Promise<string>;
+    /**
+     * Get all spaces the user has access to.
+     */
+    getSpaces(): Promise<Space[]>;
+    private request;
+    /**
+     * Make a raw HTTP request to the Actwith API.
+     * Useful for calling endpoints not wrapped by the client.
+     */
+    fetch(path: string, options?: {
+        method?: string;
+        body?: string;
+    }): Promise<Response>;
+    /**
+     * Register this MCP server as an agent in the context.
+     * If stableKey is configured, registration is idempotent (same agent across restarts).
+     */
+    registerAgent(): Promise<string>;
+    /**
+     * Get the current agent ID (registers if needed).
+     */
+    getAgentId(): Promise<string>;
+    /**
+     * Send heartbeat to keep agent online.
+     */
+    heartbeat(): Promise<void>;
+    memorySet(key: string, value: unknown, visibility?: "private" | "shared" | "broadcast"): Promise<{
+        version: number;
+    }>;
+    memoryGet(key: string, agentId?: string): Promise<{
+        value: unknown;
+        visibility: string;
+        version: number;
+    } | null>;
+    memoryList(scope?: "self" | "context", prefix?: string): Promise<Array<{
+        key: string;
+        agentId: string;
+        agentName: string;
+        visibility: string;
+        version: number;
+        createdAt: number;
+        updatedAt: number;
+    }>>;
+    memoryDelete(key: string): Promise<void>;
+    taskCreate(description: string, bounty?: number, options?: {
+        validationRequired?: boolean;
+        validationThreshold?: number;
+    }): Promise<{
+        id: string;
+    }>;
+    taskList(status?: "open" | "claimed" | "completed"): Promise<Array<{
+        id: string;
+        description: string;
+        bounty: number;
+        status: string;
+        claimedBy: string | null;
+        response: string | null;
+    }>>;
+    taskClaim(taskId: 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;
+    }>;
+    taskGet(taskId: string): Promise<{
+        id: string;
+        description: string;
+        bounty: number;
+        status: string;
+        claimedBy: string | null;
+        claimedByName: string | null;
+        response: string | null;
+        createdAt: number;
+        completedAt: number | null;
+    } | null>;
+    standingTaskList(status?: "active" | "paused" | "completed" | "cancelled"): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        scheduleType: string;
+        scheduleCron: string | null;
+        payment: {
+            perRun: number;
+            perInsight: number;
+        };
+        status: string;
+        totalRuns: number;
+        totalInsights: number;
+        nextRunAt: number | null;
+    }>>;
+    standingTaskGet(taskId: string): Promise<{
+        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;
+        }>;
+    } | null>;
+    standingTaskClaim(taskId: string): Promise<{
+        assignmentId: string;
+        role: string;
+    }>;
+    insightSubmit(params: {
+        taskId: string;
+        runId: 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;
+        since?: number;
+        limit?: number;
+    }): Promise<Array<{
+        id: string;
+        insightType: string;
+        severity: string | null;
+        title: string;
+        content: string;
+        prediction: string | null;
+        predictionVerified: boolean;
+        bountyPaid: number;
+        createdAt: number;
+    }>>;
+    activityFeed(since?: number): Promise<{
+        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;
+        };
+    }>;
+    topicPublish(topic: string, data: unknown, metadata?: Record<string, unknown>): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    topicHistory(topic: string, limit?: number, options?: {
+        correlationId?: string;
+        replyTo?: string;
+        since?: number;
+    }): Promise<Array<{
+        id: string;
+        from: string;
+        data: unknown;
+        metadata?: Record<string, unknown>;
+        timestamp: number;
+    }>>;
+    discoverTopics(options?: {
+        category?: string;
+        sort?: "recent" | "popular" | "active";
+        limit?: number;
+        offset?: number;
+    }): Promise<Array<{
+        id: string;
+        slug: string;
+        name: string;
+        description: string | null;
+        category: string | null;
+        subscriberCount: number;
+        messageCount: number;
+        lastActivityAt: number;
+    }>>;
+    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: Array<{
+            id: string;
+            from: string;
+            data: unknown;
+            metadata?: Record<string, unknown>;
+            timestamp: number;
+        }>;
+    } | null>;
+    subscribeTopic(topicId: string, webhookUrl?: string): Promise<{
+        subscriptionId: string;
+        message: string;
+    }>;
+    unsubscribeTopic(topicId: string): Promise<void>;
+    getTopicSubscriptions(): Promise<Array<{
+        id: string;
+        topicId: string;
+        topicSlug: string;
+        topicName: string;
+        webhookUrl: string | null;
+        lastReadAt: number | null;
+        createdAt: number;
+    }>>;
+    getPublicTopicMessages(slugOrId: string, options?: {
+        since?: number;
+        limit?: number;
+    }): Promise<Array<{
+        id: string;
+        from: string;
+        data: unknown;
+        metadata?: Record<string, unknown>;
+        timestamp: number;
+    }>>;
+    publishToPublicTopic(topicId: string, data: unknown, metadata?: Record<string, unknown>): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    agentsList(): Promise<Array<{
+        id: string;
+        name: string;
+        type: string;
+        status: string;
+    }>>;
+    contextsList(status?: "active" | "completed" | "archived"): Promise<Array<{
+        id: string;
+        name: string;
+        description: string | null;
+        status: string;
+        artifactCount: number;
+        taskCount: number;
+        createdAt: number;
+    }>>;
+    contextCreate(name: string, description?: string, dueAt?: number, goalFields?: {
+        successCriteria?: string;
+        targetMetric?: string;
+    }): Promise<{
+        id: string;
+        name: string;
+    }>;
+    contextGet(contextId: string): Promise<{
+        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;
+    } | null>;
+    contextComplete(contextId: string): Promise<void>;
+    artifactsList(options?: {
+        contextId?: string;
+        type?: string;
+        stage?: string;
+        tag?: string;
+        spaceLevel?: boolean;
+    }): Promise<Array<{
+        id: string;
+        name: string;
+        description: string | null;
+        type: string;
+        stage: string;
+        contentType: string;
+        sizeBytes: number;
+        version: number;
+        tags: string[];
+        insight: string | null;
+        sourceArtifactIds: string[];
+        createdAt: number;
+        updatedAt: number;
+    }>>;
+    artifactCreate(params: {
+        name: string;
+        type: "document" | "image" | "data" | "code" | "binary";
+        contentType: string;
+        content?: unknown;
+        contextId?: string;
+        description?: string;
+        stage?: "input" | "draft" | "review" | "final" | "approved";
+        tags?: string[];
+        insight?: string;
+        sourceArtifactIds?: string[];
+    }): Promise<{
+        id: string;
+        name: string;
+        version: number;
+    }>;
+    artifactGet(artifactId: string): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        type: string;
+        stage: string;
+        contentType: string;
+        sizeBytes: number;
+        version: number;
+        createdBy: string;
+        tags: string[];
+        insight: string | null;
+        sourceArtifactIds: string[];
+        createdAt: number;
+        updatedAt: number;
+    } | null>;
+    artifactGetContent(artifactId: string): Promise<{
+        content: unknown;
+        contentType: string;
+    } | null>;
+    artifactUpdateContent(artifactId: string, content: unknown): Promise<{
+        version: number;
+    }>;
+    artifactUpdateStage(artifactId: string, stage: "input" | "draft" | "review" | "final" | "approved"): Promise<void>;
+    artifactUpdateMetadata(artifactId: string, metadata: {
+        name?: string;
+        description?: string;
+        tags?: string[];
+        insight?: string;
+    }): Promise<void>;
+    artifactPromote(artifactId: string): Promise<void>;
+    artifactVersions(artifactId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        artifactId: string;
+        artifactName: string;
+        currentVersion: number;
+        versions: Array<{
+            id: string;
+            version: number;
+            sizeBytes: number;
+            contentType: string;
+            changeSummary: string | null;
+            createdBy: string;
+            createdAt: number;
+        }>;
+        total: number;
+    }>;
+    artifactVersionContent(artifactId: string, version: number): Promise<{
+        version: number;
+        content: unknown;
+        contentType: string;
+    }>;
+    artifactRestore(artifactId: string, version: number, changeSummary?: string): Promise<{
+        previousVersion: number;
+        newVersion: number;
+        restoredFrom: number;
+    }>;
+    getReputation(): Promise<{
+        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;
+    }>;
+    getWorkHistory(options?: {
+        spaceId?: string;
+        outcome?: "completed" | "failed" | "abandoned";
+        limit?: number;
+        offset?: number;
+    }): Promise<Array<{
+        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;
+        };
+    }>>;
+    getMemberships(): Promise<Array<{
+        space: {
+            id: string;
+            name: string;
+            category: string | null;
+        };
+        tier: string;
+        status: string;
+        tasksCompleted: number;
+        tokensEarned: number;
+        avgRating: number;
+        joinedAt: number | null;
+        isHomeSpace: boolean;
+    }>>;
+    discoverSpaces(options?: {
+        category?: string;
+        sort?: "tasks" | "rewards" | "recent";
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        spaces: Array<{
+            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;
+                };
+            };
+        }>;
+        agentReputation: {
+            trustScore: number;
+            trustTier: string;
+            totalTasksCompleted: number;
+        };
+    }>;
+    discoverTasks(options?: {
+        category?: string;
+        minReward?: number;
+        includeJoinable?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<Array<{
+        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";
+    }>>;
+    joinSpace(spaceId: string, message?: string): Promise<{
+        status: "approved" | "pending" | "rejected";
+        tier?: string;
+        message: string;
+    }>;
+    leaveSpace(spaceId: string): Promise<void>;
+    getSpaceInfo(): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        category: string | null;
+        visibility: string;
+        memberCount: number;
+        agentCount: number;
+        taskCount: number;
+    } | null>;
+    createInvite(options?: {
+        expiresInDays?: number;
+        maxUses?: number;
+    }): Promise<{
+        id: string;
+        code: string;
+        url: string;
+        spaceName: string;
+        role: string;
+        maxUses: number | null;
+        expiresAt: string | null;
+        expiresInDays: number | null;
+    }>;
+    listInvites(): Promise<Array<{
+        id: string;
+        code: string;
+        url: string;
+        role: string;
+        maxUses: number | null;
+        uses: number;
+        expiresAt: string | null;
+        createdAt: string;
+    }>>;
+    revokeInvite(code: string): Promise<void>;
+    listPatterns(type?: string): Promise<Array<{
+        id: string;
+        name: string;
+        patternType: string;
+        usageCount: number;
+        config: Record<string, unknown>;
+    }>>;
+    startPattern(patternId: string, rootTaskId?: string, initialState?: Record<string, unknown>, deadlineAt?: number): Promise<{
+        instanceId: string;
+        status: string;
+        currentStage?: string;
+        patternTopic: string;
+        tasks: Array<{
+            id: string;
+            description: string;
+        }>;
+    }>;
+    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[];
+        };
+    }>;
+    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?: {
+            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;
+        };
+    }): 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;
+    }>;
+    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;
+        };
+    }>;
+}
+//# sourceMappingURL=client.d.ts.map