@kaiban/sdk 0.1.1

package/dist/lib/http/errors.js

@@ -0,0 +1,126 @@
+export class HttpError extends Error {
+    constructor(message, status, url, body) {
+        super(message);
+        this.name = 'HttpError';
+        this.status = status;
+        this.url = url;
+        this.body = body;
+    }
+}
+export class TimeoutError extends Error {
+    constructor(message = 'Request timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+export class AbortedError extends Error {
+    constructor(message = 'Request was aborted') {
+        super(message);
+        this.name = 'AbortedError';
+    }
+}
+export class ApiError extends Error {
+    constructor(shape) {
+        super(shape.message);
+        this.name = 'ApiError';
+        this.code = shape.code;
+        this.details = shape.details;
+    }
+}
+export class BadRequestError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'BadRequestError';
+    }
+}
+export class ValidationError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ValidationError';
+    }
+}
+export class UnauthorizedError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'UnauthorizedError';
+    }
+}
+export class ForbiddenError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ForbiddenError';
+    }
+}
+export class NotFoundError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'NotFoundError';
+    }
+}
+export class ConflictError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ConflictError';
+    }
+}
+export class RateLimitError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'RateLimitError';
+    }
+}
+export class UnavailableError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'UnavailableError';
+    }
+}
+export class ServerError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ServerError';
+    }
+}
+// Map HTTP response status and body to human-friendly SDK errors
+export function mapHttpToSdkError(status, body) {
+    const shape = normalizeBody(body);
+    switch (status) {
+        case 400:
+            return new BadRequestError(shape);
+        case 401:
+            return new UnauthorizedError(shape);
+        case 403:
+            return new ForbiddenError(shape);
+        case 404:
+            return new NotFoundError(shape);
+        case 409:
+            return new ConflictError(shape);
+        case 422:
+            return new ValidationError(shape);
+        case 429:
+            return new RateLimitError(shape);
+        case 502:
+        case 503:
+        case 504:
+            return new UnavailableError(shape);
+        case 500:
+        default:
+            return new ServerError(shape);
+    }
+}
+function normalizeBody(body) {
+    if (!body)
+        return { message: 'Unknown error' };
+    if (typeof body === 'string')
+        return { message: body };
+    if (typeof body === 'object') {
+        const anyBody = body;
+        const code = anyBody['code'] || anyBody['error'];
+        const message = anyBody['message'] ||
+            anyBody['error_description'] ||
+            'Request failed';
+        const details = anyBody['details'];
+        return { code, message, details };
+    }
+    return { message: 'Request failed' };
+}

package/dist/lib/http/types.d.ts

@@ -0,0 +1,40 @@
+export interface KaibanClientConfig {
+    tenant: string;
+    token: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    retry?: {
+        maxAttempts?: number;
+        backoffMs?: number;
+        maxBackoffMs?: number;
+        jitter?: boolean;
+        retryOn?: number[];
+        retryMethods?: string[];
+    };
+    fetch?: typeof fetch;
+    onRequest?: (info: {
+        method: string;
+        url: string;
+        init: RequestInit;
+    }) => void;
+    onResponse?: (info: {
+        status: number;
+        url: string;
+        response: Response;
+    }) => void;
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    query?: Record<string, unknown>;
+    timeoutMs?: number;
+    /** Optional per-request retry overrides; merged with client-level defaults. */
+    retry?: {
+        maxAttempts?: number;
+        backoffMs?: number;
+        maxBackoffMs?: number;
+        jitter?: boolean;
+        retryOn?: number[];
+        retryMethods?: string[];
+    };
+}

package/dist/lib/http/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,89 @@
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
+import { CardActivity, ActivityCreate } from '../../types/entities';
+import { ListParams, Paginated } from '../../types/responses';
+/**
+ * Client for managing card activities
+ * Activities track changes, comments, and events on cards
+ * @category Resources
+ */
+export declare class ActivitiesClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List activities for a specific card
+     * Supports pagination, filtering, and sorting through query parameters
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for the next page of results
+     * @param params.limit - Number of items per page
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of activities
+     *
+     * @example
+     * ```typescript
+     * // Get activities for a card
+     * const result = await client.activities.list('card-123', {
+     *   limit: 20,
+     *   order_by: ['created_at']
+     * });
+     *
+     * console.log(result.items); // Array of CardActivity objects
+     * ```
+     */
+    list(cardId: string, params?: ListParams, options?: RequestOptions): Promise<Paginated<CardActivity>>;
+    /**
+     * Iterate through all activities for a card using async generator
+     * Automatically handles pagination by following next_page_token
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters (excluding cursor)
+     * @param options - Optional request configuration
+     *
+     * @yields Individual CardActivity objects
+     *
+     * @example
+     * ```typescript
+     * // Process all activities for a card
+     * for await (const activity of client.activities.listAll('card-123')) {
+     *   console.log(activity.type, activity.description);
+     * }
+     * ```
+     */
+    listAll(cardId: string, params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<CardActivity, void, unknown>;
+    /**
+     * Create a new activity for a card
+     * Activities can track various events such as comments, status changes, or custom events
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Activity creation data
+     * @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.activities.create('card-123', {
+     *   board_id: 'board-456',
+     *   team_id: 'team-789',
+     *   card_id: 'card-123',
+     *   type: 'comment',
+     *   description: 'Added a comment',
+     *   actor: {
+     *     id: 'user-001',
+     *     type: 'user',
+     *     name: 'Jane Doe'
+     *   }
+     * });
+     * ```
+     */
+    create(cardId: string, data: ActivityCreate, options?: RequestOptions): Promise<CardActivity>;
+}

