@taico/client 0.1.0 → 0.2.0

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

@@ -0,0 +1,26 @@
+import { BaseClient } from './base-client.js';
+export class AgentResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new agent */
+    async AgentsController_createAgent(params) {
+        return this.request('POST', '/api/v1/agents', { body: params.body, signal: params?.signal });
+    }
+    /** List agents with optional filtering and pagination */
+    async AgentsController_listAgents(params) {
+        return this.request('GET', '/api/v1/agents', { params: { isActive: params?.isActive, page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Get an agent by slug */
+    async AgentsController_getAgentBySlug(params) {
+        return this.request('GET', `/api/v1/agents/${params.slug}`, { signal: params?.signal });
+    }
+    /** Patch an agent and its linked actor fields */
+    async AgentsController_patchAgent(params) {
+        return this.request('PATCH', `/api/v1/agents/${params.actorId}`, { body: params.body, signal: params?.signal });
+    }
+    /** Delete an agent */
+    async AgentsController_deleteAgent(params) {
+        return this.request('DELETE', `/api/v1/agents/${params.actorId}`, { signal: params?.signal });
+    }
+}

package/dist/src/v2/agent-run-resource.d.ts

@@ -0,0 +1,29 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AgentRunListResponseDto, AgentRunResponseDto, CreateAgentRunDto, UpdateAgentRunDto } from './types.js';
+export declare class AgentrunResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new agent run */
+    AgentRunsController_createAgentRun(params: {
+        body: CreateAgentRunDto;
+        signal?: AbortSignal;
+    }): Promise<AgentRunResponseDto>;
+    /** List agent runs with optional filters */
+    AgentRunsController_listAgentRuns(params?: {
+        actorId?: string;
+        parentTaskId?: string;
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<AgentRunListResponseDto>;
+    /** Get an agent run by ID */
+    AgentRunsController_getAgentRunById(params: {
+        runId: string;
+        signal?: AbortSignal;
+    }): Promise<AgentRunResponseDto>;
+    /** Update an agent run */
+    AgentRunsController_updateAgentRun(params: {
+        runId: string;
+        body: UpdateAgentRunDto;
+        signal?: AbortSignal;
+    }): Promise<AgentRunResponseDto>;
+}

package/dist/src/v2/agent-run-resource.js

@@ -0,0 +1,22 @@
+import { BaseClient } from './base-client.js';
+export class AgentrunResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Create a new agent run */
+    async AgentRunsController_createAgentRun(params) {
+        return this.request('POST', '/api/v1/agent-runs', { body: params.body, signal: params?.signal });
+    }
+    /** List agent runs with optional filters */
+    async AgentRunsController_listAgentRuns(params) {
+        return this.request('GET', '/api/v1/agent-runs', { params: { actorId: params?.actorId, parentTaskId: params?.parentTaskId, page: params?.page, limit: params?.limit }, signal: params?.signal });
+    }
+    /** Get an agent run by ID */
+    async AgentRunsController_getAgentRunById(params) {
+        return this.request('GET', `/api/v1/agent-runs/${params.runId}`, { signal: params?.signal });
+    }
+    /** Update an agent run */
+    async AgentRunsController_updateAgentRun(params) {
+        return this.request('PATCH', `/api/v1/agent-runs/${params.runId}`, { body: params.body, signal: params?.signal });
+    }
+}

package/dist/src/v2/agent-tokens-resource.d.ts

@@ -0,0 +1,22 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { IssueAccessTokenRequestDto, IssueAccessTokenResponseDto, IssuedAccessTokenResponseDto } from './types.js';
+export declare class AgentTokensResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Issue a new access token for an agent */
+    AgentTokensController_issueToken(params: {
+        slug: string;
+        body: IssueAccessTokenRequestDto;
+        signal?: AbortSignal;
+    }): Promise<IssueAccessTokenResponseDto>;
+    /** List all tokens for an agent */
+    AgentTokensController_listTokens(params: {
+        slug: string;
+        signal?: AbortSignal;
+    }): Promise<IssuedAccessTokenResponseDto[]>;
+    /** Revoke an agent token */
+    AgentTokensController_revokeToken(params: {
+        slug: string;
+        tokenId: string;
+        signal?: AbortSignal;
+    }): Promise<IssuedAccessTokenResponseDto>;
+}

package/dist/src/v2/agent-tokens-resource.js

@@ -0,0 +1,18 @@
+import { BaseClient } from './base-client.js';
+export class AgentTokensResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Issue a new access token for an agent */
+    async AgentTokensController_issueToken(params) {
+        return this.request('POST', `/api/v1/agents/${params.slug}/tokens`, { body: params.body, signal: params?.signal });
+    }
+    /** List all tokens for an agent */
+    async AgentTokensController_listTokens(params) {
+        return this.request('GET', `/api/v1/agents/${params.slug}/tokens`, { signal: params?.signal });
+    }
+    /** Revoke an agent token */
+    async AgentTokensController_revokeToken(params) {
+        return this.request('DELETE', `/api/v1/agents/${params.slug}/tokens/${params.tokenId}`, { signal: params?.signal });
+    }
+}

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

