@kaiban/sdk 0.1.1

package/dist/lib/resources/TeamsClient.js

@@ -0,0 +1,92 @@
+/**
+ * Client for managing teams in the Kaiban platform
+ * @category Resources
+ */
+export class TeamsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List teams with pagination, filters, and sorting
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for pagination (from previous/next response)
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.order_by - Fields to sort by. Use - prefix for descending order
+     * @param params.filters - Filter parameters (e.g., { status: 'active' })
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of teams
+     *
+     * @example
+     * ```typescript
+     * // Basic pagination
+     * const result = await client.teams.list({ limit: 20 });
+     * console.log(result.data); // Current page items
+     * console.log(result.pagination.next_cursor); // Use for next page
+     *
+     * // With sorting
+     * const sorted = await client.teams.list({
+     *   order_by: '-created_at',
+     *   limit: 50
+     * });
+     *
+     * // With filters
+     * const filtered = await client.teams.list({
+     *   filters: { status: 'active' }
+     * });
+     *
+     * // Next page
+     * const nextPage = await client.teams.list({
+     *   cursor: result.pagination.next_cursor
+     * });
+     * ```
+     */
+    list(params, options) {
+        return this.http.list('/teams', params, options);
+    }
+    /**
+     * Iterate through all teams 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 Team objects
+     *
+     * @example
+     * ```typescript
+     * for await (const team of client.teams.listAll()) {
+     *   console.log(team.id, team.name);
+     * }
+     * ```
+     */
+    async *listAll(params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.list({ ...(params || {}), cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.meta.next_cursor;
+        } while (cursor);
+    }
+    /**
+     * Get a single team by ID
+     *
+     * @param id - The unique identifier of the team
+     * @param options - Optional request configuration
+     *
+     * @returns The team object
+     *
+     * @throws {Error} If the team is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * const team = await client.teams.get('team-123');
+     * console.log(team.name);
+     * ```
+     */
+    get(id, options) {
+        return this.http.get(`/team/${encodeURIComponent(id)}`, options);
+    }
+}

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

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

package/dist/lib/resources/__tests__/ActivitiesClient.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('ActivitiesClient', () => {
+    it('lists activities and iterates', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'act1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'act2' }] }),
+        ]);
+        const page = await client.activities.list('c1', { page_size: 1 });
+        expect(page.items[0].id).toBe('act1');
+        const all = [];
+        for await (const a of client.activities.listAll('c1', { page_size: 1 }))
+            all.push(a);
+        expect(all.map((x) => x.id)).toEqual(['act1', 'act2']);
+    });
+    it('creates an activity', async () => {
+        const client = makeClient([jsonOk({ id: 'act1' })]);
+        const res = await client.activities.create('c1', {
+            board_id: 'b',
+            card_id: 'c1',
+            team_id: 't',
+            type: 'card_created',
+            description: 'd',
+            actor: { id: 'x', type: 'system', name: 'n' },
+        });
+        expect(res.id).toBe('act1');
+    });
+});

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

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

package/dist/lib/resources/__tests__/AgentsClient.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('AgentsClient', () => {
+    it('lists agents with pagination', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'a1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'a2' }], next_page_token: undefined }),
+        ]);
+        const page1 = await client.agents.list({ page_size: 1 });
+        expect(page1.items[0].id).toBe('a1');
+        expect(page1.next_page_token).toBe('n1');
+        const items = [];
+        for await (const a of client.agents.listAll({ page_size: 1 }))
+            items.push(a);
+        expect(items.map((x) => x.id)).toEqual(['a1', 'a2']);
+    });
+    it('gets an agent', async () => {
+        const client = makeClient([jsonOk({ id: 'a1', name: 'Agent' })]);
+        const agent = await client.agents.get('a1');
+        expect(agent.id).toBe('a1');
+    });
+    it('updates an agent', async () => {
+        const client = makeClient([jsonOk({ id: 'a1', name: 'New' })]);
+        const updated = await client.agents.update('a1', { name: 'New' });
+        expect(updated.name).toBe('New');
+    });
+    it('creates feedback', async () => {
+        const client = makeClient([jsonOk({})]);
+        await client.agents.createFeedback('a1', { rating: 5 });
+        expect(true).toBe(true);
+    });
+});

