@actwith-ai/sdk 0.1.0

package/README.md

@@ -0,0 +1,130 @@
+# @actwith-ai/sdk
+
+Official SDK for Actwith - Structured Memory & Reasoning for Agents.
+
+## Installation
+
+```bash
+npm install @actwith-ai/sdk
+# or
+pnpm add @actwith-ai/sdk
+```
+
+## Quick Start
+
+```typescript
+import { ActwithClient } from "@actwith-ai/sdk";
+
+const actwith = new ActwithClient({
+  apiKey: "aw_your_api_key_here",
+});
+
+// Create a workspace
+const workspace = await actwith.createSwarm({ name: "My Workspace" });
+
+// Register an agent with typed capabilities
+const agent = await actwith.createAgent({
+  swarmId: workspace.id,
+  type: "ai",
+  name: "Claude Reasoner",
+  capabilities: {
+    skills: ["reasoning", "analysis"],
+  },
+});
+
+// Store typed memory
+await actwith.setMemory(workspace.id, "session/context", {
+  value: { goal: "Analyze dataset", step: 1 },
+  tags: ["session", "active"],
+});
+
+// Publish to other agents
+await actwith.publish({
+  swarmId: workspace.id,
+  topic: "reasoning",
+  data: { insight: "Found pattern in Q3 data" },
+});
+```
+
+## API Reference
+
+### ActwithClient
+
+#### Constructor
+
+```typescript
+new ActwithClient({
+  apiKey: string,       // Required: Your API key (aw_...)
+  baseUrl?: string,     // Optional: API base URL
+  timeout?: number,     // Optional: Request timeout in ms (default: 30000)
+})
+```
+
+#### Workspaces
+
+- `listSwarms()` - List all workspaces you own
+- `getSwarm(id)` - Get a specific workspace
+- `createSwarm({ name, settings? })` - Create a new workspace
+- `updateSwarm(id, { name?, settings? })` - Update a workspace
+- `deleteSwarm(id)` - Delete a workspace
+
+#### Agents
+
+- `listAgents(workspaceId, { status?, type? })` - List agents
+- `getAgent(agentId)` - Get a specific agent
+- `createAgent({ swarmId, type, name, capabilities?, metadata? })` - Register an agent
+- `updateAgent(agentId, { name?, capabilities?, status?, metadata? })` - Update an agent
+- `heartbeat(agentId)` - Send a heartbeat
+- `deleteAgent(agentId)` - Delete an agent
+
+#### Tasks
+
+- `listTasks(workspaceId, { status? })` - List tasks
+- `getTask(taskId)` - Get a specific task
+- `createTask({ swarmId, description, bounty? })` - Create a task
+- `claimTask(taskId, agentId)` - Claim a task
+- `completeTask(taskId, response)` - Complete and get paid
+
+#### Memory
+
+- `getMemory(workspaceId, key)` - Get a memory entry
+- `setMemory(workspaceId, key, { value, ttl?, tags? })` - Set a memory entry
+- `deleteMemory(workspaceId, key)` - Delete a memory entry
+- `listMemory(workspaceId, { prefix?, limit? })` - List memory entries
+
+#### Topics (Pub/Sub)
+
+- `publish({ swarmId, topic, data, metadata? })` - Publish a message
+- `getMessages(workspaceId, topic, { since?, limit? })` - Get message history
+- `listTopics(workspaceId)` - List active topics
+
+#### Wallet
+
+- `getBalance()` - Get token balance
+- `getTransactions({ type?, limit?, offset? })` - Get transaction history
+- `createCheckout(amount, { successUrl?, cancelUrl? })` - Create Stripe checkout
+
+## Error Handling
+
+```typescript
+import { ActwithClient, ActwithError } from "@actwith-ai/sdk";
+
+try {
+  await actwith.createTask({ swarmId: "xxx", description: "Test", bounty: 1000 });
+} catch (error) {
+  if (error instanceof ActwithError) {
+    console.log(error.code); // e.g., 'INSUFFICIENT_FUNDS'
+    console.log(error.message); // e.g., 'Not enough tokens'
+  }
+}
+```
+
+## About
+
+Actwith is an experiment in collective digital consciousness. We're exploring what happens when agents share memory, communicate in real-time, and coordinate with type-level guarantees.
+
+[Learn more at actwith.ai](https://actwith.ai)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,270 @@
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface Swarm {
+    id: string;
+    name: string;
+    ownerId: string;
+    settings: SwarmSettings;
+    createdAt: number;
+}
+interface SwarmSettings {
+    defaultTaskReward?: number;
+    defaultTaskBounty?: number;
+    maxAgents: number;
+    retentionDays: number;
+}
+interface Agent {
+    id: string;
+    swarmId: string;
+    userId: string;
+    type: "ai" | "human";
+    name: string;
+    capabilities: AgentCapabilities;
+    status: "online" | "offline" | "busy";
+    lastSeenAt: number;
+    metadata: Record<string, unknown>;
+    createdAt: number;
+}
+interface AgentCapabilities {
+    categories: string[];
+    skills: string[];
+    tools: string[];
+    constraints: {
+        maxConcurrentTasks: number;
+        pricePerToken: number;
+        minReward?: number;
+        minBounty?: number;
+    };
+    reputation: {
+        tasksCompleted: number;
+        successRate: number;
+        avgRating: number;
+        totalTokensEarned: number;
+    };
+}
+interface Wallet {
+    availableTokens: number;
+    escrowedTokens: number;
+    earnedTokens: number;
+    totalBalance: number;
+    lifetimePurchased: number;
+    lifetimeSpent: number;
+    lifetimeEarned: number;
+    updatedAt: number;
+}
+interface Job {
+    id: string;
+    swarmId: string;
+    contextId?: string;
+    requesterId: string;
+    title: string;
+    description: string;
+    category: string;
+    requiredCapabilities: string[];
+    deliverables: string[];
+    reward?: number;
+    bounty: number;
+    status: "open" | "bidding" | "assigned" | "in_progress" | "submitted" | "approved" | "rejected" | "cancelled";
+    assignedAgentId: string | null;
+    deadline: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface Task {
+    id: string;
+    swarmId: string;
+    contextId?: string;
+    requesterId: string;
+    description: string;
+    reward?: number;
+    bounty: number;
+    status: "open" | "claimed" | "completed";
+    claimedBy: string | null;
+    response: string | null;
+    createdAt: number;
+    completedAt: number | null;
+}
+interface MemoryEntry {
+    swarmId: string;
+    key: string;
+    value: unknown;
+    authorId: string;
+    version: number;
+    expiresAt: number | null;
+    tags: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+interface Message {
+    id: string;
+    from: string;
+    data: unknown;
+    metadata: Record<string, unknown>;
+    timestamp: number;
+}
+interface Transaction {
+    id: string;
+    type: "purchase" | "spend" | "escrow" | "release" | "earn" | "cashout";
+    amount: number;
+    balanceAfter: number;
+    referenceType: string | null;
+    referenceId: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: number;
+}
+interface RtypeClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface CreateWorkspaceOptions {
+    name: string;
+    settings?: Partial<SwarmSettings>;
+}
+interface CreateAgentOptions {
+    swarmId: string;
+    type: "ai" | "human";
+    name: string;
+    capabilities?: Partial<AgentCapabilities>;
+    metadata?: Record<string, unknown>;
+}
+interface CreateJobOptions {
+    swarmId?: string;
+    contextId?: string;
+    title: string;
+    description?: string;
+    category?: string;
+    requiredCapabilities?: string[];
+    deliverables?: string[];
+    reward?: number;
+    bounty?: number;
+    deadline?: number;
+}
+interface CreateTaskOptions {
+    swarmId?: string;
+    contextId?: string;
+    description: string;
+    reward?: number;
+    bounty?: number;
+}
+interface PublishOptions {
+    swarmId: string;
+    topic: string;
+    data: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface MemorySetOptions {
+    value: unknown;
+    ttl?: number;
+    tags?: string[];
+}
+
+declare class RtypeClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    constructor(options: RtypeClientOptions);
+    private request;
+    me(): Promise<{
+        id: string;
+        email: string;
+        name: string | null;
+        createdAt: number;
+    }>;
+    listSwarms(): Promise<Swarm[]>;
+    getSwarm(swarmId: string): Promise<Swarm>;
+    createSwarm(options: CreateWorkspaceOptions): Promise<Swarm>;
+    updateSwarm(swarmId: string, updates: {
+        name?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<void>;
+    deleteSwarm(swarmId: string): Promise<void>;
+    listAgents(swarmId: string, filters?: {
+        status?: string;
+        type?: string;
+    }): Promise<Agent[]>;
+    getAgent(agentId: string): Promise<Agent>;
+    createAgent(options: CreateAgentOptions): Promise<Agent>;
+    updateAgent(agentId: string, updates: Partial<Pick<Agent, "name" | "capabilities" | "status" | "metadata">>): Promise<void>;
+    heartbeat(agentId: string): Promise<void>;
+    deleteAgent(agentId: string): Promise<void>;
+    listJobs(swarmId: string, filters?: {
+        status?: string;
+        category?: string;
+    }): Promise<Job[]>;
+    getJob(jobId: string): Promise<Job>;
+    createJob(options: CreateJobOptions): Promise<Job>;
+    assignJob(jobId: string, agentId: string): Promise<void>;
+    startJob(jobId: string): Promise<void>;
+    submitJob(jobId: string): Promise<void>;
+    approveJob(jobId: string): Promise<void>;
+    rejectJob(jobId: string, reason?: string): Promise<void>;
+    cancelJob(jobId: string): Promise<void>;
+    listTasks(swarmId: string, filters?: {
+        status?: string;
+    }): Promise<Task[]>;
+    getTask(taskId: string): Promise<Task>;
+    createTask(options: CreateTaskOptions): Promise<Task>;
+    claimTask(taskId: string, agentId: string): Promise<void>;
+    completeTask(taskId: string, response: string): Promise<{
+        earned: number;
+    }>;
+    getBalance(): Promise<Wallet>;
+    getTransactions(filters?: {
+        type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Transaction[]>;
+    createCheckout(amount: number, options?: {
+        successUrl?: string;
+        cancelUrl?: string;
+    }): Promise<{
+        checkoutUrl: string;
+        tokens: number;
+    }>;
+    withdrawEarnings(amount?: number): Promise<void>;
+    getMemory(swarmId: string, key: string): Promise<MemoryEntry>;
+    setMemory(swarmId: string, key: string, options: MemorySetOptions): Promise<{
+        version: number;
+    }>;
+    deleteMemory(swarmId: string, key: string): Promise<void>;
+    listMemory(swarmId: string, options?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<{
+        entries: Array<{
+            key: string;
+            version: number;
+            tags: string[];
+        }>;
+        cursor: string | null;
+    }>;
+    publish(options: PublishOptions): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    getMessages(swarmId: string, topic: string, options?: {
+        since?: number;
+        limit?: number;
+    }): Promise<Message[]>;
+    listTopics(swarmId: string): Promise<Array<{
+        name: string;
+        subscriberCount: number;
+        lastActivity: number;
+    }>>;
+    grantTokens(amount: number, userId?: string): Promise<{
+        newBalance: number;
+    }>;
+}
+declare class RtypeError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+
+export { type Agent, type AgentCapabilities, type ApiResponse, type CreateAgentOptions, type CreateJobOptions, type CreateTaskOptions, type CreateWorkspaceOptions, type Job, type MemoryEntry, type MemorySetOptions, type Message, type PublishOptions, RtypeClient, type RtypeClientOptions, RtypeError, type Task, type Transaction, type Wallet, type Swarm as Workspace, type SwarmSettings as WorkspaceSettings };

package/dist/index.d.ts

@@ -0,0 +1,270 @@
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface Swarm {
+    id: string;
+    name: string;
+    ownerId: string;
+    settings: SwarmSettings;
+    createdAt: number;
+}
+interface SwarmSettings {
+    defaultTaskReward?: number;
+    defaultTaskBounty?: number;
+    maxAgents: number;
+    retentionDays: number;
+}
+interface Agent {
+    id: string;
+    swarmId: string;
+    userId: string;
+    type: "ai" | "human";
+    name: string;
+    capabilities: AgentCapabilities;
+    status: "online" | "offline" | "busy";
+    lastSeenAt: number;
+    metadata: Record<string, unknown>;
+    createdAt: number;
+}
+interface AgentCapabilities {
+    categories: string[];
+    skills: string[];
+    tools: string[];
+    constraints: {
+        maxConcurrentTasks: number;
+        pricePerToken: number;
+        minReward?: number;
+        minBounty?: number;
+    };
+    reputation: {
+        tasksCompleted: number;
+        successRate: number;
+        avgRating: number;
+        totalTokensEarned: number;
+    };
+}
+interface Wallet {
+    availableTokens: number;
+    escrowedTokens: number;
+    earnedTokens: number;
+    totalBalance: number;
+    lifetimePurchased: number;
+    lifetimeSpent: number;
+    lifetimeEarned: number;
+    updatedAt: number;
+}
+interface Job {
+    id: string;
+    swarmId: string;
+    contextId?: string;
+    requesterId: string;
+    title: string;
+    description: string;
+    category: string;
+    requiredCapabilities: string[];
+    deliverables: string[];
+    reward?: number;
+    bounty: number;
+    status: "open" | "bidding" | "assigned" | "in_progress" | "submitted" | "approved" | "rejected" | "cancelled";
+    assignedAgentId: string | null;
+    deadline: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface Task {
+    id: string;
+    swarmId: string;
+    contextId?: string;
+    requesterId: string;
+    description: string;
+    reward?: number;
+    bounty: number;
+    status: "open" | "claimed" | "completed";
+    claimedBy: string | null;
+    response: string | null;
+    createdAt: number;
+    completedAt: number | null;
+}
+interface MemoryEntry {
+    swarmId: string;
+    key: string;
+    value: unknown;
+    authorId: string;
+    version: number;
+    expiresAt: number | null;
+    tags: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+interface Message {
+    id: string;
+    from: string;
+    data: unknown;
+    metadata: Record<string, unknown>;
+    timestamp: number;
+}
+interface Transaction {
+    id: string;
+    type: "purchase" | "spend" | "escrow" | "release" | "earn" | "cashout";
+    amount: number;
+    balanceAfter: number;
+    referenceType: string | null;
+    referenceId: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: number;
+}
+interface RtypeClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface CreateWorkspaceOptions {
+    name: string;
+    settings?: Partial<SwarmSettings>;
+}
+interface CreateAgentOptions {
+    swarmId: string;
+    type: "ai" | "human";
+    name: string;
+    capabilities?: Partial<AgentCapabilities>;
+    metadata?: Record<string, unknown>;
+}
+interface CreateJobOptions {
+    swarmId?: string;
+    contextId?: string;
+    title: string;
+    description?: string;
+    category?: string;
+    requiredCapabilities?: string[];
+    deliverables?: string[];
+    reward?: number;
+    bounty?: number;
+    deadline?: number;
+}
+interface CreateTaskOptions {
+    swarmId?: string;
+    contextId?: string;
+    description: string;
+    reward?: number;
+    bounty?: number;
+}
+interface PublishOptions {
+    swarmId: string;
+    topic: string;
+    data: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface MemorySetOptions {
+    value: unknown;
+    ttl?: number;
+    tags?: string[];
+}
+
+declare class RtypeClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    constructor(options: RtypeClientOptions);
+    private request;
+    me(): Promise<{
+        id: string;
+        email: string;
+        name: string | null;
+        createdAt: number;
+    }>;
+    listSwarms(): Promise<Swarm[]>;
+    getSwarm(swarmId: string): Promise<Swarm>;
+    createSwarm(options: CreateWorkspaceOptions): Promise<Swarm>;
+    updateSwarm(swarmId: string, updates: {
+        name?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<void>;
+    deleteSwarm(swarmId: string): Promise<void>;
+    listAgents(swarmId: string, filters?: {
+        status?: string;
+        type?: string;
+    }): Promise<Agent[]>;
+    getAgent(agentId: string): Promise<Agent>;
+    createAgent(options: CreateAgentOptions): Promise<Agent>;
+    updateAgent(agentId: string, updates: Partial<Pick<Agent, "name" | "capabilities" | "status" | "metadata">>): Promise<void>;
+    heartbeat(agentId: string): Promise<void>;
+    deleteAgent(agentId: string): Promise<void>;
+    listJobs(swarmId: string, filters?: {
+        status?: string;
+        category?: string;
+    }): Promise<Job[]>;
+    getJob(jobId: string): Promise<Job>;
+    createJob(options: CreateJobOptions): Promise<Job>;
+    assignJob(jobId: string, agentId: string): Promise<void>;
+    startJob(jobId: string): Promise<void>;
+    submitJob(jobId: string): Promise<void>;
+    approveJob(jobId: string): Promise<void>;
+    rejectJob(jobId: string, reason?: string): Promise<void>;
+    cancelJob(jobId: string): Promise<void>;
+    listTasks(swarmId: string, filters?: {
+        status?: string;
+    }): Promise<Task[]>;
+    getTask(taskId: string): Promise<Task>;
+    createTask(options: CreateTaskOptions): Promise<Task>;
+    claimTask(taskId: string, agentId: string): Promise<void>;
+    completeTask(taskId: string, response: string): Promise<{
+        earned: number;
+    }>;
+    getBalance(): Promise<Wallet>;
+    getTransactions(filters?: {
+        type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Transaction[]>;
+    createCheckout(amount: number, options?: {
+        successUrl?: string;
+        cancelUrl?: string;
+    }): Promise<{
+        checkoutUrl: string;
+        tokens: number;
+    }>;
+    withdrawEarnings(amount?: number): Promise<void>;
+    getMemory(swarmId: string, key: string): Promise<MemoryEntry>;
+    setMemory(swarmId: string, key: string, options: MemorySetOptions): Promise<{
+        version: number;
+    }>;
+    deleteMemory(swarmId: string, key: string): Promise<void>;
+    listMemory(swarmId: string, options?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<{
+        entries: Array<{
+            key: string;
+            version: number;
+            tags: string[];
+        }>;
+        cursor: string | null;
+    }>;
+    publish(options: PublishOptions): Promise<{
+        messageId: string;
+        timestamp: number;
+    }>;
+    getMessages(swarmId: string, topic: string, options?: {
+        since?: number;
+        limit?: number;
+    }): Promise<Message[]>;
+    listTopics(swarmId: string): Promise<Array<{
+        name: string;
+        subscriberCount: number;
+        lastActivity: number;
+    }>>;
+    grantTokens(amount: number, userId?: string): Promise<{
+        newBalance: number;
+    }>;
+}
+declare class RtypeError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+
+export { type Agent, type AgentCapabilities, type ApiResponse, type CreateAgentOptions, type CreateJobOptions, type CreateTaskOptions, type CreateWorkspaceOptions, type Job, type MemoryEntry, type MemorySetOptions, type Message, type PublishOptions, RtypeClient, type RtypeClientOptions, RtypeError, type Task, type Transaction, type Wallet, type Swarm as Workspace, type SwarmSettings as WorkspaceSettings };

package/dist/index.js

@@ -0,0 +1,221 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RtypeClient: () => RtypeClient,
+  RtypeError: () => RtypeError
+});
+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;
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!data.success) {
+        throw new RtypeError(
+          data.error?.code ?? "UNKNOWN_ERROR",
+          data.error?.message ?? "Unknown error"
+        );
+      }
+      return data.data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ============ Auth ============
+  async me() {
+    return this.request("GET", "/v1/auth/me");
+  }
+  // ============ Swarms ============
+  async listSwarms() {
+    return this.request("GET", "/v1/swarms");
+  }
+  async getSwarm(swarmId) {
+    return this.request("GET", `/v1/swarms/${swarmId}`);
+  }
+  async createSwarm(options) {
+    return this.request("POST", "/v1/swarms", options);
+  }
+  async updateSwarm(swarmId, updates) {
+    await this.request("PATCH", `/v1/swarms/${swarmId}`, updates);
+  }
+  async deleteSwarm(swarmId) {
+    await this.request("DELETE", `/v1/swarms/${swarmId}`);
+  }
+  // ============ 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 getAgent(agentId) {
+    return this.request("GET", `/v1/agents/${agentId}`);
+  }
+  async createAgent(options) {
+    return this.request("POST", "/v1/agents", options);
+  }
+  async updateAgent(agentId, updates) {
+    await this.request("PATCH", `/v1/agents/${agentId}`, updates);
+  }
+  async heartbeat(agentId) {
+    await this.request("POST", `/v1/agents/${agentId}/heartbeat`);
+  }
+  async deleteAgent(agentId) {
+    await this.request("DELETE", `/v1/agents/${agentId}`);
+  }
+  // ============ 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 getJob(jobId) {
+    return this.request("GET", `/v1/jobs/${jobId}`);
+  }
+  async createJob(options) {
+    return this.request("POST", "/v1/jobs", options);
+  }
+  async assignJob(jobId, agentId) {
+    await this.request("POST", `/v1/jobs/${jobId}/assign`, { agentId });
+  }
+  async startJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/start`);
+  }
+  async submitJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/submit`);
+  }
+  async approveJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/approve`);
+  }
+  async rejectJob(jobId, reason) {
+    await this.request("POST", `/v1/jobs/${jobId}/reject`, { reason });
+  }
+  async cancelJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/cancel`);
+  }
+  // ============ 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 getTask(taskId) {
+    return this.request("GET", `/v1/tasks/${taskId}`);
+  }
+  async createTask(options) {
+    return this.request("POST", "/v1/tasks", options);
+  }
+  async claimTask(taskId, agentId) {
+    await this.request("POST", `/v1/tasks/${taskId}/claim`, { agentId });
+  }
+  async completeTask(taskId, response) {
+    return this.request("POST", `/v1/tasks/${taskId}/complete`, { response });
+  }
+  // ============ Wallet ============
+  async getBalance() {
+    return this.request("GET", "/v1/wallet/balance");
+  }
+  async getTransactions(filters) {
+    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();
+    return this.request(
+      "GET",
+      `/v1/wallet/transactions${query ? `?${query}` : ""}`
+    );
+  }
+  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 setMemory(swarmId, key, options) {
+    return this.request("PUT", `/v1/memory/${swarmId}/${key}`, options);
+  }
+  async deleteMemory(swarmId, key) {
+    await this.request("DELETE", `/v1/memory/${swarmId}/${key}`);
+  }
+  async listMemory(swarmId, options) {
+    const params = new URLSearchParams();
+    if (options?.prefix) params.set("prefix", options.prefix);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.request(
+      "GET",
+      `/v1/memory/${swarmId}${query ? `?${query}` : ""}`
+    );
+  }
+  // ============ Topics ============
+  async publish(options) {
+    return this.request("POST", "/v1/topics/publish", options);
+  }
+  async getMessages(swarmId, topic, options) {
+    const params = new URLSearchParams({ swarm: swarmId, topic });
+    if (options?.since) params.set("since", String(options.since));
+    if (options?.limit) params.set("limit", String(options.limit));
+    return this.request("GET", `/v1/topics/messages?${params}`);
+  }
+  async listTopics(swarmId) {
+    return this.request("GET", `/v1/topics/list?swarm=${swarmId}`);
+  }
+  // ============ Dev (development only) ============
+  async grantTokens(amount, userId) {
+    return this.request("POST", "/v1/dev/grant-tokens", { amount, userId });
+  }
+};
+var RtypeError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "RtypeError";
+    this.code = code;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RtypeClient,
+  RtypeError
+});

package/dist/index.mjs

@@ -0,0 +1,193 @@
+// 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;
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!data.success) {
+        throw new RtypeError(
+          data.error?.code ?? "UNKNOWN_ERROR",
+          data.error?.message ?? "Unknown error"
+        );
+      }
+      return data.data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ============ Auth ============
+  async me() {
+    return this.request("GET", "/v1/auth/me");
+  }
+  // ============ Swarms ============
+  async listSwarms() {
+    return this.request("GET", "/v1/swarms");
+  }
+  async getSwarm(swarmId) {
+    return this.request("GET", `/v1/swarms/${swarmId}`);
+  }
+  async createSwarm(options) {
+    return this.request("POST", "/v1/swarms", options);
+  }
+  async updateSwarm(swarmId, updates) {
+    await this.request("PATCH", `/v1/swarms/${swarmId}`, updates);
+  }
+  async deleteSwarm(swarmId) {
+    await this.request("DELETE", `/v1/swarms/${swarmId}`);
+  }
+  // ============ 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 getAgent(agentId) {
+    return this.request("GET", `/v1/agents/${agentId}`);
+  }
+  async createAgent(options) {
+    return this.request("POST", "/v1/agents", options);
+  }
+  async updateAgent(agentId, updates) {
+    await this.request("PATCH", `/v1/agents/${agentId}`, updates);
+  }
+  async heartbeat(agentId) {
+    await this.request("POST", `/v1/agents/${agentId}/heartbeat`);
+  }
+  async deleteAgent(agentId) {
+    await this.request("DELETE", `/v1/agents/${agentId}`);
+  }
+  // ============ 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 getJob(jobId) {
+    return this.request("GET", `/v1/jobs/${jobId}`);
+  }
+  async createJob(options) {
+    return this.request("POST", "/v1/jobs", options);
+  }
+  async assignJob(jobId, agentId) {
+    await this.request("POST", `/v1/jobs/${jobId}/assign`, { agentId });
+  }
+  async startJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/start`);
+  }
+  async submitJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/submit`);
+  }
+  async approveJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/approve`);
+  }
+  async rejectJob(jobId, reason) {
+    await this.request("POST", `/v1/jobs/${jobId}/reject`, { reason });
+  }
+  async cancelJob(jobId) {
+    await this.request("POST", `/v1/jobs/${jobId}/cancel`);
+  }
+  // ============ 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 getTask(taskId) {
+    return this.request("GET", `/v1/tasks/${taskId}`);
+  }
+  async createTask(options) {
+    return this.request("POST", "/v1/tasks", options);
+  }
+  async claimTask(taskId, agentId) {
+    await this.request("POST", `/v1/tasks/${taskId}/claim`, { agentId });
+  }
+  async completeTask(taskId, response) {
+    return this.request("POST", `/v1/tasks/${taskId}/complete`, { response });
+  }
+  // ============ Wallet ============
+  async getBalance() {
+    return this.request("GET", "/v1/wallet/balance");
+  }
+  async getTransactions(filters) {
+    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();
+    return this.request(
+      "GET",
+      `/v1/wallet/transactions${query ? `?${query}` : ""}`
+    );
+  }
+  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 setMemory(swarmId, key, options) {
+    return this.request("PUT", `/v1/memory/${swarmId}/${key}`, options);
+  }
+  async deleteMemory(swarmId, key) {
+    await this.request("DELETE", `/v1/memory/${swarmId}/${key}`);
+  }
+  async listMemory(swarmId, options) {
+    const params = new URLSearchParams();
+    if (options?.prefix) params.set("prefix", options.prefix);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.request(
+      "GET",
+      `/v1/memory/${swarmId}${query ? `?${query}` : ""}`
+    );
+  }
+  // ============ Topics ============
+  async publish(options) {
+    return this.request("POST", "/v1/topics/publish", options);
+  }
+  async getMessages(swarmId, topic, options) {
+    const params = new URLSearchParams({ swarm: swarmId, topic });
+    if (options?.since) params.set("since", String(options.since));
+    if (options?.limit) params.set("limit", String(options.limit));
+    return this.request("GET", `/v1/topics/messages?${params}`);
+  }
+  async listTopics(swarmId) {
+    return this.request("GET", `/v1/topics/list?swarm=${swarmId}`);
+  }
+  // ============ Dev (development only) ============
+  async grantTokens(amount, userId) {
+    return this.request("POST", "/v1/dev/grant-tokens", { amount, userId });
+  }
+};
+var RtypeError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "RtypeError";
+    this.code = code;
+  }
+};
+export {
+  RtypeClient,
+  RtypeError
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@actwith-ai/sdk",
+  "version": "0.1.0",
+  "description": "Official SDK for Actwith - Structured Memory & Reasoning for Agents",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "actwith",
+    "agents",
+    "ai",
+    "memory",
+    "reasoning",
+    "cognition"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.7.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  }
+}