@@ -0,0 +1,8 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+export declare class AppResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Health check endpoint */
+    AppController_getHello(params?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+}

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

@@ -0,0 +1,10 @@
+import { BaseClient } from './base-client.js';
+export class AppResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Health check endpoint */
+    async AppController_getHello(params) {
+        return this.request('GET', '/api/v1', { signal: params?.signal });
+    }
+}

package/dist/src/v2/authorization-journeys-resource.d.ts

@@ -0,0 +1,10 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AuthJourneyResponseDto } from './types.js';
+export declare class AuthorizationJourneysResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Get authorization journeys for an MCP server (debug/monitoring) */
+    AuthJourneysController_getAuthJourneys(params: {
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<AuthJourneyResponseDto[]>;
+}

package/dist/src/v2/authorization-journeys-resource.js

@@ -0,0 +1,10 @@
+import { BaseClient } from './base-client.js';
+export class AuthorizationJourneysResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Get authorization journeys for an MCP server (debug/monitoring) */
+    async AuthJourneysController_getAuthJourneys(params) {
+        return this.request('GET', `/api/v1/auth-journeys/servers/${params.serverId}`, { signal: params?.signal });
+    }
+}

package/dist/src/v2/authorization-server-resource.d.ts

@@ -0,0 +1,81 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ClientRegistrationResponseDto, ConsentDecisionDto, GetConsentMetadataResponseDto, IntrospectTokenRequestDto, IntrospectTokenResponseDto, RegisterClientDto, ScopesResponseDto, TokenExchangeRequestDto, TokenExchangeResponseDto, TokenRequestDto, TokenResponseDto } from './types.js';
+export declare class AuthorizationServerResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Register a new OAuth 2.0 client (Dynamic Client Registration) */
+    ClientRegistrationController_registerClient(params: {
+        serverId: string;
+        version: string;
+        body: RegisterClientDto;
+        signal?: AbortSignal;
+    }): Promise<ClientRegistrationResponseDto>;
+    /** Retrieve client registration information */
+    ClientRegistrationController_getClient(params: {
+        clientId: string;
+        signal?: AbortSignal;
+    }): Promise<ClientRegistrationResponseDto>;
+    /** List all registered clients (Admin) */
+    ClientRegistrationController_listClients(params?: {
+        signal?: AbortSignal;
+    }): Promise<ClientRegistrationResponseDto[]>;
+    /** OAuth 2.0 Authorization Endpoint */
+    AuthorizationController_authorize(params: {
+        serverIdentifier: string;
+        version: string;
+        response_type: 'code';
+        scope?: string;
+        client_id: string;
+        code_challenge: string;
+        code_challenge_method: string;
+        redirect_uri: string;
+        state: string;
+        resource?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** OAuth 2.0 Authorization Consent Handler */
+    AuthorizationController_authorizeConsent(params: {
+        serverIdentifier: string;
+        version: string;
+        body: ConsentDecisionDto;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Get metadata for the consent screen from flow ID */
+    AuthorizationController_getConsentMetadata(params: {
+        flowId: string;
+        signal?: AbortSignal;
+    }): Promise<GetConsentMetadataResponseDto>;
+    /** OAuth 2.0 Token Endpoint */
+    AuthorizationController_token(params: {
+        serverIdentifier: string;
+        version: string;
+        body: TokenRequestDto;
+        signal?: AbortSignal;
+    }): Promise<TokenResponseDto>;
+    /** OAuth 2.0 Token Introspection Endpoint */
+    AuthorizationController_introspect(params: {
+        serverIdentifier: string;
+        version: string;
+        body: IntrospectTokenRequestDto;
+        signal?: AbortSignal;
+    }): Promise<IntrospectTokenResponseDto>;
+    /** RFC 8693 Token Exchange Endpoint */
+    AuthorizationController_tokenExchange(params: {
+        serverIdentifier: string;
+        version: string;
+        body: TokenExchangeRequestDto;
+        signal?: AbortSignal;
+    }): Promise<TokenExchangeResponseDto>;
+    /** OAuth 2.0 Callback Endpoint for Downstream Systems */
+    AuthorizationController_callback(params: {
+        code: string;
+        state: string;
+        error?: string;
+        scope?: string;
+        error_description?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** List All Available Scopes */
+    AuthorizationController_getScopes(params?: {
+        signal?: AbortSignal;
+    }): Promise<ScopesResponseDto>;
+}

package/dist/src/v2/authorization-server-resource.js

@@ -0,0 +1,50 @@
+import { BaseClient } from './base-client.js';
+export class AuthorizationServerResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Register a new OAuth 2.0 client (Dynamic Client Registration) */
+    async ClientRegistrationController_registerClient(params) {
+        return this.request('POST', `/api/v1/auth/clients/register/mcp/${params.serverId}/${params.version}`, { body: params.body, signal: params?.signal });
+    }
+    /** Retrieve client registration information */
+    async ClientRegistrationController_getClient(params) {
+        return this.request('GET', `/api/v1/auth/clients/${params.clientId}`, { signal: params?.signal });
+    }
+    /** List all registered clients (Admin) */
+    async ClientRegistrationController_listClients(params) {
+        return this.request('GET', '/api/v1/auth/clients', { signal: params?.signal });
+    }
+    /** OAuth 2.0 Authorization Endpoint */
+    async AuthorizationController_authorize(params) {
+        return this.request('GET', `/api/v1/auth/authorize/mcp/${params.serverIdentifier}/${params.version}`, { params: { response_type: params.response_type, scope: params.scope, client_id: params.client_id, code_challenge: params.code_challenge, code_challenge_method: params.code_challenge_method, redirect_uri: params.redirect_uri, state: params.state, resource: params.resource }, signal: params?.signal });
+    }
+    /** OAuth 2.0 Authorization Consent Handler */
+    async AuthorizationController_authorizeConsent(params) {
+        return this.request('POST', `/api/v1/auth/authorize/mcp/${params.serverIdentifier}/${params.version}`, { body: params.body, signal: params?.signal });
+    }
+    /** Get metadata for the consent screen from flow ID */
+    async AuthorizationController_getConsentMetadata(params) {
+        return this.request('GET', `/api/v1/auth/consent/${params.flowId}`, { signal: params?.signal });
+    }
+    /** OAuth 2.0 Token Endpoint */
+    async AuthorizationController_token(params) {
+        return this.request('POST', `/api/v1/auth/token/mcp/${params.serverIdentifier}/${params.version}`, { body: params.body, signal: params?.signal });
+    }
+    /** OAuth 2.0 Token Introspection Endpoint */
+    async AuthorizationController_introspect(params) {
+        return this.request('POST', `/api/v1/auth/introspect/mcp/${params.serverIdentifier}/${params.version}`, { body: params.body, signal: params?.signal });
+    }
+    /** RFC 8693 Token Exchange Endpoint */
+    async AuthorizationController_tokenExchange(params) {
+        return this.request('POST', `/api/v1/auth/token-exchange/mcp/${params.serverIdentifier}/${params.version}`, { body: params.body, signal: params?.signal });
+    }
+    /** OAuth 2.0 Callback Endpoint for Downstream Systems */
+    async AuthorizationController_callback(params) {
+        return this.request('GET', '/api/v1/auth/callback', { params: { code: params.code, state: params.state, error: params.error, scope: params.scope, error_description: params.error_description }, signal: params?.signal });
+    }
+    /** List All Available Scopes */
+    async AuthorizationController_getScopes(params) {
+        return this.request('GET', '/api/v1/auth/scopes', { signal: params?.signal });
+    }
+}

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

@@ -0,0 +1,26 @@
+export interface ClientConfig {
+    baseUrl: string;
+    /** Bearer token auth: sets Authorization: Bearer <token> */
+    getAccessToken?: () => string | Promise<string>;
+    /** Cookie auth for Node.js: sets Cookie header directly */
+    getCookies?: () => string | Promise<string>;
+    /** Cookie auth for browsers: passed as fetch credentials option (e.g. 'include') */
+    credentials?: 'include' | 'same-origin' | 'omit';
+    headers?: Record<string, string>;
+}
+export declare class BaseClient {
+    protected config: ClientConfig;
+    constructor(config: ClientConfig);
+    private buildAuthHeaders;
+    protected request<T>(method: string, path: string, options?: {
+        params?: Record<string, any>;
+        body?: any;
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    protected streamEvents<T = any>(path: string, options?: {
+        params?: Record<string, any>;
+        headers?: Record<string, string>;
+        signal?: AbortSignal;
+    }): AsyncIterable<T>;
+}

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

@@ -0,0 +1,142 @@
+export class BaseClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    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) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Handle no content responses
+        if (response.status === 204 || response.headers.get('content-length') === '0') {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            return response.json();
+        }
+        return response.text();
+    }
+    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) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        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);
+}