package/dist/lib/resources/__tests__/BenchmarkExecutionsClient.test.d.ts

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

package/dist/lib/resources/__tests__/BenchmarkExecutionsClient.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('BenchmarkExecutionsClient', () => {
+    it('lists executions and iterates', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'e1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'e2' }] }),
+        ]);
+        const page = await client.benchmarkExecutions.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('e1');
+        const all = [];
+        for await (const e of client.benchmarkExecutions.listAll({ page_size: 1 }))
+            all.push(e);
+        expect(all.map((x) => x.id)).toEqual(['e1', 'e2']);
+    });
+    it('CRUD execution', async () => {
+        const client = makeClient([jsonOk({ id: 'e1' }), jsonOk({ id: 'e1' }), jsonOk({})]);
+        const c = await client.benchmarkExecutions.create({ benchmark_id: 'b', agent_id: 'a' });
+        expect(c.id).toBe('e1');
+        const g = await client.benchmarkExecutions.get('e1');
+        expect(g.id).toBe('e1');
+        await client.benchmarkExecutions.delete('e1');
+        expect(true).toBe(true);
+    });
+    it('test cases: create, list, get, update, delete', async () => {
+        const client = makeClient([
+            jsonOk({ id: 't1' }),
+            jsonOk({ items: [{ id: 't1' }] }),
+            jsonOk({ id: 't1' }),
+            jsonOk({ id: 't1', test_index: 1 }),
+            jsonOk({}),
+        ]);
+        const tc = await client.benchmarkExecutions.createTestCase({
+            execution_id: 'e1',
+            body: { input: 'i', agent_output: 'o', execution_time: 1 },
+        });
+        expect(tc.id).toBe('t1');
+        const list = await client.benchmarkExecutions.listTestCases({ execution_id: 'e1' });
+        expect(list.items[0].id).toBe('t1');
+        const g = await client.benchmarkExecutions.getTestCase({
+            execution_id: 'e1',
+            test_case_id: 't1',
+        });
+        expect(g.id).toBe('t1');
+        const u = await client.benchmarkExecutions.updateTestCase({
+            execution_id: 'e1',
+            test_case_id: 't1',
+            body: { test_index: 1 },
+        });
+        expect(u.test_index).toBe(1);
+        await client.benchmarkExecutions.deleteTestCase({ execution_id: 'e1', test_case_id: 't1' });
+        expect(true).toBe(true);
+    });
+});

package/dist/lib/resources/__tests__/BenchmarksClient.test.d.ts

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

package/dist/lib/resources/__tests__/BenchmarksClient.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('BenchmarksClient', () => {
+    it('lists and iterates benchmarks', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'bm1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'bm2' }] }),
+        ]);
+        const page = await client.benchmarks.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('bm1');
+        const all = [];
+        for await (const b of client.benchmarks.listAll({ page_size: 1 }))
+            all.push(b);
+        expect(all.map((x) => x.id)).toEqual(['bm1', 'bm2']);
+    });
+    it('gets, creates and updates benchmark', async () => {
+        const client = makeClient([
+            jsonOk({ id: 'bm1' }),
+            jsonOk({ id: 'bm2' }),
+            jsonOk({ id: 'bm2', name: 'n' }),
+        ]);
+        const g = await client.benchmarks.get('bm1');
+        expect(g.id).toBe('bm1');
+        const c = await client.benchmarks.create({ name: 'x' });
+        expect(c.id).toBe('bm2');
+        const u = await client.benchmarks.update('bm2', { name: 'n' });
+        expect(u.name).toBe('n');
+    });
+    it('executes a benchmark', async () => {
+        const client = makeClient([jsonOk({ message: 'ok' })]);
+        const res = await client.benchmarks.execute({
+            benchmark_id: 'bm1',
+            body: { agentConfig: { id: 'a' } },
+        });
+        expect(res.message).toBe('ok');
+    });
+});

