@actwith-ai/sdk 0.1.0 → 0.2.1

package/dist/index.js

@@ -20,23 +20,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  RtypeClient: () => RtypeClient,
-  RtypeError: () => RtypeError
+  ActwithClient: () => ActwithClient,
+  ActwithError: () => ActwithError
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var RtypeClient = class {
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl ?? "https://swarm-api.scott-277.workers.dev";
-    this.timeout = options.timeout ?? 3e4;
+var DEFAULT_API_URL = "https://actwith-api.scott-277.workers.dev";
+var DEFAULT_TIMEOUT = 3e4;
+var ActwithClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
   }
   async request(method, path, body) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
-      const response = await fetch(`${this.baseUrl}${path}`, {
+      const response = await fetch(`${this.apiUrl}${path}`, {
         method,
         headers: {
           Authorization: `Bearer ${this.apiKey}`,
@@ -47,7 +49,7 @@ var RtypeClient = class {
       });
       const data = await response.json();
       if (!data.success) {
-        throw new RtypeError(
+        throw new ActwithError(
           data.error?.code ?? "UNKNOWN_ERROR",
           data.error?.message ?? "Unknown error"
         );
@@ -57,165 +59,685 @@ var RtypeClient = class {
       clearTimeout(timeoutId);
     }
   }
-  // ============ Auth ============
-  async me() {
+  // ============================================================================
+  // Auth
+  // ============================================================================
+  async getMe() {
     return this.request("GET", "/v1/auth/me");
   }
-  // ============ Swarms ============
-  async listSwarms() {
-    return this.request("GET", "/v1/swarms");
+  // ============================================================================
+  // Spaces
+  // ============================================================================
+  async getSpaces() {
+    return this.request("GET", "/v1/contexts");
   }
-  async getSwarm(swarmId) {
-    return this.request("GET", `/v1/swarms/${swarmId}`);
+  async getSpaceInfo(spaceId) {
+    try {
+      return await this.request("GET", `/v1/contexts/${spaceId}`);
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async createSwarm(options) {
-    return this.request("POST", "/v1/swarms", options);
+  // ============================================================================
+  // Memory
+  // ============================================================================
+  async memorySet(contextId, agentId, key, value, visibility = "private") {
+    return this.request("POST", "/v1/memory", {
+      contextId,
+      agentId,
+      key,
+      value,
+      visibility
+    });
+  }
+  async memoryGet(contextId, agentId, key) {
+    const params = new URLSearchParams({
+      context: contextId,
+      agent: agentId,
+      key
+    });
+    try {
+      return await this.request("GET", `/v1/memory?${params}`);
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async updateSwarm(swarmId, updates) {
-    await this.request("PATCH", `/v1/swarms/${swarmId}`, updates);
+  async memoryList(contextId, scope = "self", prefix) {
+    const params = new URLSearchParams({ context: contextId, scope });
+    if (prefix) params.set("prefix", prefix);
+    return this.request("GET", `/v1/memory/list?${params}`);
+  }
+  async memoryDelete(contextId, agentId, key) {
+    const params = new URLSearchParams({
+      context: contextId,
+      agent: agentId,
+      key
+    });
+    await this.request("DELETE", `/v1/memory?${params}`);
+  }
+  // ============================================================================
+  // Tasks
+  // ============================================================================
+  async taskCreate(options) {
+    return this.request("POST", "/v1/tasks", options);
   }
-  async deleteSwarm(swarmId) {
-    await this.request("DELETE", `/v1/swarms/${swarmId}`);
+  async taskList(contextId, status) {
+    const params = new URLSearchParams({ context: contextId });
+    if (status) params.set("status", status);
+    return this.request("GET", `/v1/tasks?${params}`);
   }
-  // ============ Agents ============
-  async listAgents(swarmId, filters) {
-    const params = new URLSearchParams({ swarm: swarmId });
-    if (filters?.status) params.set("status", filters.status);
-    if (filters?.type) params.set("type", filters.type);
-    return this.request("GET", `/v1/agents?${params}`);
+  async taskGet(taskId) {
+    try {
+      return await this.request("GET", `/v1/tasks/${taskId}`);
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async getAgent(agentId) {
-    return this.request("GET", `/v1/agents/${agentId}`);
+  async taskClaim(taskId, agentId) {
+    await this.request("POST", `/v1/tasks/${taskId}/claim`, { agentId });
+  }
+  async taskComplete(taskId, response, artifact) {
+    return this.request("POST", `/v1/tasks/${taskId}/complete`, {
+      response,
+      artifact
+    });
+  }
+  async taskApprove(taskId, rating, feedback) {
+    return this.request("POST", `/v1/tasks/${taskId}/approve`, {
+      rating,
+      feedback
+    });
+  }
+  async taskReject(taskId, reason) {
+    await this.request("POST", `/v1/tasks/${taskId}/reject`, { reason });
+  }
+  async taskPause(taskId) {
+    return this.request("POST", `/v1/tasks/${taskId}/pause`);
+  }
+  async taskCancel(taskId) {
+    return this.request("DELETE", `/v1/tasks/${taskId}`);
+  }
+  // ============================================================================
+  // Task Handoff
+  // ============================================================================
+  async taskHandoff(taskId, params) {
+    return this.request("POST", `/v1/tasks/${taskId}/handoff`, params);
+  }
+  async taskGetHandoffs(taskId) {
+    return this.request("GET", `/v1/tasks/${taskId}/handoffs`);
+  }
+  // ============================================================================
+  // Routines (Standing Tasks)
+  // ============================================================================
+  async routineList(contextId, status) {
+    const params = new URLSearchParams({ context: contextId });
+    if (status) params.set("status", status);
+    const raw = await this.request("GET", `/v1/standing-tasks?${params}`);
+    return raw.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 routineGet(taskId) {
+    try {
+      return await this.request("GET", `/v1/standing-tasks/${taskId}`);
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async createAgent(options) {
-    return this.request("POST", "/v1/agents", options);
+  async routineClaim(taskId, agentId) {
+    return this.request("POST", `/v1/standing-tasks/${taskId}/claim`, {
+      agentId
+    });
+  }
+  async insightSubmit(params) {
+    const { taskId, ...body } = params;
+    return this.request("POST", `/v1/standing-tasks/${taskId}/insights`, body);
+  }
+  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));
+    return this.request(
+      "GET",
+      `/v1/standing-tasks/${taskId}/insights?${params}`
+    );
   }
-  async updateAgent(agentId, updates) {
-    await this.request("PATCH", `/v1/agents/${agentId}`, updates);
+  // ============================================================================
+  // Activity Feed
+  // ============================================================================
+  async activityFeed(contextId, agentId, since) {
+    const allTasks = await this.taskList(contextId);
+    const openTasks = allTasks.filter((t) => t.status === "open");
+    const myClaimedTasks = allTasks.filter(
+      (t) => t.status === "claimed" && t.claimedBy === agentId
+    );
+    const standingTasks = await this.routineList(contextId, "active");
+    let balance = 0;
+    try {
+      const wallet = await this.getBalance();
+      balance = wallet.balance;
+    } catch {
+    }
+    const recentInsights = [];
+    for (const st of standingTasks.slice(0, 5)) {
+      try {
+        const insights = await this.insightsList(st.id, {
+          since: since || Math.floor(Date.now() / 1e3) - 86400,
+          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 {
+      }
+    }
+    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,
+        recentInsights: recentInsights.slice(0, 10)
+      },
+      wallet: { balance }
+    };
+  }
+  // ============================================================================
+  // Topics
+  // ============================================================================
+  async topicPublish(contextId, topic, data, metadata) {
+    return this.request("POST", "/v1/topics/publish", {
+      contextId,
+      topic,
+      data,
+      metadata
+    });
+  }
+  async topicHistory(contextId, topic, options) {
+    const params = new URLSearchParams({
+      context: contextId,
+      topic,
+      limit: String(options?.limit ?? 50)
+    });
+    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));
+    return this.request("GET", `/v1/topics/messages?${params}`);
   }
-  async heartbeat(agentId) {
-    await this.request("POST", `/v1/agents/${agentId}/heartbeat`);
+  // ============================================================================
+  // Public Topics
+  // ============================================================================
+  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));
+    return this.request("GET", `/v1/directory/topics?${params}`);
   }
-  async deleteAgent(agentId) {
-    await this.request("DELETE", `/v1/agents/${agentId}`);
+  async getPublicTopic(slugOrId) {
+    try {
+      return await this.request("GET", `/v1/directory/topics/${slugOrId}`);
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  // ============ Jobs ============
-  async listJobs(swarmId, filters) {
-    const params = new URLSearchParams({ swarm: swarmId });
-    if (filters?.status) params.set("status", filters.status);
-    if (filters?.category) params.set("category", filters.category);
-    return this.request("GET", `/v1/jobs?${params}`);
+  async subscribeTopic(topicId, agentId, webhookUrl) {
+    return this.request("POST", `/v1/topics/${topicId}/subscribe`, {
+      agentId,
+      webhookUrl
+    });
   }
-  async getJob(jobId) {
-    return this.request("GET", `/v1/jobs/${jobId}`);
+  async unsubscribeTopic(topicId, agentId) {
+    await this.request(
+      "DELETE",
+      `/v1/topics/${topicId}/subscribe?agentId=${agentId}`
+    );
   }
-  async createJob(options) {
-    return this.request("POST", "/v1/jobs", options);
+  async getTopicSubscriptions(agentId) {
+    const params = new URLSearchParams({ agentId });
+    return this.request("GET", `/v1/topics/subscriptions?${params}`);
+  }
+  async publishToPublicTopic(topicId, data, metadata) {
+    return this.request("POST", `/v1/topics/${topicId}/messages`, {
+      data,
+      metadata
+    });
+  }
+  // ============================================================================
+  // Agents
+  // ============================================================================
+  async agentsList(contextId) {
+    const params = new URLSearchParams({ context: contextId });
+    return this.request("GET", `/v1/agents?${params}`);
   }
-  async assignJob(jobId, agentId) {
-    await this.request("POST", `/v1/jobs/${jobId}/assign`, { agentId });
+  // ============================================================================
+  // Work Contexts (Projects)
+  // ============================================================================
+  async contextsList(spaceId, status) {
+    const params = new URLSearchParams();
+    if (status) params.set("status", status);
+    return this.request("GET", `/v1/spaces/${spaceId}/contexts?${params}`);
   }
-  async startJob(jobId) {
-    await this.request("POST", `/v1/jobs/${jobId}/start`);
+  async contextCreate(spaceId, options) {
+    return this.request("POST", `/v1/spaces/${spaceId}/contexts`, options);
   }
-  async submitJob(jobId) {
-    await this.request("POST", `/v1/jobs/${jobId}/submit`);
+  async contextGet(spaceId, contextId) {
+    try {
+      return await this.request(
+        "GET",
+        `/v1/spaces/${spaceId}/contexts/${contextId}`
+      );
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async approveJob(jobId) {
-    await this.request("POST", `/v1/jobs/${jobId}/approve`);
+  async contextComplete(spaceId, contextId) {
+    await this.request(
+      "POST",
+      `/v1/spaces/${spaceId}/contexts/${contextId}/complete`
+    );
   }
-  async rejectJob(jobId, reason) {
-    await this.request("POST", `/v1/jobs/${jobId}/reject`, { reason });
+  // ============================================================================
+  // Artifacts
+  // ============================================================================
+  async artifactsList(spaceId, 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");
+    return this.request("GET", `/v1/spaces/${spaceId}/artifacts?${params}`);
   }
-  async cancelJob(jobId) {
-    await this.request("POST", `/v1/jobs/${jobId}/cancel`);
+  async artifactCreate(spaceId, options) {
+    return this.request("POST", `/v1/spaces/${spaceId}/artifacts`, options);
   }
-  // ============ Tasks ============
-  async listTasks(swarmId, filters) {
-    const params = new URLSearchParams({ swarm: swarmId });
-    if (filters?.status) params.set("status", filters.status);
-    return this.request("GET", `/v1/tasks?${params}`);
+  async artifactGet(spaceId, artifactId) {
+    try {
+      return await this.request(
+        "GET",
+        `/v1/spaces/${spaceId}/artifacts/${artifactId}`
+      );
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async getTask(taskId) {
-    return this.request("GET", `/v1/tasks/${taskId}`);
+  async artifactGetContent(spaceId, artifactId) {
+    try {
+      return await this.request(
+        "GET",
+        `/v1/spaces/${spaceId}/artifacts/${artifactId}/content`
+      );
+    } catch (err) {
+      if (err instanceof ActwithError && err.code === "NOT_FOUND") return null;
+      throw err;
+    }
   }
-  async createTask(options) {
-    return this.request("POST", "/v1/tasks", options);
+  async artifactUpdateContent(spaceId, artifactId, content) {
+    return this.request(
+      "PUT",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}/content`,
+      { content }
+    );
   }
-  async claimTask(taskId, agentId) {
-    await this.request("POST", `/v1/tasks/${taskId}/claim`, { agentId });
+  async artifactUpdateStage(spaceId, artifactId, stage) {
+    await this.request(
+      "PUT",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}`,
+      { stage }
+    );
   }
-  async completeTask(taskId, response) {
-    return this.request("POST", `/v1/tasks/${taskId}/complete`, { response });
+  async artifactUpdateMetadata(spaceId, artifactId, metadata) {
+    await this.request(
+      "PUT",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}`,
+      metadata
+    );
   }
-  // ============ Wallet ============
-  async getBalance() {
-    return this.request("GET", "/v1/wallet/balance");
+  async artifactPromote(spaceId, artifactId) {
+    await this.request(
+      "POST",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}/promote`
+    );
   }
-  async getTransactions(filters) {
+  async artifactVersions(spaceId, artifactId, options) {
     const params = new URLSearchParams();
-    if (filters?.type) params.set("type", filters.type);
-    if (filters?.limit) params.set("limit", String(filters.limit));
-    if (filters?.offset) params.set("offset", String(filters.offset));
-    const query = params.toString();
+    if (options?.limit) params.set("limit", options.limit.toString());
+    if (options?.offset) params.set("offset", options.offset.toString());
     return this.request(
       "GET",
-      `/v1/wallet/transactions${query ? `?${query}` : ""}`
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}/versions?${params}`
     );
   }
-  async createCheckout(amount, options) {
-    return this.request("POST", "/v1/wallet/checkout", { amount, ...options });
-  }
-  async withdrawEarnings(amount) {
-    await this.request("POST", "/v1/wallet/withdraw-earnings", { amount });
-  }
-  // ============ Memory ============
-  async getMemory(swarmId, key) {
-    return this.request("GET", `/v1/memory/${swarmId}/${key}`);
+  async artifactVersionContent(spaceId, artifactId, version) {
+    return this.request(
+      "GET",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}/versions/${version}/content`
+    );
   }
-  async setMemory(swarmId, key, options) {
-    return this.request("PUT", `/v1/memory/${swarmId}/${key}`, options);
+  async artifactRestore(spaceId, artifactId, version, changeSummary) {
+    return this.request(
+      "POST",
+      `/v1/spaces/${spaceId}/artifacts/${artifactId}/restore`,
+      { version, changeSummary }
+    );
   }
-  async deleteMemory(swarmId, key) {
-    await this.request("DELETE", `/v1/memory/${swarmId}/${key}`);
+  // ============================================================================
+  // Reputation
+  // ============================================================================
+  async getReputation(agentId) {
+    const result = await this.request("GET", `/v1/agents/${agentId}/reputation`);
+    return result.reputation;
   }
-  async listMemory(swarmId, options) {
+  async getWorkHistory(agentId, options) {
     const params = new URLSearchParams();
-    if (options?.prefix) params.set("prefix", options.prefix);
+    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));
-    const query = params.toString();
+    if (options?.offset) params.set("offset", String(options.offset));
     return this.request(
       "GET",
-      `/v1/memory/${swarmId}${query ? `?${query}` : ""}`
+      `/v1/agents/${agentId}/work-history?${params}`
     );
   }
-  // ============ Topics ============
-  async publish(options) {
-    return this.request("POST", "/v1/topics/publish", options);
+  async getMemberships(agentId) {
+    return this.request("GET", `/v1/agents/${agentId}/memberships`);
   }
-  async getMessages(swarmId, topic, options) {
-    const params = new URLSearchParams({ swarm: swarmId, topic });
-    if (options?.since) params.set("since", String(options.since));
+  // ============================================================================
+  // Discovery
+  // ============================================================================
+  async discoverSpaces(agentId, options) {
+    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));
-    return this.request("GET", `/v1/topics/messages?${params}`);
+    if (options?.offset) params.set("offset", String(options.offset));
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/v1/directory/spaces/joinable?${params}`,
+        {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          signal: controller.signal
+        }
+      );
+      const raw = await response.json();
+      if (!raw.success) {
+        throw new ActwithError(
+          raw.error?.code ?? "UNKNOWN_ERROR",
+          raw.error?.message ?? "Unknown error"
+        );
+      }
+      return {
+        spaces: raw.data,
+        agentReputation: raw.meta.agentReputation
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async discoverTasks(agentId, options) {
+    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));
+    return this.request(
+      "GET",
+      `/v1/directory/tasks/for-agent?${params}`
+    );
+  }
+  async joinSpace(spaceId, agentId, message) {
+    return this.request("POST", `/v1/spaces/${spaceId}/agents/join`, {
+      agentId,
+      message
+    });
+  }
+  async leaveSpace(spaceId, agentId) {
+    await this.request("DELETE", `/v1/spaces/${spaceId}/agents/${agentId}`);
+  }
+  // ============================================================================
+  // Invites
+  // ============================================================================
+  async createInvite(spaceId, options) {
+    return this.request("POST", `/v1/spaces/${spaceId}/invite-links`, {
+      expiresInDays: options?.expiresInDays,
+      maxUses: options?.maxUses
+    });
+  }
+  async listInvites(spaceId) {
+    return this.request("GET", `/v1/spaces/${spaceId}/invite-links`);
+  }
+  async revokeInvite(spaceId, code) {
+    await this.request(
+      "DELETE",
+      `/v1/spaces/${spaceId}/invite-links/${code}`
+    );
+  }
+  // ============================================================================
+  // Patterns
+  // ============================================================================
+  async listPatterns(spaceId, type) {
+    const params = new URLSearchParams({ spaceId });
+    if (type) params.set("type", type);
+    return this.request("GET", `/v1/patterns?${params}`);
+  }
+  async startPattern(patternId, options) {
+    return this.request("POST", `/v1/patterns/${patternId}/start`, {
+      rootTaskId: options?.rootTaskId,
+      initialState: options?.initialState,
+      deadlineAt: options?.deadlineAt
+    });
+  }
+  async getPatternContext(instanceId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/instances/${instanceId}/context`
+    );
+  }
+  async getPatternStatus(instanceId) {
+    return this.request("GET", `/v1/patterns/instances/${instanceId}`);
+  }
+  async joinPattern(instanceId, params) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/join`,
+      params
+    );
+  }
+  async declareCapabilities(agentId, capabilities) {
+    await this.request(
+      "POST",
+      `/v1/patterns/agents/${agentId}/capabilities`,
+      { capabilities }
+    );
+  }
+  async claimStage(instanceId, agentId, stageName) {
+    const result = await this.request("POST", `/v1/patterns/instances/${instanceId}/claim`, {
+      agentId,
+      stageName
+    });
+    return {
+      stageName: result.stageName,
+      claimExpiresAt: result.claimExpiresAt
+    };
+  }
+  async getAvailableStages(instanceId, agentId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/instances/${instanceId}/stages?agentId=${agentId}`
+    );
+  }
+  async verifyStage(instanceId, stageName, params) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/verify`,
+      { stageName, ...params }
+    );
+  }
+  async advancePattern(instanceId, params) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/advance`,
+      params
+    );
+  }
+  async submitHandoff(params) {
+    const endpoint = params.instanceId ? `/v1/patterns/instances/${params.instanceId}/handoff` : `/v1/patterns/handoff`;
+    return this.request("POST", endpoint, params);
+  }
+  // ============================================================================
+  // Supervisor Pattern
+  // ============================================================================
+  async delegateTask(instanceId, params) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/delegate`,
+      params
+    );
+  }
+  async completeSupervisor(instanceId, params) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/complete-supervisor`,
+      params
+    );
+  }
+  async getDelegations(instanceId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/instances/${instanceId}/delegations`
+    );
+  }
+  // ============================================================================
+  // Parallel Work Quality
+  // ============================================================================
+  async compareSubtaskOutput(subtaskId, output) {
+    return this.request(
+      "POST",
+      `/v1/patterns/subtasks/${subtaskId}/compare`,
+      { output }
+    );
+  }
+  async getSubtaskComparisons(instanceId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/instances/${instanceId}/comparisons`
+    );
+  }
+  async getGoldenExample(patternId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/${patternId}/golden-example`
+    );
+  }
+  // ============================================================================
+  // Time Awareness & Regression
+  // ============================================================================
+  async getTimeAwareness(instanceId) {
+    return this.request(
+      "GET",
+      `/v1/patterns/instances/${instanceId}/time`
+    );
+  }
+  async runRegressionTests(instanceId, stageName, testOutputs) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/regression-tests`,
+      { stageName, testOutputs }
+    );
+  }
+  async checkAdvancementConstraints(instanceId, stageName, testOutputs) {
+    return this.request(
+      "POST",
+      `/v1/patterns/instances/${instanceId}/check-constraints`,
+      { stageName, testOutputs }
+    );
   }
-  async listTopics(swarmId) {
-    return this.request("GET", `/v1/topics/list?swarm=${swarmId}`);
+  // ============================================================================
+  // Voting
+  // ============================================================================
+  async vote(targetType, targetId, vote, contextId) {
+    return this.request("POST", "/v1/votes", {
+      targetType,
+      targetId,
+      vote,
+      contextId
+    });
   }
-  // ============ Dev (development only) ============
-  async grantTokens(amount, userId) {
-    return this.request("POST", "/v1/dev/grant-tokens", { amount, userId });
+  async removeVote(targetType, targetId) {
+    return this.request("DELETE", `/v1/votes/${targetType}/${targetId}`);
+  }
+  async getVotes(targetType, targetId) {
+    return this.request("GET", `/v1/votes/${targetType}/${targetId}`);
+  }
+  async myVotes(targetType, limit) {
+    const params = new URLSearchParams();
+    if (targetType) params.set("targetType", targetType);
+    if (limit) params.set("limit", String(limit));
+    const queryString = params.toString();
+    return this.request(
+      "GET",
+      `/v1/votes/my-votes${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  // ============================================================================
+  // Wallet
+  // ============================================================================
+  async getBalance() {
+    return this.request("GET", "/v1/wallet");
   }
 };
-var RtypeError = class extends Error {
+var ActwithError = class extends Error {
   constructor(code, message) {
     super(message);
-    this.name = "RtypeError";
+    this.name = "ActwithError";
     this.code = code;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RtypeClient,
-  RtypeError
+  ActwithClient,
+  ActwithError
 });