package/dist/lib/resources/ActivitiesClient.js

@@ -0,0 +1,99 @@
+// Reuse ActivityCreate from shared types
+/**
+ * Client for managing card activities
+ * Activities track changes, comments, and events on cards
+ * @category Resources
+ */
+export class ActivitiesClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List activities for a specific card
+     * Supports pagination, filtering, and sorting through query parameters
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for the next page of results
+     * @param params.limit - Number of items per page
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of activities
+     *
+     * @example
+     * ```typescript
+     * // Get activities for a card
+     * const result = await client.activities.list('card-123', {
+     *   limit: 20,
+     *   order_by: ['created_at']
+     * });
+     *
+     * console.log(result.items); // Array of CardActivity objects
+     * ```
+     */
+    list(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_page_token
+     *
+     * @param cardId - The unique identifier of the card
+     * @param params - Optional query parameters (excluding cursor)
+     * @param options - Optional request configuration
+     *
+     * @yields Individual CardActivity objects
+     *
+     * @example
+     * ```typescript
+     * // Process all activities for a card
+     * for await (const activity of client.activities.listAll('card-123')) {
+     *   console.log(activity.type, activity.description);
+     * }
+     * ```
+     */
+    async *listAll(cardId, params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.list(cardId, { ...(params || {}), cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.meta.next_cursor;
+        } while (cursor);
+    }
+    /**
+     * Create a new activity for a card
+     * Activities can track various events such as comments, status changes, or custom events
+     *
+     * @param cardId - The unique identifier of the card
+     * @param data - Activity creation data
+     * @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.activities.create('card-123', {
+     *   board_id: 'board-456',
+     *   team_id: 'team-789',
+     *   card_id: 'card-123',
+     *   type: 'comment',
+     *   description: 'Added a comment',
+     *   actor: {
+     *     id: 'user-001',
+     *     type: 'user',
+     *     name: 'Jane Doe'
+     *   }
+     * });
+     * ```
+     */
+    create(cardId, data, options) {
+        return this.http.post(`/card/${encodeURIComponent(cardId)}/activities`, data, options);
+    }
+}

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

@@ -0,0 +1,121 @@
+import { HttpClient } from '../http/HttpClient';
+import { RequestOptions } from '../http/types';
+import { Agent, AgentFeedback } from '../../types/entities';
+import { ListParams, Paginated } from '../../types/responses';
+/**
+ * Client for managing agents in the Kaiban platform
+ * @category Resources
+ */
+export declare class AgentsClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List agents with pagination, filters, and sorting
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for the next page of results
+     * @param params.limit - Number of items per page
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of agents
+     *
+     * @example
+     * ```typescript
+     * // List first page of agents
+     * const result = await client.agents.list({ limit: 10 });
+     * console.log(result.items); // Array of Agent objects
+     *
+     * // Get next page using cursor
+     * if (result.next_page_token) {
+     *   const nextPage = await client.agents.list({
+     *     cursor: result.next_page_token
+     *   });
+     * }
+     * ```
+     */
+    list(params?: ListParams, options?: RequestOptions): Promise<Paginated<Agent>>;
+    /**
+     * Iterate through all agents using async generator
+     * Automatically handles pagination by following next_page_token
+     *
+     * @param params - Optional query parameters (excluding cursor)
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Agent objects
+     *
+     * @example
+     * ```typescript
+     * // Iterate through all agents
+     * for await (const agent of client.agents.listAll()) {
+     *   console.log(agent.id, agent.name);
+     * }
+     *
+     * // With filtering
+     * for await (const agent of client.agents.listAll({
+     *   order_by: ['created_at']
+     * })) {
+     *   console.log(agent);
+     * }
+     * ```
+     */
+    listAll(params?: Omit<ListParams, 'cursor'>, options?: RequestOptions): AsyncGenerator<Agent, void, unknown>;
+    /**
+     * Get a single agent by ID
+     *
+     * @param id - The unique identifier of the agent
+     * @param options - Optional request configuration
+     *
+     * @returns The agent object
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.get('agent-123');
+     * console.log(agent.name, agent.status);
+     * ```
+     */
+    get(id: string, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Update an agent's properties
+     *
+     * @param id - The unique identifier of the agent to update
+     * @param data - Partial agent data with fields to update
+     * @param options - Optional request configuration
+     *
+     * @returns The updated agent object
+     *
+     * @throws {Error} If the agent is not found or update fails
+     *
+     * @example
+     * ```typescript
+     * const updatedAgent = await client.agents.update('agent-123', {
+     *   name: 'New Name',
+     *   status: 'active'
+     * });
+     * ```
+     */
+    update(id: string, data: Partial<Agent>, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Create feedback for an agent
+     *
+     * @param id - The unique identifier of the agent
+     * @param feedback - Feedback data to submit
+     * @param options - Optional request configuration
+     *
+     * @returns Promise that resolves when feedback is created
+     *
+     * @throws {Error} If the agent is not found or feedback creation fails
+     *
+     * @example
+     * ```typescript
+     * await client.agents.createFeedback('agent-123', {
+     *   rating: 5,
+     *   comment: 'Excellent performance',
+     *   tags: ['helpful', 'accurate']
+     * });
+     * ```
+     */
+    createFeedback(id: string, feedback: AgentFeedback, options?: RequestOptions): Promise<void>;
+}

package/dist/lib/resources/AgentsClient.js

@@ -0,0 +1,134 @@
+/**
+ * Client for managing agents in the Kaiban platform
+ * @category Resources
+ */
+export class AgentsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List agents with pagination, filters, and sorting
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for the next page of results
+     * @param params.limit - Number of items per page
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of agents
+     *
+     * @example
+     * ```typescript
+     * // List first page of agents
+     * const result = await client.agents.list({ limit: 10 });
+     * console.log(result.items); // Array of Agent objects
+     *
+     * // Get next page using cursor
+     * if (result.next_page_token) {
+     *   const nextPage = await client.agents.list({
+     *     cursor: result.next_page_token
+     *   });
+     * }
+     * ```
+     */
+    list(params, options) {
+        return this.http.list('/agents', params, options);
+    }
+    /**
+     * Iterate through all agents using async generator
+     * Automatically handles pagination by following next_page_token
+     *
+     * @param params - Optional query parameters (excluding cursor)
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Agent objects
+     *
+     * @example
+     * ```typescript
+     * // Iterate through all agents
+     * for await (const agent of client.agents.listAll()) {
+     *   console.log(agent.id, agent.name);
+     * }
+     *
+     * // With filtering
+     * for await (const agent of client.agents.listAll({
+     *   order_by: ['created_at']
+     * })) {
+     *   console.log(agent);
+     * }
+     * ```
+     */
+    async *listAll(params, options) {
+        let pageToken = undefined;
+        do {
+            const page = await this.list({ ...(params || {}), cursor: pageToken }, options);
+            for (const item of page.data)
+                yield item;
+            pageToken = page.meta.next_cursor;
+        } while (pageToken);
+    }
+    /**
+     * Get a single agent by ID
+     *
+     * @param id - The unique identifier of the agent
+     * @param options - Optional request configuration
+     *
+     * @returns The agent object
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.get('agent-123');
+     * console.log(agent.name, agent.status);
+     * ```
+     */
+    get(id, options) {
+        return this.http.get(`/agent/${encodeURIComponent(id)}`, options);
+    }
+    /**
+     * Update an agent's properties
+     *
+     * @param id - The unique identifier of the agent to update
+     * @param data - Partial agent data with fields to update
+     * @param options - Optional request configuration
+     *
+     * @returns The updated agent object
+     *
+     * @throws {Error} If the agent is not found or update fails
+     *
+     * @example
+     * ```typescript
+     * const updatedAgent = await client.agents.update('agent-123', {
+     *   name: 'New Name',
+     *   status: 'active'
+     * });
+     * ```
+     */
+    update(id, data, options) {
+        return this.http.put(`/agent/${encodeURIComponent(id)}`, data, options);
+    }
+    /**
+     * Create feedback for an agent
+     *
+     * @param id - The unique identifier of the agent
+     * @param feedback - Feedback data to submit
+     * @param options - Optional request configuration
+     *
+     * @returns Promise that resolves when feedback is created
+     *
+     * @throws {Error} If the agent is not found or feedback creation fails
+     *
+     * @example
+     * ```typescript
+     * await client.agents.createFeedback('agent-123', {
+     *   rating: 5,
+     *   comment: 'Excellent performance',
+     *   tags: ['helpful', 'accurate']
+     * });
+     * ```
+     */
+    createFeedback(id, feedback, options) {
+        return this.http.post(`/agent/${encodeURIComponent(id)}/feedback`, feedback, options);
+    }
+}