package/dist/lib/resources/__tests__/BoardsClient.test.d.ts

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

package/dist/lib/resources/__tests__/BoardsClient.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('BoardsClient', () => {
+    it('lists boards and iterates', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'b1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'b2' }] }),
+        ]);
+        const page = await client.boards.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('b1');
+        const all = [];
+        for await (const b of client.boards.listAll({ page_size: 1 }))
+            all.push(b);
+        expect(all.map((x) => x.id)).toEqual(['b1', 'b2']);
+    });
+    it('gets a board', async () => {
+        const client = makeClient([jsonOk({ id: 'b1' })]);
+        const board = await client.boards.get('b1');
+        expect(board.id).toBe('b1');
+    });
+});

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

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

package/dist/lib/resources/__tests__/CardsClient.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('CardsClient', () => {
+    it('lists and iterates cards', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'c1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'c2' }] }),
+        ]);
+        const page = await client.cards.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('c1');
+        const all = [];
+        for await (const c of client.cards.listAll({ page_size: 1 }))
+            all.push(c);
+        expect(all.map((x) => x.id)).toEqual(['c1', 'c2']);
+    });
+    it('gets a card', async () => {
+        const client = makeClient([
+            jsonOk({ id: 'c1', column_key: 'todo', board_id: 'b', team_id: 't' }),
+        ]);
+        const card = await client.cards.get('c1');
+        expect(card.id).toBe('c1');
+    });
+    it('creates a card', async () => {
+        const client = makeClient([jsonOk({ id: 'c1' })]);
+        const card = await client.cards.create({
+            team_id: 't',
+            board_id: 'b',
+            owner_id: 'u',
+            agent_id: 'a',
+            title: 'x',
+            status: 'todo',
+            column_key: 'col',
+            priority: 'p',
+            member_ids: [],
+        });
+        expect(card.id).toBe('c1');
+    });
+    it('updates a card', async () => {
+        const client = makeClient([jsonOk({ id: 'c1', title: 'y' })]);
+        const res = await client.cards.update('c1', { title: 'y' });
+        expect(res.title).toBe('y');
+    });
+    it('deletes a card', async () => {
+        const client = makeClient([jsonOk({})]);
+        await client.cards.delete('c1');
+        expect(true).toBe(true);
+    });
+    it('moves to column and creates activity', async () => {
+        const client = makeClient([
+            jsonOk({ id: 'c1', column_key: 'todo', board_id: 'b', team_id: 't' }), // get current
+            jsonOk({ id: 'c1', column_key: 'done', board_id: 'b', team_id: 't' }), // update
+            jsonOk({}), // post activity
+        ]);
+        const res = await client.cards.moveToColumn('c1', 'done');
+        expect(res.column_key).toBe('done');
+    });
+});

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

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

package/dist/lib/resources/__tests__/ExternalChannelsClient.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('ExternalChannelsClient', () => {
+    it('lists and iterates external channels', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'ec1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'ec2' }] }),
+        ]);
+        const page = await client.externalChannels.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('ec1');
+        const all = [];
+        for await (const e of client.externalChannels.listAll({ page_size: 1 }))
+            all.push(e);
+        expect(all.map((x) => x.id)).toEqual(['ec1', 'ec2']);
+    });
+    it('gets an external channel', async () => {
+        const client = makeClient([jsonOk({ id: 'ec1' })]);
+        const ch = await client.externalChannels.get('ec1');
+        expect(ch.id).toBe('ec1');
+    });
+});

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

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

package/dist/lib/resources/__tests__/ResourcesClient.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('ResourcesClient', () => {
+    it('lists and iterates resources', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'r1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'r2' }] }),
+        ]);
+        const page = await client.resources.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('r1');
+        const all = [];
+        for await (const r of client.resources.listAll({ page_size: 1 }))
+            all.push(r);
+        expect(all.map((x) => x.id)).toEqual(['r1', 'r2']);
+    });
+    it('gets and publishes a resource', async () => {
+        const client = makeClient([jsonOk({ id: 'r1' }), jsonOk({ message: 'ok' })]);
+        const g = await client.resources.get('r1');
+        expect(g.id).toBe('r1');
+        const p = await client.resources.publish({ resource_id: 'r1', userId: 'u1' });
+        expect(p.message).toBe('ok');
+    });
+});

