@kaiban/sdk 0.1.1 → 0.1.2

package/dist/lib/resources/CardsClient.d.ts

@@ -1,7 +1,7 @@
+import { Activity, ActivityActor, ActivityCreate, Card } from '../../types/entities';
+import { ListParams, Paginated } from '../../types/responses';
 import { HttpClient } from '../http/HttpClient';
 import { RequestOptions } from '../http/types';
-import { Card, CreateCardInput, UpdateCardInput, ActivityActor } from '../../types/entities';
-import { ListParams, Paginated } from '../../types/responses';
 /**
  * Client for managing cards in the Kaiban platform
  * Cards represent work items, tasks, or tickets within boards
@@ -48,11 +48,11 @@ export declare class CardsClient {
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Card, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Card, void, unknown>;
     /**
      * Get a single card by ID
      *
-     * @param id - The unique identifier of the card
+     * @param cardId - The unique identifier of the card
      * @param options - Optional request configuration
      *
      * @returns The card object
@@ -65,7 +65,7 @@ export declare class CardsClient {
      * console.log(card.title, card.description);
      * ```
      */
-    get(id: string, options?: RequestOptions): Promise<Card>;
+    get(cardId: string, options?: RequestOptions): Promise<Card>;
     /**
      * Create a new card with optional activity tracking
      *
@@ -91,13 +91,13 @@ export declare class CardsClient {
      * }, { create_activity: true });
      * ```
      */
