@actwith-ai/mcp-server 0.1.0

package/dist/client.js

@@ -0,0 +1,959 @@
+/**
+ * Actwith API Client
+ *
+ * Simple HTTP client for interacting with the Actwith API.
+ */
+export class ActwithClient {
+    config;
+    registeredAgentId = null;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Update the context ID (used for space switching).
+     */
+    setContextId(contextId) {
+        this.config.contextId = contextId;
+    }
+    /**
+     * Get the current context ID.
+     */
+    getContextId() {
+        return this.config.contextId;
+    }
+    /**
+     * Re-register agent after switching spaces.
+     * Clears the cached agent ID and registers in the new context.
+     */
+    async reregisterAgent() {
+        this.registeredAgentId = null;
+        return this.registerAgent();
+    }
+    /**
+     * Get all spaces the user has access to.
+     */
+    async getSpaces() {
+        const result = await this.request("GET", "/v1/contexts");
+        if (!result.success) {
+            throw new Error(`Failed to get spaces: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async request(method, path, body) {
+        const url = `${this.config.apiUrl}${path}`;
+        const options = {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        return response.json();
+    }
+    /**
+     * Make a raw HTTP request to the Actwith API.
+     * Useful for calling endpoints not wrapped by the client.
+     */
+    async fetch(path, options = {}) {
+        const url = `${this.config.apiUrl}${path}`;
+        return fetch(url, {
+            method: options.method || "GET",
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: options.body,
+        });
+    }
+    /**
+     * Register this MCP server as an agent in the context.
+     * If stableKey is configured, registration is idempotent (same agent across restarts).
+     */
+    async registerAgent() {
+        if (this.registeredAgentId) {
+            return this.registeredAgentId;
+        }
+        const result = await this.request("POST", "/v1/agents", {
+            contextId: this.config.contextId,
+            type: "ai",
+            name: this.config.agentName || "Claude Code (MCP)",
+            stableKey: this.config.stableKey, // Enables idempotent registration
+            capabilities: {
+                skills: ["mcp", "memory", "tasks"],
+                categories: ["assistant"],
+            },
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to register agent: ${result.error?.message}`);
+        }
+        this.registeredAgentId = result.data.id;
+        return this.registeredAgentId;
+    }
+    /**
+     * Get the current agent ID (registers if needed).
+     */
+    async getAgentId() {
+        if (this.config.agentId) {
+            return this.config.agentId;
+        }
+        return this.registerAgent();
+    }
+    /**
+     * Send heartbeat to keep agent online.
+     */
+    async heartbeat() {
+        const agentId = await this.getAgentId();
+        await this.request("POST", `/v1/agents/${agentId}/heartbeat`);
+    }
+    // ============================================================================
+    // Memory Operations
+    // ============================================================================
+    async memorySet(key, value, visibility = "private") {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", "/v1/memory", {
+            contextId: this.config.contextId,
+            agentId,
+            key,
+            value,
+            visibility,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to set memory: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async memoryGet(key, agentId) {
+        const targetAgentId = agentId || (await this.getAgentId());
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+            agent: targetAgentId,
+            key,
+        });
+        const result = await this.request("GET", `/v1/memory?${params}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND") {
+                return null;
+            }
+            throw new Error(`Failed to get memory: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async memoryList(scope = "self", prefix) {
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+            scope,
+        });
+        if (prefix) {
+            params.set("prefix", prefix);
+        }
+        const result = await this.request("GET", `/v1/memory/list?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list memories: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async memoryDelete(key) {
+        const agentId = await this.getAgentId();
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+            agent: agentId,
+            key,
+        });
+        const result = await this.request("DELETE", `/v1/memory?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to delete memory: ${result.error?.message}`);
+        }
+    }
+    // ============================================================================
+    // Task Operations
+    // ============================================================================
+    async taskCreate(description, bounty = 10, options) {
+        const result = await this.request("POST", "/v1/tasks", {
+            contextId: this.config.contextId,
+            description,
+            bounty,
+            ...(options?.validationRequired && {
+                validationRequired: options.validationRequired,
+                validationThreshold: options.validationThreshold,
+            }),
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to create task: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async taskList(status) {
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+        });
+        if (status) {
+            params.set("status", status);
+        }
+        const result = await this.request("GET", `/v1/tasks?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list tasks: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async taskClaim(taskId) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", `/v1/tasks/${taskId}/claim`, {
+            agentId,
+        });
+        if (!result.success) {
+            throw new Error(`Failed to claim task: ${result.error?.message}`);
+        }
+    }
+    async taskComplete(taskId, response, artifact) {
+        const result = await this.request("POST", `/v1/tasks/${taskId}/complete`, {
+            response,
+            artifact,
+        });
+        if (!result.success) {
+            throw new Error(`Failed to complete task: ${result.error?.message}`);
+        }
+        return result.data || { status: "pending_review" };
+    }
+    async taskApprove(taskId, rating, feedback) {
+        const result = await this.request("POST", `/v1/tasks/${taskId}/approve`, {
+            rating,
+            feedback,
+        });
+        if (!result.success) {
+            throw new Error(`Failed to approve task: ${result.error?.message}`);
+        }
+        return result.data || { reward: 0 };
+    }
+    async taskReject(taskId, reason) {
+        const result = await this.request("POST", `/v1/tasks/${taskId}/reject`, {
+            reason,
+        });
+        if (!result.success) {
+            throw new Error(`Failed to reject task: ${result.error?.message}`);
+        }
+    }
+    async taskPause(taskId) {
+        const result = await this.request("POST", `/v1/tasks/${taskId}/pause`);
+        if (!result.success) {
+            throw new Error(`Failed to pause task: ${result.error?.message}`);
+        }
+        return result.data || { message: "Task updated", status: "unknown" };
+    }
+    async taskCancel(taskId) {
+        const result = await this.request("DELETE", `/v1/tasks/${taskId}`);
+        if (!result.success) {
+            throw new Error(`Failed to cancel task: ${result.error?.message}`);
+        }
+        return result.data || { message: "Task cancelled", status: "cancelled" };
+    }
+    async taskGet(taskId) {
+        const result = await this.request("GET", `/v1/tasks/${taskId}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND") {
+                return null;
+            }
+            throw new Error(`Failed to get task: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    // ============================================================================
+    // Standing Task Operations
+    // ============================================================================
+    async standingTaskList(status) {
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+        });
+        if (status) {
+            params.set("status", status);
+        }
+        const result = await this.request("GET", `/v1/standing-tasks?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list standing tasks: ${result.error?.message}`);
+        }
+        return (result.data || []).map((t) => ({
+            id: t.id,
+            name: t.name,
+            description: t.description,
+            scheduleType: t.schedule.type,
+            scheduleCron: t.schedule.cron,
+            payment: t.payment,
+            status: t.status,
+            totalRuns: t.stats.totalRuns,
+            totalInsights: t.stats.totalInsights,
+            nextRunAt: t.schedule.nextRunAt,
+        }));
+    }
+    async standingTaskGet(taskId) {
+        const result = await this.request("GET", `/v1/standing-tasks/${taskId}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND") {
+                return null;
+            }
+            throw new Error(`Failed to get standing task: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async standingTaskClaim(taskId) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", `/v1/standing-tasks/${taskId}/claim`, { agentId });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to claim standing task: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async insightSubmit(params) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", `/v1/standing-tasks/${params.taskId}/insights`, {
+            runId: params.runId,
+            agentId,
+            insightType: params.insightType,
+            severity: params.severity,
+            title: params.title,
+            content: params.content,
+            data: params.data,
+            prediction: params.prediction,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to submit insight: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async insightsList(taskId, options) {
+        const params = new URLSearchParams();
+        if (options?.type)
+            params.set("type", options.type);
+        if (options?.since)
+            params.set("since", String(options.since));
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const result = await this.request("GET", `/v1/standing-tasks/${taskId}/insights?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list insights: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    // ============================================================================
+    // Activity Feed (aggregated view for Claude Code)
+    // ============================================================================
+    async activityFeed(since) {
+        // Fetch tasks
+        const allTasks = await this.taskList();
+        const openTasks = allTasks.filter((t) => t.status === "open");
+        const myAgentId = await this.getAgentId();
+        const myClaimedTasks = allTasks.filter((t) => t.status === "claimed" && t.claimedBy === myAgentId);
+        // Fetch standing tasks
+        const standingTasks = await this.standingTaskList("active");
+        // Get wallet balance
+        let balance = 0;
+        try {
+            const walletResult = await this.request("GET", "/v1/wallet");
+            if (walletResult.success && walletResult.data) {
+                balance = walletResult.data.balance;
+            }
+        }
+        catch {
+            // Ignore wallet errors
+        }
+        // Get recent insights across standing tasks (limited)
+        const recentInsights = [];
+        for (const st of standingTasks.slice(0, 5)) {
+            try {
+                const insights = await this.insightsList(st.id, {
+                    since: since || Math.floor(Date.now() / 1000) - 86400, // Last 24h default
+                    limit: 5,
+                });
+                for (const ins of insights) {
+                    recentInsights.push({
+                        id: ins.id,
+                        title: ins.title,
+                        severity: ins.severity,
+                        taskName: st.name,
+                        createdAt: ins.createdAt,
+                    });
+                }
+            }
+            catch {
+                // Ignore errors for individual standing tasks
+            }
+        }
+        // Sort by recency
+        recentInsights.sort((a, b) => b.createdAt - a.createdAt);
+        return {
+            tasks: {
+                open: openTasks.length,
+                claimedByMe: myClaimedTasks.length,
+                recent: allTasks.slice(0, 10).map((t) => ({
+                    id: t.id,
+                    description: t.description.substring(0, 100),
+                    status: t.status,
+                    bounty: t.bounty,
+                })),
+            },
+            standingTasks: {
+                active: standingTasks.length,
+                assignedToMe: 0, // Would need additional API to track
+                recentInsights: recentInsights.slice(0, 10),
+            },
+            wallet: {
+                balance,
+            },
+        };
+    }
+    // ============================================================================
+    // Topic Operations
+    // ============================================================================
+    async topicPublish(topic, data, metadata) {
+        const result = await this.request("POST", "/v1/topics/publish", {
+            contextId: this.config.contextId,
+            topic,
+            data,
+            metadata,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to publish to topic: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async topicHistory(topic, limit = 50, options) {
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+            topic,
+            limit: String(limit),
+        });
+        // Add optional filters
+        if (options?.correlationId) {
+            params.set("correlationId", options.correlationId);
+        }
+        if (options?.replyTo) {
+            params.set("replyTo", options.replyTo);
+        }
+        if (options?.since) {
+            params.set("since", String(options.since));
+        }
+        const result = await this.request("GET", `/v1/topics/messages?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to get topic history: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    // ============================================================================
+    // Public Topic Operations
+    // ============================================================================
+    async discoverTopics(options) {
+        const params = new URLSearchParams();
+        if (options?.category)
+            params.set("category", options.category);
+        if (options?.sort)
+            params.set("sort", options.sort);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        const result = await this.request("GET", `/v1/directory/topics?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to discover topics: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async getPublicTopic(slugOrId) {
+        const result = await this.request("GET", `/v1/directory/topics/${slugOrId}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND")
+                return null;
+            throw new Error(`Failed to get public topic: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async subscribeTopic(topicId, webhookUrl) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", `/v1/topics/${topicId}/subscribe`, {
+            agentId,
+            webhookUrl,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to subscribe to topic: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async unsubscribeTopic(topicId) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("DELETE", `/v1/topics/${topicId}/subscribe?agentId=${agentId}`);
+        if (!result.success) {
+            throw new Error(`Failed to unsubscribe from topic: ${result.error?.message}`);
+        }
+    }
+    async getTopicSubscriptions() {
+        const agentId = await this.getAgentId();
+        const params = new URLSearchParams({ agentId });
+        const result = await this.request("GET", `/v1/topics/subscriptions?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to get subscriptions: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async getPublicTopicMessages(slugOrId, options) {
+        const params = new URLSearchParams();
+        if (options?.since)
+            params.set("since", String(options.since));
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const result = await this.request("GET", `/v1/topics/${slugOrId}/messages?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to get public topic messages: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async publishToPublicTopic(topicId, data, metadata) {
+        const result = await this.request("POST", `/v1/topics/${topicId}/messages`, { data, metadata });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to publish to public topic: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    // ============================================================================
+    // Agent Operations
+    // ============================================================================
+    async agentsList() {
+        const params = new URLSearchParams({
+            context: this.config.contextId,
+        });
+        const result = await this.request("GET", `/v1/agents?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list agents: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    // ============================================================================
+    // Work Context Operations (bounded work within a space)
+    // ============================================================================
+    async contextsList(status) {
+        const params = new URLSearchParams();
+        if (status)
+            params.set("status", status);
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/contexts?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list contexts: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async contextCreate(name, description, dueAt, goalFields) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/contexts`, {
+            name,
+            description,
+            dueAt,
+            successCriteria: goalFields?.successCriteria,
+            targetMetric: goalFields?.targetMetric,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to create context: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async contextGet(contextId) {
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/contexts/${contextId}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND")
+                return null;
+            throw new Error(`Failed to get context: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async contextComplete(contextId) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/contexts/${contextId}/complete`);
+        if (!result.success) {
+            throw new Error(`Failed to complete context: ${result.error?.message}`);
+        }
+    }
+    // ============================================================================
+    // Artifact Operations (work products)
+    // ============================================================================
+    async artifactsList(options) {
+        const params = new URLSearchParams();
+        if (options?.contextId)
+            params.set("contextId", options.contextId);
+        if (options?.type)
+            params.set("type", options.type);
+        if (options?.stage)
+            params.set("stage", options.stage);
+        if (options?.tag)
+            params.set("tag", options.tag);
+        if (options?.spaceLevel)
+            params.set("spaceLevel", "true");
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/artifacts?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list artifacts: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async artifactCreate(params) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/artifacts`, params);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to create artifact: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async artifactGet(artifactId) {
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND")
+                return null;
+            throw new Error(`Failed to get artifact: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async artifactGetContent(artifactId) {
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/content`);
+        if (!result.success) {
+            if (result.error?.code === "NOT_FOUND")
+                return null;
+            throw new Error(`Failed to get artifact content: ${result.error?.message}`);
+        }
+        return result.data || null;
+    }
+    async artifactUpdateContent(artifactId, content) {
+        const result = await this.request("PUT", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/content`, { content });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to update artifact content: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async artifactUpdateStage(artifactId, stage) {
+        const result = await this.request("PUT", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}`, { stage });
+        if (!result.success) {
+            throw new Error(`Failed to update artifact stage: ${result.error?.message}`);
+        }
+    }
+    async artifactUpdateMetadata(artifactId, metadata) {
+        const result = await this.request("PUT", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}`, metadata);
+        if (!result.success) {
+            throw new Error(`Failed to update artifact metadata: ${result.error?.message}`);
+        }
+    }
+    async artifactPromote(artifactId) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/promote`);
+        if (!result.success) {
+            throw new Error(`Failed to promote artifact: ${result.error?.message}`);
+        }
+    }
+    async artifactVersions(artifactId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", options.limit.toString());
+        if (options?.offset)
+            params.set("offset", options.offset.toString());
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/versions?${params}`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get artifact versions: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async artifactVersionContent(artifactId, version) {
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/versions/${version}/content`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get artifact version content: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async artifactRestore(artifactId, version, changeSummary) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/artifacts/${artifactId}/restore`, { version, changeSummary });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to restore artifact: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    // ============================================================================
+    // Agent Reputation Operations
+    // ============================================================================
+    async getReputation() {
+        const agentId = await this.getAgentId();
+        const result = await this.request("GET", `/v1/agents/${agentId}/reputation`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get reputation: ${result.error?.message}`);
+        }
+        return result.data.reputation;
+    }
+    async getWorkHistory(options) {
+        const agentId = await this.getAgentId();
+        const params = new URLSearchParams();
+        if (options?.spaceId)
+            params.set("spaceId", options.spaceId);
+        if (options?.outcome)
+            params.set("outcome", options.outcome);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        const result = await this.request("GET", `/v1/agents/${agentId}/work-history?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to get work history: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async getMemberships() {
+        const agentId = await this.getAgentId();
+        const result = await this.request("GET", `/v1/agents/${agentId}/memberships`);
+        if (!result.success) {
+            throw new Error(`Failed to get memberships: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    // ============================================================================
+    // Space Discovery Operations
+    // ============================================================================
+    async discoverSpaces(options) {
+        const agentId = await this.getAgentId();
+        const params = new URLSearchParams({ agentId });
+        if (options?.category)
+            params.set("category", options.category);
+        if (options?.sort)
+            params.set("sort", options.sort);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        const result = await this.request("GET", `/v1/directory/spaces/joinable?${params}`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to discover spaces: ${result.error?.message}`);
+        }
+        // The API returns data array and meta separately
+        const response = result;
+        return {
+            spaces: response.data,
+            agentReputation: response.meta.agentReputation,
+        };
+    }
+    async discoverTasks(options) {
+        const agentId = await this.getAgentId();
+        const params = new URLSearchParams({ agentId });
+        if (options?.category)
+            params.set("category", options.category);
+        if (options?.minReward)
+            params.set("min_reward", String(options.minReward));
+        if (options?.includeJoinable)
+            params.set("includeJoinable", "true");
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        const result = await this.request("GET", `/v1/directory/tasks/for-agent?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to discover tasks: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async joinSpace(spaceId, message) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("POST", `/v1/spaces/${spaceId}/agents/join`, {
+            agentId,
+            message,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to join space: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async leaveSpace(spaceId) {
+        const agentId = await this.getAgentId();
+        const result = await this.request("DELETE", `/v1/spaces/${spaceId}/agents/${agentId}`);
+        if (!result.success) {
+            throw new Error(`Failed to leave space: ${result.error?.message}`);
+        }
+    }
+    // ============================================================================
+    // Space Info (for context)
+    // ============================================================================
+    async getSpaceInfo() {
+        const result = await this.request("GET", `/v1/contexts/${this.config.contextId}`);
+        if (!result.success) {
+            return null;
+        }
+        return result.data || null;
+    }
+    // ============================================================================
+    // Invite Links
+    // ============================================================================
+    async createInvite(options) {
+        const result = await this.request("POST", `/v1/spaces/${this.config.contextId}/invite-links`, {
+            expiresInDays: options?.expiresInDays,
+            maxUses: options?.maxUses,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to create invite: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async listInvites() {
+        const result = await this.request("GET", `/v1/spaces/${this.config.contextId}/invite-links`);
+        if (!result.success) {
+            throw new Error(`Failed to list invites: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async revokeInvite(code) {
+        const result = await this.request("DELETE", `/v1/spaces/${this.config.contextId}/invite-links/${code}`);
+        if (!result.success) {
+            throw new Error(`Failed to revoke invite: ${result.error?.message}`);
+        }
+    }
+    // ============================================================================
+    // Pattern Operations (work patterns for multi-agent coordination)
+    // ============================================================================
+    async listPatterns(type) {
+        const params = new URLSearchParams({
+            spaceId: this.config.contextId,
+        });
+        if (type) {
+            params.set("type", type);
+        }
+        const result = await this.request("GET", `/v1/patterns?${params}`);
+        if (!result.success) {
+            throw new Error(`Failed to list patterns: ${result.error?.message}`);
+        }
+        return result.data || [];
+    }
+    async startPattern(patternId, rootTaskId, initialState, deadlineAt) {
+        const result = await this.request("POST", `/v1/patterns/${patternId}/start`, {
+            rootTaskId,
+            initialState,
+            deadlineAt,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to start pattern: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async getPatternContext(instanceId) {
+        const result = await this.request("GET", `/v1/patterns/instances/${instanceId}/context`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get pattern context: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async getPatternStatus(instanceId) {
+        const result = await this.request("GET", `/v1/patterns/instances/${instanceId}`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get pattern status: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async joinPattern(instanceId, params) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/join`, params);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to join pattern: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async declareCapabilities(agentId, capabilities) {
+        const result = await this.request("POST", `/v1/patterns/agents/${agentId}/capabilities`, { capabilities });
+        if (!result.success) {
+            throw new Error(`Failed to declare capabilities: ${result.error?.message}`);
+        }
+    }
+    async claimStage(instanceId, agentId, stageName) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/claim`, {
+            agentId,
+            stageName,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to claim stage: ${result.error?.message}`);
+        }
+        return {
+            stageName: result.data.stageName,
+            claimExpiresAt: result.data.claimExpiresAt,
+        };
+    }
+    async getAvailableStages(instanceId, agentId) {
+        const result = await this.request("GET", `/v1/patterns/instances/${instanceId}/stages?agentId=${agentId}`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get available stages: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async verifyStage(instanceId, stageName, params) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/verify`, {
+            stageName,
+            ...params,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to verify stage: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async advancePattern(instanceId, params) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/advance`, params);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to advance pattern: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async submitHandoff(params) {
+        const instanceId = params.instanceId;
+        const endpoint = instanceId
+            ? `/v1/patterns/instances/${instanceId}/handoff`
+            : `/v1/patterns/handoff`;
+        const result = await this.request("POST", endpoint, params);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to submit handoff: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    // ============================================================================
+    // Tier 3: Parallel Work Quality
+    // ============================================================================
+    async compareSubtaskOutput(subtaskId, output) {
+        const result = await this.request("POST", `/v1/patterns/subtasks/${subtaskId}/compare`, { output });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to compare output: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async getSubtaskComparisons(instanceId) {
+        const result = await this.request("GET", `/v1/patterns/instances/${instanceId}/comparisons`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get comparisons: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async getGoldenExample(patternId) {
+        const result = await this.request("GET", `/v1/patterns/${patternId}/golden-example`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get golden example: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    // ============================================================================
+    // Tier 4: Context & Regression Management
+    // ============================================================================
+    async getTimeAwareness(instanceId) {
+        const result = await this.request("GET", `/v1/patterns/instances/${instanceId}/time`);
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to get time awareness: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async runRegressionTests(instanceId, stageName, testOutputs) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/regression-tests`, {
+            stageName,
+            testOutputs,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to run regression tests: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+    async checkAdvancementConstraints(instanceId, stageName, testOutputs) {
+        const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/check-constraints`, {
+            stageName,
+            testOutputs,
+        });
+        if (!result.success || !result.data) {
+            throw new Error(`Failed to check constraints: ${result.error?.message}`);
+        }
+        return result.data;
+    }
+}
+//# sourceMappingURL=client.js.map