package/dist/lib/resources/__tests__/SupervisorFeedbackClient.test.d.ts

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

package/dist/lib/resources/__tests__/SupervisorFeedbackClient.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('SupervisorFeedbackClient', () => {
+    it('lists feedback by agent and iterates', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'sf1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'sf2' }] }),
+        ]);
+        const page = await client.supervisorFeedback.listByAgent({ agent_id: 'a1', page_size: 1 });
+        expect(page.items[0].id).toBe('sf1');
+        const all = [];
+        for await (const s of client.supervisorFeedback.listAllByAgent({
+            agent_id: 'a1',
+            page_size: 1,
+        }))
+            all.push(s);
+        expect(all.map((x) => x.id)).toEqual(['sf1', 'sf2']);
+    });
+});

package/dist/lib/resources/__tests__/TeamMembersClient.test.d.ts

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

package/dist/lib/resources/__tests__/TeamMembersClient.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('TeamMembersClient', () => {
+    it('lists and iterates team members', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 'tm1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 'tm2' }] }),
+        ]);
+        const page = await client.teamMembers.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('tm1');
+        const all = [];
+        for await (const t of client.teamMembers.listAll({ page_size: 1 }))
+            all.push(t);
+        expect(all.map((x) => x.id)).toEqual(['tm1', 'tm2']);
+    });
+    it('gets a team member', async () => {
+        const client = makeClient([jsonOk({ id: 'tm1' })]);
+        const tm = await client.teamMembers.get('tm1');
+        expect(tm.id).toBe('tm1');
+    });
+});

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

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

package/dist/lib/resources/__tests__/TeamsClient.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { createKaibanClient } from '../../client';
+import { createMockFetch, jsonOk } from '../../../test/helpers/mockFetch';
+function makeClient(responses) {
+    const fetch = createMockFetch(responses);
+    return createKaibanClient({ tenant: 't', token: 'x', fetch });
+}
+describe('TeamsClient', () => {
+    it('lists and iterates teams', async () => {
+        const client = makeClient([
+            jsonOk({ items: [{ id: 't1' }], next_page_token: 'n1' }),
+            jsonOk({ items: [{ id: 't2' }] }),
+        ]);
+        const page = await client.teams.list({ page_size: 1 });
+        expect(page.items[0].id).toBe('t1');
+        const all = [];
+        for await (const t of client.teams.listAll({ page_size: 1 }))
+            all.push(t);
+        expect(all.map((x) => x.id)).toEqual(['t1', 't2']);
+    });
+    it('gets a team', async () => {
+        const client = makeClient([jsonOk({ id: 't1' })]);
+        const team = await client.teams.get('t1');
+        expect(team.id).toBe('t1');
+    });
+});

package/dist/test/helpers/mockFetch.d.ts

@@ -0,0 +1,8 @@
+export type MockResponse = {
+    status: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+};
+export declare function createMockFetch(sequence: Array<MockResponse | ((input: RequestInfo | URL, init?: RequestInit) => MockResponse | Promise<MockResponse>)>): typeof fetch;
+export declare function jsonOk(body: unknown, headers?: Record<string, string>): MockResponse;
+export declare function jsonError(status: number, body: unknown): MockResponse;

package/dist/test/helpers/mockFetch.js

@@ -0,0 +1,22 @@
+export function createMockFetch(sequence) {
+    let callIndex = 0;
+    const fetchImpl = async (input, init) => {
+        const item = sequence[Math.min(callIndex, sequence.length - 1)];
+        callIndex++;
+        const resolved = typeof item === 'function' ? await item(input, init) : item;
+        const headers = new Headers(resolved.headers || { 'content-type': 'application/json' });
+        const body = resolved.body === undefined || resolved.body === null
+            ? null
+            : headers.get('content-type')?.includes('application/json')
+                ? JSON.stringify(resolved.body)
+                : String(resolved.body);
+        return new Response(body, { status: resolved.status, headers });
+    };
+    return fetchImpl;
+}
+export function jsonOk(body, headers) {
+    return { status: 200, headers: { 'content-type': 'application/json', ...(headers || {}) }, body };
+}
+export function jsonError(status, body) {
+    return { status, headers: { 'content-type': 'application/json' }, body };
+}

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