-    create(data: CreateCardInput, options?: RequestOptions & {
+    create(data: Omit<Card, 'id' | 'created_at'>, options?: RequestOptions & {
         create_activity?: boolean;
     }): Promise<Card>;
     /**
      * Update a card's properties
      *
-     * @param id - The unique identifier of the card to update
+     * @param cardId - The unique identifier of the card to update
      * @param data - Card data with fields to update
      * @param options - Optional request configuration
      *
@@ -113,11 +113,11 @@ export declare class CardsClient {
      * });
      * ```
      */
-    update(id: string, data: UpdateCardInput, options?: RequestOptions): Promise<Card>;
+    update(cardId: string, data: Partial<Omit<Card, 'id' | 'created_at' | 'updated_at'>>, options?: RequestOptions): Promise<Card>;
     /**
      * Delete a card by ID
      *
-     * @param id - The unique identifier of the card to delete
+     * @param cardId - The unique identifier of the card to delete
      * @param options - Optional request configuration
      *
      * @returns Promise that resolves when the card is deleted
@@ -129,12 +129,12 @@ export declare class CardsClient {
      * await client.cards.delete('card-123');
      * ```
      */
-    delete(id: string, options?: RequestOptions): Promise<void>;
+    delete(cardId: string, options?: RequestOptions): Promise<void>;
     /**
      * Move a card to a new column and automatically record the activity
      * This is a convenience method that combines update and activity creation
      *
-     * @param id - The unique identifier of the card to move
+     * @param cardId - The unique identifier of the card to move
      * @param newColumnKey - The key of the destination column
      * @param options - Optional request configuration
      * @param options.actor - The actor performing the move (defaults to SDK system actor)
@@ -155,7 +155,134 @@ export declare class CardsClient {
      * });
      * ```
      */
-    moveToColumn(id: string, newColumnKey: string, options?: RequestOptions & {
+    moveToColumn(cardId: string, newColumnKey: string, options?: RequestOptions & {
         actor?: ActivityActor;
     }): Promise<Card>;
+    /**
+     * Create a new activity for a card
+     * Activities track changes, comments, and events on cards
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Activity creation data (card_id is automatically added)
+     * @param data.board_id - The board ID
+     * @param data.team_id - The team ID
+     * @param data.type - The type of activity (e.g., 'card_created', 'card_updated', 'comment')
+     * @param data.description - A description of the activity
+     * @param data.actor - The actor who performed the activity
+     * @param options - Optional request configuration
+     *
+     * @returns The created activity object
+     *
+     * @throws {Error} If the card is not found or creation fails
+     *
+     * @example
+     * ```typescript
+     * const activity = await client.cards.createActivity('card-123', {
+     *   board_id: 'board-456',
+     *   team_id: 'team-789',
+     *   type: 'comment',
+     *   description: 'Added a comment',
+     *   actor: {
+     *     id: 'user-001',
+     *     type: 'user',
+     *     name: 'Jane Doe'
+     *   }
+     * });
+     * ```
+     */
+    createActivity(cardId: string, data: Omit<ActivityCreate, 'card_id'>, options?: RequestOptions): Promise<Activity>;
+    /**
+     * Create multiple activities for a card in a single batch request
+     * This is more efficient than creating activities one by one
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Array of activity creation data (card_id is automatically added to each)
+     * @param options - Optional request configuration
+     *
+     * @returns The batch creation result
+     *
+     * @throws {Error} If the card is not found or batch creation fails
+     *
+     * @example
+     * ```typescript
+     * const activities = await client.cards.createBatchActivities('card-123', [
+     *   {
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'comment',
+     *     description: 'First comment',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   },
+     *   {
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'card_updated',
+     *     description: 'Updated priority',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   }
+     * ]);
+     * ```
+     */
+    createBatchActivities(cardId: string, data: Omit<ActivityCreate, 'card_id'>[], options?: RequestOptions): Promise<Activity>;
+    /**
+     * List activities for a specific card with pagination, filters, and sorting
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page
+     * @param params.after - Cursor to navigate forwards
+     * @param params.before - Cursor to navigate backwards
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of activities
+     *
+     * @example
+     * ```typescript
+     * // Get first page of activities
+     * const result = await client.cards.listActivities('card-123', {
+     *   limit: 20,
+     *   order_by: '-created_at'
+     * });
+     * console.log(result.data); // Array of Activity objects
+     *
+     * // Get next page
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.cards.listActivities('card-123', {
+     *     limit: 20,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    listActivities(cardId: string, params?: ListParams, options?: RequestOptions): Promise<Paginated<Activity>>;
+    /**
+     * Iterate through all activities for a card using async generator
+     * Automatically handles pagination by following next_cursor
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Activity objects
+     *
+     * @example
+     * ```typescript
+     * // Process all activities for a card
+     * for await (const activity of client.cards.listAllActivities('card-123')) {
+     *   console.log(activity.type, activity.description);
+     * }
+     *
+     * // With custom page size and ordering
+     * for await (const activity of client.cards.listAllActivities('card-123', {
+     *   limit: 100,
+     *   order_by: '-created_at'
+     * })) {
+     *   console.log(activity);
+     * }
+     * ```
+     */
+    listAllActivities(cardId: string, params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Activity, void, unknown>;
 }

package/dist/lib/resources/CardsClient.js

@@ -1,3 +1,4 @@
+import { ActivityType } from '../../types/entities';
 // Minimal create-activity payload aligned to backend activity schema
 // Activity types are shared in entities
 /**
@@ -52,16 +53,16 @@ export class CardsClient {
     async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**
      * Get a single card by ID
      *
-     * @param id - The unique identifier of the card
+     * @param cardId - The unique identifier of the card
      * @param options - Optional request configuration
      *
      * @returns The card object
@@ -74,8 +75,8 @@ export class CardsClient {
      * console.log(card.title, card.description);
      * ```
      */
-    get(id, options) {
-        return this.http.get(`/card/${encodeURIComponent(id)}`, options);
+    get(cardId, options) {
+        return this.http.get(`/card/${encodeURIComponent(cardId)}`, options);
     }
     /**
      * Create a new card with optional activity tracking
@@ -105,22 +106,20 @@ export class CardsClient {
     async create(data, options) {
         const card = await this.http.post('/cards', data, options);
         if (options?.create_activity) {
-            const activity = {
+            await this.createActivity(card.id, {
                 board_id: card.board_id,
                 team_id: card.team_id,
-                card_id: card.id,
-                type: 'card_created',
+                type: ActivityType.CARD_CREATED,
                 description: 'Card created',
                 actor: { id: 'sdk', type: 'system', name: 'Kaiban SDK' },
-            };
-            await this.http.post(`/card/${encodeURIComponent(card.id)}/activities`, activity, options);
+            }, options);
         }
         return card;
     }
     /**
      * Update a card's properties
      *
-     * @param id - The unique identifier of the card to update
+     * @param cardId - The unique identifier of the card to update
      * @param data - Card data with fields to update
      * @param options - Optional request configuration
      *
@@ -136,13 +135,13 @@ export class CardsClient {
      * });
      * ```
      */
-    update(id, data, options) {
-        return this.http.put(`/card/${encodeURIComponent(id)}`, data, options);
+    update(cardId, data, options) {
+        return this.http.put(`/card/${encodeURIComponent(cardId)}`, data, options);
     }
     /**
      * Delete a card by ID
      *
-     * @param id - The unique identifier of the card to delete
+     * @param cardId - The unique identifier of the card to delete
      * @param options - Optional request configuration
      *
      * @returns Promise that resolves when the card is deleted
@@ -154,15 +153,15 @@ export class CardsClient {
      * await client.cards.delete('card-123');
      * ```
      */
-    delete(id, options) {
-        return this.http.delete(`/card/${encodeURIComponent(id)}`, options);
+    delete(cardId, options) {
+        return this.http.delete(`/card/${encodeURIComponent(cardId)}`, options);
     }
     // Activity operations moved to ActivitiesClient
     /**
      * Move a card to a new column and automatically record the activity
      * This is a convenience method that combines update and activity creation
      *
-     * @param id - The unique identifier of the card to move
+     * @param cardId - The unique identifier of the card to move
      * @param newColumnKey - The key of the destination column
      * @param options - Optional request configuration
      * @param options.actor - The actor performing the move (defaults to SDK system actor)
@@ -183,20 +182,167 @@ export class CardsClient {
      * });
      * ```
      */
-    async moveToColumn(id, newColumnKey, options) {
-        const current = await this.get(id, options);
+    async moveToColumn(cardId, newColumnKey, options) {
+        const current = await this.get(cardId, options);
         const oldColumn = current.column_key;
-        const updated = await this.update(id, { column_key: newColumnKey }, options);
-        const activity = {
+        const updated = await this.update(cardId, { column_key: newColumnKey }, options);
+        await this.createActivity(cardId, {
             board_id: updated.board_id,
             team_id: updated.team_id,
-            card_id: updated.id,
-            type: 'card_column_changed',
+            type: ActivityType.CARD_COLUMN_CHANGED,
             description: `Moved card from ${oldColumn} to ${newColumnKey}`,
             actor: options?.actor || { id: 'sdk', type: 'system', name: 'Kaiban SDK' },
             changes: [{ field: 'column_key', old_value: oldColumn, new_value: newColumnKey }],
-        };
-        await this.http.post(`/card/${encodeURIComponent(updated.id)}/activities`, activity, options);
+        }, options);
         return updated;
     }
+    /**
+     * Create a new activity for a card
+     * Activities track changes, comments, and events on cards
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Activity creation data (card_id is automatically added)
+     * @param data.board_id - The board ID
+     * @param data.team_id - The team ID
+     * @param data.type - The type of activity (e.g., 'card_created', 'card_updated', 'comment')
+     * @param data.description - A description of the activity
+     * @param data.actor - The actor who performed the activity
+     * @param options - Optional request configuration
+     *
+     * @returns The created activity object
+     *
+     * @throws {Error} If the card is not found or creation fails
+     *
+     * @example
+     * ```typescript
+     * const activity = await client.cards.createActivity('card-123', {
+     *   board_id: 'board-456',
+     *   team_id: 'team-789',
+     *   type: 'comment',
+     *   description: 'Added a comment',
+     *   actor: {
+     *     id: 'user-001',
+     *     type: 'user',
+     *     name: 'Jane Doe'
+     *   }
+     * });
+     * ```
+     */
+    createActivity(cardId, data, options) {
+        return this.http.post(`/card/${encodeURIComponent(cardId)}/activities`, {
+            ...data,
+            card_id: cardId,
+        }, options);
+    }
+    /**
+     * Create multiple activities for a card in a single batch request
+     * This is more efficient than creating activities one by one
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Array of activity creation data (card_id is automatically added to each)
+     * @param options - Optional request configuration
+     *
+     * @returns The batch creation result
+     *
+     * @throws {Error} If the card is not found or batch creation fails
+     *
+     * @example
+     * ```typescript
+     * const activities = await client.cards.createBatchActivities('card-123', [
+     *   {
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'comment',
+     *     description: 'First comment',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   },
+     *   {
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'card_updated',
+     *     description: 'Updated priority',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   }
+     * ]);
+     * ```
+     */
+    createBatchActivities(cardId, data, options) {
+        return this.http.post(`/activities:batch`, {
+            items: data.map((item) => ({
+                ...item,
+                card_id: cardId,
+            })),
+        }, options);
+    }
+    /**
+     * List activities for a specific card with pagination, filters, and sorting
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page
+     * @param params.after - Cursor to navigate forwards
+     * @param params.before - Cursor to navigate backwards
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of activities
+     *
+     * @example
+     * ```typescript
+     * // Get first page of activities
+     * const result = await client.cards.listActivities('card-123', {
+     *   limit: 20,
+     *   order_by: '-created_at'
+     * });
+     * console.log(result.data); // Array of Activity objects
+     *
+     * // Get next page
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.cards.listActivities('card-123', {
+     *     limit: 20,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    listActivities(cardId, params, options) {
+        return this.http.list(`/card/${encodeURIComponent(cardId)}/activities`, params, options);
+    }
+    /**
+     * Iterate through all activities for a card using async generator
+     * Automatically handles pagination by following next_cursor
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Activity objects
+     *
+     * @example
+     * ```typescript
+     * // Process all activities for a card
+     * for await (const activity of client.cards.listAllActivities('card-123')) {
+     *   console.log(activity.type, activity.description);
+     * }
+     *
+     * // With custom page size and ordering
+     * for await (const activity of client.cards.listAllActivities('card-123', {
+     *   limit: 100,
+     *   order_by: '-created_at'
+     * })) {
+     *   console.log(activity);
+     * }
+     * ```
+     */
+    async *listAllActivities(cardId, params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.listActivities(cardId, { ...(params || {}), after: cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.pagination.next_cursor;
+        } while (cursor);
+    }
 }

package/dist/lib/resources/ExternalChannelsClient.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/HttpClient';
-import { RequestOptions } from '../http/types';
 import { ExternalChannel } from '../../types/entities';
 import { ListParams, Paginated } from '../../types/responses';
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
 /**
  * Client for managing external channels in the Kaiban platform
  * External channels represent integrations with external communication platforms
@@ -44,7 +44,7 @@ export declare class ExternalChannelsClient {
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<ExternalChannel, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<ExternalChannel, void, unknown>;
     /**
      * Get a single external channel by ID
      *

package/dist/lib/resources/ExternalChannelsClient.js

@@ -46,10 +46,10 @@ export class ExternalChannelsClient {
     async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**

package/dist/lib/resources/ResourcesClient.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/HttpClient';
-import { RequestOptions } from '../http/types';
 import { Resource } from '../../types/entities';
 import { ListParams, Paginated } from '../../types/responses';
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
 /**
  * Client for managing resources in the Kaiban platform
  * Resources can include documents, files, or other materials
@@ -44,7 +44,7 @@ export declare class ResourcesClient {
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Resource, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Resource, void, unknown>;
     /**
      * Get a single resource by ID
      *
@@ -62,31 +62,4 @@ export declare class ResourcesClient {
      * ```
      */
     get(id: string, options?: RequestOptions): Promise<Resource>;
-    /**
-     * Publish a resource to make it available
-     *
-     * @param params - Publish parameters
-     * @param params.resource_id - The unique identifier of the resource to publish
-     * @param params.userId - The ID of the user publishing the resource
-     * @param options - Optional request configuration
-     *
-     * @returns A response with a success message
-     *
-     * @throws {Error} If the resource is not found or publish fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.resources.publish({
-     *   resource_id: 'resource-123',
-     *   userId: 'user-456'
-     * });
-     * console.log(result.message);
-     * ```
-     */
-    publish(params: {
-        resource_id: string;
-        userId: string;
-    }, options?: RequestOptions): Promise<{
-        message: string;
-    }>;
 }

package/dist/lib/resources/ResourcesClient.js

@@ -46,10 +46,10 @@ export class ResourcesClient {
     async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**
@@ -71,28 +71,4 @@ export class ResourcesClient {
     get(id, options) {
         return this.http.get(`/resource/${encodeURIComponent(id)}`, options);
     }
-    /**
-     * Publish a resource to make it available
-     *
-     * @param params - Publish parameters
-     * @param params.resource_id - The unique identifier of the resource to publish
-     * @param params.userId - The ID of the user publishing the resource
-     * @param options - Optional request configuration
-     *
-     * @returns A response with a success message
-     *
-     * @throws {Error} If the resource is not found or publish fails
-     *
-     * @example
-     * ```typescript
-     * const result = await client.resources.publish({
-     *   resource_id: 'resource-123',
-     *   userId: 'user-456'
-     * });
-     * console.log(result.message);
-     * ```
-     */
-    publish(params, options) {
-        return this.http.post(`/resource/${encodeURIComponent(params.resource_id)}/publish`, { userId: params.userId }, options);
-    }
 }

package/dist/lib/resources/TeamsClient.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/HttpClient';
-import { RequestOptions } from '../http/types';
 import { Team } from '../../types/entities';
 import { ListParams, Paginated } from '../../types/responses';
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
 /**
  * Client for managing teams in the Kaiban platform
  * @category Resources
@@ -62,7 +62,7 @@ export declare class TeamsClient {
      * }
      * ```
      */
-    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Team, void, unknown>;
+    listAll(params?: Omit<ListParams, 'after' | 'before'>, options?: RequestOptions): AsyncGenerator<Team, void, unknown>;
     /**
      * Get a single team by ID
      *

package/dist/lib/resources/TeamsClient.js

@@ -64,10 +64,10 @@ export class TeamsClient {
     async *listAll(params, options) {
         let cursor = undefined;
         do {
-            const page = await this.list({ ...(params || {}), cursor }, options);
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
             for (const item of page.data)
                 yield item;
-            cursor = page.meta.next_cursor;
+            cursor = page.pagination.next_cursor;
         } while (cursor);
     }
     /**

package/dist/types/a2a-data-parts.d.ts

@@ -1,4 +1,4 @@
-import { ActivityCreate } from './entities';
+import { Activity } from './entities';
 export declare const A2ADataPartType: {
     readonly TOOL_CALL_START: "tool_call_start";
     readonly TOOL_CALL_ARGS: "tool_call_args";
@@ -56,7 +56,7 @@ export type UserThreadFeedbackPart = A2ADataPartBase<'user_thread_feedback', {
     feedback: string;
 }>;
 export type KaibanActivityPart = A2ADataPartBase<'kaiban_activity', {
-    activity: ActivityCreate;
+    activity: Activity;
 }>;
 export type AgentStatusPart = A2ADataPartBase<'agent_status', {
     status: string;