@taico/client 0.1.0 → 0.2.1

package/dist/src/v2/base-client.js

@@ -0,0 +1,190 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function getErrorMessageFromBody(body) {
+    if (!isRecord(body)) {
+        return undefined;
+    }
+    const detail = body.detail;
+    if (typeof detail === 'string' && detail.length > 0) {
+        return detail;
+    }
+    const message = body.message;
+    if (typeof message === 'string' && message.length > 0) {
+        return message;
+    }
+    const title = body.title;
+    if (typeof title === 'string' && title.length > 0) {
+        return title;
+    }
+    const errorDescription = body.error_description;
+    if (typeof errorDescription === 'string' && errorDescription.length > 0) {
+        return errorDescription;
+    }
+    return undefined;
+}
+export class ApiError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(response, body) {
+        const message = getErrorMessageFromBody(body) ?? `HTTP ${response.status}: ${response.statusText}`;
+        super(message);
+        this.name = 'ApiError';
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = body;
+    }
+}
+export class BaseClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async parseResponseBody(response) {
+        if (response.status === 204 || response.headers.get('content-length') === '0') {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            try {
+                return await response.json();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const text = await response.text();
+        return text.length > 0 ? text : undefined;
+    }
+    async buildAuthHeaders() {
+        const headers = {};
+        if (this.config.getAccessToken) {
+            const token = await this.config.getAccessToken();
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        if (this.config.getCookies) {
+            headers['Cookie'] = await this.config.getCookies();
+        }
+        return headers;
+    }
+    async request(method, path, options) {
+        const url = new URL(path, this.config.baseUrl);
+        // Add query parameters
+        if (options?.params) {
+            for (const [key, value] of Object.entries(options.params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            }
+        }
+        // Build headers (filter out undefined values)
+        const headers = {};
+        // Add config headers
+        if (this.config.headers) {
+            for (const [key, value] of Object.entries(this.config.headers)) {
+                if (value !== undefined && value !== null) {
+                    headers[key] = String(value);
+                }
+            }
+        }
+        // Add request-specific headers
+        if (options?.headers) {
+            for (const [key, value] of Object.entries(options.headers)) {
+                if (value !== undefined && value !== null) {
+                    headers[key] = String(value);
+                }
+            }
+        }
+        // Add auth headers
+        Object.assign(headers, await this.buildAuthHeaders());
+        // Add content type for body requests
+        if (options?.body && !headers['Content-Type']) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(url.toString(), {
+            method,
+            headers,
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            signal: options?.signal,
+            credentials: this.config.credentials,
+        });
+        if (!response.ok) {
+            const errorBody = await this.parseResponseBody(response);
+            throw new ApiError(response, errorBody);
+        }
+        return await this.parseResponseBody(response);
+    }
+    async *streamEvents(path, options) {
+        const url = new URL(path, this.config.baseUrl);
+        if (options?.params) {
+            for (const [key, value] of Object.entries(options.params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            }
+        }
+        // Build headers (filter out undefined values)
+        const headers = {
+            'Accept': 'text/event-stream',
+        };
+        // Add config headers
+        if (this.config.headers) {
+            for (const [key, value] of Object.entries(this.config.headers)) {
+                if (value !== undefined && value !== null) {
+                    headers[key] = String(value);
+                }
+            }
+        }
+        // Add request-specific headers
+        if (options?.headers) {
+            for (const [key, value] of Object.entries(options.headers)) {
+                if (value !== undefined && value !== null) {
+                    headers[key] = String(value);
+                }
+            }
+        }
+        // Add auth headers
+        Object.assign(headers, await this.buildAuthHeaders());
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers,
+            signal: options?.signal,
+            credentials: this.config.credentials,
+        });
+        if (!response.ok) {
+            const errorBody = await this.parseResponseBody(response);
+            throw new ApiError(response, errorBody);
+        }
+        if (!response.body) {
+            throw new Error('Response body is null');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        try {
+                            yield JSON.parse(data);
+                        }
+                        catch {
+                            yield data;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/src/v2/chat-providers-resource.d.ts

@@ -0,0 +1,39 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ChatProviderResponseDto, CreateChatProviderDto, SetActiveChatProviderDto, UpdateChatProviderDto } from './types.js';
+export declare class ChatProvidersResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new chat provider */
+    ChatProvidersController_createChatProvider(params: {
+        body: CreateChatProviderDto;
+        signal?: AbortSignal;
+    }): Promise<ChatProviderResponseDto>;
+    /** List all chat providers */
+    ChatProvidersController_listChatProviders(params?: {
+        signal?: AbortSignal;
+    }): Promise<ChatProviderResponseDto[]>;
+    /** Get chat provider by ID */
+    ChatProvidersController_getChatProvider(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<ChatProviderResponseDto>;
+    /** Update a chat provider */
+    ChatProvidersController_updateChatProvider(params: {
+        id: string;
+        body: UpdateChatProviderDto;
+        signal?: AbortSignal;
+    }): Promise<ChatProviderResponseDto>;
+    /** Delete a chat provider */
+    ChatProvidersController_deleteChatProvider(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Set the active chat provider */
+    ChatProvidersController_setActiveChatProvider(params: {
+        body: SetActiveChatProviderDto;
+        signal?: AbortSignal;
+    }): Promise<ChatProviderResponseDto>;
+    /** Deactivate the active chat provider */
+    ChatProvidersController_deactivateActiveChatProvider(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/src/v2/chat-providers-resource.js

@@ -0,0 +1,34 @@
+import { BaseClient } from './base-client.js';
+export class ChatProvidersResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new chat provider */
+    async ChatProvidersController_createChatProvider(params) {
+        return this.request('POST', '/api/v1/chat-providers', { body: params.body, signal: params?.signal });
+    }
+    /** List all chat providers */
+    async ChatProvidersController_listChatProviders(params) {
+        return this.request('GET', '/api/v1/chat-providers', { signal: params?.signal });
+    }
+    /** Get chat provider by ID */
+    async ChatProvidersController_getChatProvider(params) {
+        return this.request('GET', `/api/v1/chat-providers/${params.id}`, { signal: params?.signal });
+    }
+    /** Update a chat provider */
+    async ChatProvidersController_updateChatProvider(params) {
+        return this.request('PATCH', `/api/v1/chat-providers/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete a chat provider */
+    async ChatProvidersController_deleteChatProvider(params) {
+        return this.request('DELETE', `/api/v1/chat-providers/${params.id}`, { signal: params?.signal });
+    }
+    /** Set the active chat provider */
+    async ChatProvidersController_setActiveChatProvider(params) {
+        return this.request('POST', '/api/v1/chat-providers/set-active', { body: params.body, signal: params?.signal });
+    }
+    /** Deactivate the active chat provider */
+    async ChatProvidersController_deactivateActiveChatProvider(params) {
+        return this.request('POST', '/api/v1/chat-providers/deactivate', { signal: params?.signal });
+    }
+}

package/dist/src/v2/client.d.ts

@@ -0,0 +1,52 @@
+import { ClientConfig } from './base-client.js';
+import { AppResource } from './app-resource.js';
+import { MetaResource } from './meta-resource.js';
+import { MetaProjectsResource } from './meta---projects-resource.js';
+import { AuthorizationServerResource } from './authorization-server-resource.js';
+import { WebAuthenticationResource } from './web-authentication-resource.js';
+import { AuthorizationJourneysResource } from './authorization-journeys-resource.js';
+import { ToolsResource } from './tools-resource.js';
+import { JwksResource } from './jwks-resource.js';
+import { ActorsResource } from './actors-resource.js';
+import { TaskResource } from './task-resource.js';
+import { AgentrunResource } from './agent-run-resource.js';
+import { ThreadsResource } from './threads-resource.js';
+import { AgentResource } from './agent-resource.js';
+import { AgentTokensResource } from './agent-tokens-resource.js';
+import { AgentExecutionTokensResource } from './agent-execution-tokens-resource.js';
+import { ChatProvidersResource } from './chat-providers-resource.js';
+import { SecretsResource } from './secrets-resource.js';
+import { ContextResource } from './context-resource.js';
+import { ExecutionsV2Resource } from './executions-v2-resource.js';
+import { TaskBlueprintsResource } from './task-blueprints-resource.js';
+import { ScheduledTasksResource } from './scheduled-tasks-resource.js';
+import { DiscoveryResource } from './discovery-resource.js';
+import { ExecutionsResource } from './executions-resource.js';
+import { SearchResource } from './search-resource.js';
+export declare class ApiClient {
+    readonly app: AppResource;
+    readonly meta: MetaResource;
+    readonly metaProjects: MetaProjectsResource;
+    readonly authorizationServer: AuthorizationServerResource;
+    readonly webAuthentication: WebAuthenticationResource;
+    readonly authorizationJourneys: AuthorizationJourneysResource;
+    readonly tools: ToolsResource;
+    readonly jwks: JwksResource;
+    readonly actors: ActorsResource;
+    readonly task: TaskResource;
+    readonly agentrun: AgentrunResource;
+    readonly threads: ThreadsResource;
+    readonly agent: AgentResource;
+    readonly agentTokens: AgentTokensResource;
+    readonly agentExecutionTokens: AgentExecutionTokensResource;
+    readonly chatProviders: ChatProvidersResource;
+    readonly secrets: SecretsResource;
+    readonly context: ContextResource;
+    readonly executionsV2: ExecutionsV2Resource;
+    readonly taskBlueprints: TaskBlueprintsResource;
+    readonly scheduledTasks: ScheduledTasksResource;
+    readonly discovery: DiscoveryResource;
+    readonly executions: ExecutionsResource;
+    readonly search: SearchResource;
+    constructor(config: ClientConfig);
+}

package/dist/src/v2/client.js

@@ -0,0 +1,76 @@
+import { AppResource } from './app-resource.js';
+import { MetaResource } from './meta-resource.js';
+import { MetaProjectsResource } from './meta---projects-resource.js';
+import { AuthorizationServerResource } from './authorization-server-resource.js';
+import { WebAuthenticationResource } from './web-authentication-resource.js';
+import { AuthorizationJourneysResource } from './authorization-journeys-resource.js';
+import { ToolsResource } from './tools-resource.js';
+import { JwksResource } from './jwks-resource.js';
+import { ActorsResource } from './actors-resource.js';
+import { TaskResource } from './task-resource.js';
+import { AgentrunResource } from './agent-run-resource.js';
+import { ThreadsResource } from './threads-resource.js';
+import { AgentResource } from './agent-resource.js';
+import { AgentTokensResource } from './agent-tokens-resource.js';
+import { AgentExecutionTokensResource } from './agent-execution-tokens-resource.js';
+import { ChatProvidersResource } from './chat-providers-resource.js';
+import { SecretsResource } from './secrets-resource.js';
+import { ContextResource } from './context-resource.js';
+import { ExecutionsV2Resource } from './executions-v2-resource.js';
+import { TaskBlueprintsResource } from './task-blueprints-resource.js';
+import { ScheduledTasksResource } from './scheduled-tasks-resource.js';
+import { DiscoveryResource } from './discovery-resource.js';
+import { ExecutionsResource } from './executions-resource.js';
+import { SearchResource } from './search-resource.js';
+export class ApiClient {
+    app;
+    meta;
+    metaProjects;
+    authorizationServer;
+    webAuthentication;
+    authorizationJourneys;
+    tools;
+    jwks;
+    actors;
+    task;
+    agentrun;
+    threads;
+    agent;
+    agentTokens;
+    agentExecutionTokens;
+    chatProviders;
+    secrets;
+    context;
+    executionsV2;
+    taskBlueprints;
+    scheduledTasks;
+    discovery;
+    executions;
+    search;
+    constructor(config) {
+        this.app = new AppResource(config);
+        this.meta = new MetaResource(config);
+        this.metaProjects = new MetaProjectsResource(config);
+        this.authorizationServer = new AuthorizationServerResource(config);
+        this.webAuthentication = new WebAuthenticationResource(config);
+        this.authorizationJourneys = new AuthorizationJourneysResource(config);
+        this.tools = new ToolsResource(config);
+        this.jwks = new JwksResource(config);
+        this.actors = new ActorsResource(config);
+        this.task = new TaskResource(config);
+        this.agentrun = new AgentrunResource(config);
+        this.threads = new ThreadsResource(config);
+        this.agent = new AgentResource(config);
+        this.agentTokens = new AgentTokensResource(config);
+        this.agentExecutionTokens = new AgentExecutionTokensResource(config);
+        this.chatProviders = new ChatProvidersResource(config);
+        this.secrets = new SecretsResource(config);
+        this.context = new ContextResource(config);
+        this.executionsV2 = new ExecutionsV2Resource(config);
+        this.taskBlueprints = new TaskBlueprintsResource(config);
+        this.scheduledTasks = new ScheduledTasksResource(config);
+        this.discovery = new DiscoveryResource(config);
+        this.executions = new ExecutionsResource(config);
+        this.search = new SearchResource(config);
+    }
+}

package/dist/src/v2/context-resource.d.ts

@@ -0,0 +1,93 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AppendBlockDto, BlockListResponseDto, BlockResponseDto, BlockSearchResultDto, BlockTreeResponseDto, CreateBlockDto, CreateTagDto, MoveBlockDto, ReorderBlockDto, UpdateBlockDto } from './types.js';
+export declare class ContextResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new wiki page */
+    ContextController_createBlock(params: {
+        body: CreateBlockDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** List wiki pages without content */
+    ContextController_listBlocks(params?: {
+        tag?: string;
+        signal?: AbortSignal;
+    }): Promise<BlockListResponseDto>;
+    /** Search blocks by query string */
+    ContextController_searchBlocks(params: {
+        query: string;
+        limit?: number;
+        threshold?: number;
+        signal?: AbortSignal;
+    }): Promise<BlockSearchResultDto[]>;
+    /** Get page hierarchy tree */
+    ContextController_getBlockTree(params?: {
+        signal?: AbortSignal;
+    }): Promise<BlockTreeResponseDto[]>;
+    /** Fetch a wiki page by ID */
+    ContextController_getBlock(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Update an existing wiki page */
+    ContextController_updateBlock(params: {
+        id: string;
+        body: UpdateBlockDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Delete a wiki page */
+    ContextController_deleteBlock(params: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Append content to an existing wiki page */
+    ContextController_appendToBlock(params: {
+        id: string;
+        body: AppendBlockDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Reorder a page within siblings */
+    ContextController_reorderBlock(params: {
+        id: string;
+        body: ReorderBlockDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Move page to different parent */
+    ContextController_moveBlock(params: {
+        id: string;
+        body: MoveBlockDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Add a tag to a wiki page */
+    ContextController_addTagToBlock(params: {
+        id: string;
+        body: CreateTagDto;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    /** Remove a tag from a wiki page */
+    ContextController_removeTagFromBlock(params: {
+        id: string;
+        tagId: string;
+        signal?: AbortSignal;
+    }): Promise<BlockResponseDto>;
+    ContextController_handleMcp_get(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_post(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_put(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_delete(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_patch(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_options(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    ContextController_handleMcp_head(params?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/src/v2/context-resource.js

@@ -0,0 +1,75 @@
+import { BaseClient } from './base-client.js';
+export class ContextResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new wiki page */
+    async ContextController_createBlock(params) {
+        return this.request('POST', '/api/v1/context/blocks', { body: params.body, signal: params?.signal });
+    }
+    /** List wiki pages without content */
+    async ContextController_listBlocks(params) {
+        return this.request('GET', '/api/v1/context/blocks', { params: { tag: params?.tag }, signal: params?.signal });
+    }
+    /** Search blocks by query string */
+    async ContextController_searchBlocks(params) {
+        return this.request('GET', '/api/v1/context/blocks/search/query', { params: { query: params.query, limit: params.limit, threshold: params.threshold }, signal: params?.signal });
+    }
+    /** Get page hierarchy tree */
+    async ContextController_getBlockTree(params) {
+        return this.request('GET', '/api/v1/context/blocks/tree', { signal: params?.signal });
+    }
+    /** Fetch a wiki page by ID */
+    async ContextController_getBlock(params) {
+        return this.request('GET', `/api/v1/context/blocks/${params.id}`, { signal: params?.signal });
+    }
+    /** Update an existing wiki page */
+    async ContextController_updateBlock(params) {
+        return this.request('PATCH', `/api/v1/context/blocks/${params.id}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete a wiki page */
+    async ContextController_deleteBlock(params) {
+        return this.request('DELETE', `/api/v1/context/blocks/${params.id}`, { signal: params?.signal });
+    }
+    /** Append content to an existing wiki page */
+    async ContextController_appendToBlock(params) {
+        return this.request('POST', `/api/v1/context/blocks/${params.id}/append`, { body: params.body, signal: params?.signal });
+    }
+    /** Reorder a page within siblings */
+    async ContextController_reorderBlock(params) {
+        return this.request('PATCH', `/api/v1/context/blocks/${params.id}/reorder`, { body: params.body, signal: params?.signal });
+    }
+    /** Move page to different parent */
+    async ContextController_moveBlock(params) {
+        return this.request('PATCH', `/api/v1/context/blocks/${params.id}/move`, { body: params.body, signal: params?.signal });
+    }
+    /** Add a tag to a wiki page */
+    async ContextController_addTagToBlock(params) {
+        return this.request('POST', `/api/v1/context/blocks/${params.id}/tags`, { body: params.body, signal: params?.signal });
+    }
+    /** Remove a tag from a wiki page */
+    async ContextController_removeTagFromBlock(params) {
+        return this.request('DELETE', `/api/v1/context/blocks/${params.id}/tags/${params.tagId}`, { signal: params?.signal });
+    }
+    async ContextController_handleMcp_get(params) {
+        return this.request('GET', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_post(params) {
+        return this.request('POST', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_put(params) {
+        return this.request('PUT', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_delete(params) {
+        return this.request('DELETE', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_patch(params) {
+        return this.request('PATCH', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_options(params) {
+        return this.request('OPTIONS', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+    async ContextController_handleMcp_head(params) {
+        return this.request('HEAD', '/api/v1/context/blocks/mcp', { signal: params?.signal });
+    }
+}

package/dist/src/v2/discovery-resource.d.ts

@@ -0,0 +1,21 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AuthorizationServerMetadataDto, ProtectedResourceMetadataResponseDto } from './types.js';
+export declare class DiscoveryResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Get the authorization server issuer URL */
+    DiscoveryController_getIssuer(params?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        issuer?: string;
+    }>;
+    /** Expose OAuth 2.0 Authorization Server metadata for a registered MCP server version */
+    DiscoveryController_getAuthorizationServerMetadata(params: {
+        mcpServerId: string;
+        version: string;
+        signal?: AbortSignal;
+    }): Promise<AuthorizationServerMetadataDto>;
+    DiscoveryController_all(params: {
+        path: string[];
+        signal?: AbortSignal;
+    }): Promise<ProtectedResourceMetadataResponseDto>;
+}

package/dist/src/v2/discovery-resource.js

@@ -0,0 +1,17 @@
+import { BaseClient } from './base-client.js';
+export class DiscoveryResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Get the authorization server issuer URL */
+    async DiscoveryController_getIssuer(params) {
+        return this.request('GET', '/.well-known/oauth-authorization-server/mcp/issuer', { signal: params?.signal });
+    }
+    /** Expose OAuth 2.0 Authorization Server metadata for a registered MCP server version */
+    async DiscoveryController_getAuthorizationServerMetadata(params) {
+        return this.request('GET', `/.well-known/oauth-authorization-server/mcp/${params.mcpServerId}/${params.version}`, { signal: params?.signal });
+    }
+    async DiscoveryController_all(params) {
+        return this.request('GET', `/.well-known/oauth-protected-resource/${params.path}`, { signal: params?.signal });
+    }
+}

package/dist/src/v2/executions-resource.d.ts

@@ -0,0 +1,14 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ExecutionListResponseDto } from './types.js';
+export declare class ExecutionsResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** List task executions with optional filtering and pagination */
+    ExecutionsController_listExecutions(params?: {
+        status?: 'READY' | 'CLAIMED' | 'RUNNING' | 'STOP_REQUESTED' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'STALE';
+        agentActorId?: string;
+        taskId?: string;
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ExecutionListResponseDto>;
+}

package/dist/src/v2/executions-resource.js

@@ -0,0 +1,10 @@
+import { BaseClient } from './base-client.js';
+export class ExecutionsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** List task executions with optional filtering and pagination */
+    async ExecutionsController_listExecutions(params) {
+        return this.request('GET', '/api/v1/executions', { params: { status: params?.status, agentActorId: params?.agentActorId, taskId: params?.taskId, page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+}

package/dist/src/v2/executions-v2-resource.d.ts

@@ -0,0 +1,28 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ActiveTaskExecutionResponseDto, StopActiveTaskExecutionDto, TaskExecutionHistoryResponseDto, TaskExecutionQueueEntryResponseDto } from './types.js';
+export declare class ExecutionsV2Resource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** List the current task execution work queue */
+    TaskExecutionQueueController_listQueue(params?: {
+        signal?: AbortSignal;
+    }): Promise<TaskExecutionQueueEntryResponseDto[]>;
+    /** Claim a specific task from the execution queue */
+    TaskExecutionQueueController_claimTask(params: {
+        taskId: string;
+        signal?: AbortSignal;
+    }): Promise<ActiveTaskExecutionResponseDto>;
+    /** List active task executions */
+    ActiveTaskExecutionController_listActiveExecutions(params?: {
+        signal?: AbortSignal;
+    }): Promise<ActiveTaskExecutionResponseDto[]>;
+    /** Stop an active task execution and move it to history */
+    ActiveTaskExecutionController_stopTaskExecution(params: {
+        executionId: string;
+        body: StopActiveTaskExecutionDto;
+        signal?: AbortSignal;
+    }): Promise<TaskExecutionHistoryResponseDto>;
+    /** List task execution history */
+    TaskExecutionHistoryController_listHistory(params?: {
+        signal?: AbortSignal;
+    }): Promise<TaskExecutionHistoryResponseDto[]>;
+}