@@ -0,0 +1,64 @@
+import { ActivityCreate } from './entities';
+export declare const A2ADataPartType: {
+    readonly TOOL_CALL_START: "tool_call_start";
+    readonly TOOL_CALL_ARGS: "tool_call_args";
+    readonly TOOL_CALL_END: "tool_call_end";
+    readonly TOOL_CALL_RESULT: "tool_call_result";
+    readonly TASK_INFO_MESSAGE: "task_info_message";
+    readonly TASK_STEP_OUTPUT: "task_step_output";
+    readonly USER_EVALUATION: "user_evaluation";
+    readonly USER_THREAD_FEEDBACK: "user_thread_feedback";
+    readonly KAIBAN_ACTIVITY: "kaiban_activity";
+    readonly AGENT_STATUS: "agent_status";
+};
+export type A2ADataPartType = (typeof A2ADataPartType)[keyof typeof A2ADataPartType];
+export interface A2ADataPartBase<T extends A2ADataPartType, P extends object> {
+    data: {
+        type: T;
+    } & P;
+}
+export type ToolCallStartPart = A2ADataPartBase<'tool_call_start', {
+    toolName: string;
+}>;
+export type ToolCallArgsPart = A2ADataPartBase<'tool_call_args', {
+    toolName: string;
+    args: Record<string, unknown>;
+}>;
+export type ToolCallEndPart = A2ADataPartBase<'tool_call_end', {
+    toolName: string;
+}>;
+export type ToolCallResultPart = A2ADataPartBase<'tool_call_result', {
+    toolName: string;
+    result: Record<string, unknown>;
+}>;
+export type TaskInfoMessagePart = A2ADataPartBase<'task_info_message', {
+    message: string;
+}>;
+export type TaskStepOutputPart = A2ADataPartBase<'task_step_output', {
+    stepName: string;
+    output?: Record<string, unknown>;
+    costs?: Array<{
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        reasoningTokens: number;
+        cachedInputTokens: number;
+    }>;
+    duration: number;
+}>;
+export type UserEvaluationPart = A2ADataPartBase<'user_evaluation', {
+    messageId: string;
+    evaluation: 'good' | 'bad';
+}>;
+export type UserThreadFeedbackPart = A2ADataPartBase<'user_thread_feedback', {
+    wasHelpful: boolean;
+    feedback: string;
+}>;
+export type KaibanActivityPart = A2ADataPartBase<'kaiban_activity', {
+    activity: ActivityCreate;
+}>;
+export type AgentStatusPart = A2ADataPartBase<'agent_status', {
+    status: string;
+}>;
+export type AnyA2ADataPart = ToolCallStartPart | ToolCallArgsPart | ToolCallEndPart | ToolCallResultPart | TaskInfoMessagePart | TaskStepOutputPart | UserEvaluationPart | UserThreadFeedbackPart | KaibanActivityPart | AgentStatusPart;

package/dist/types/a2a-data-parts.js

@@ -0,0 +1,13 @@
+// A2A Data Part type identifiers
+export const A2ADataPartType = {
+    TOOL_CALL_START: 'tool_call_start',
+    TOOL_CALL_ARGS: 'tool_call_args',
+    TOOL_CALL_END: 'tool_call_end',
+    TOOL_CALL_RESULT: 'tool_call_result',
+    TASK_INFO_MESSAGE: 'task_info_message',
+    TASK_STEP_OUTPUT: 'task_step_output',
+    USER_EVALUATION: 'user_evaluation',
+    USER_THREAD_FEEDBACK: 'user_thread_feedback',
+    KAIBAN_ACTIVITY: 'kaiban_activity',
+    AGENT_STATUS: 'agent_status',
+};