@taico/client 0.0.1

package/dist/src/client/models/TokenExchangeRequestDto.d.ts

@@ -0,0 +1,36 @@
+export type TokenExchangeRequestDto = {
+    /**
+     * Grant type for token exchange as defined in RFC 8693
+     */
+    grant_type: TokenExchangeRequestDto.grant_type;
+    /**
+     * The access token that represents the identity of the party on behalf of whom the request is being made
+     */
+    subject_token: string;
+    /**
+     * Type identifier for the subject_token as defined in RFC 8693
+     */
+    subject_token_type: TokenExchangeRequestDto.subject_token_type;
+    /**
+     * Resource server URL that the client wants to access with the exchanged token
+     */
+    resource: string;
+    /**
+     * Optional space-delimited list of scopes for the exchanged token
+     */
+    scope?: string;
+};
+export declare namespace TokenExchangeRequestDto {
+    /**
+     * Grant type for token exchange as defined in RFC 8693
+     */
+    enum grant_type {
+        URN_IETF_PARAMS_OAUTH_GRANT_TYPE_TOKEN_EXCHANGE = "urn:ietf:params:oauth:grant-type:token-exchange"
+    }
+    /**
+     * Type identifier for the subject_token as defined in RFC 8693
+     */
+    enum subject_token_type {
+        URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ACCESS_TOKEN = "urn:ietf:params:oauth:token-type:access_token"
+    }
+}

package/dist/src/client/models/TokenExchangeRequestDto.js

@@ -0,0 +1,17 @@
+export var TokenExchangeRequestDto;
+(function (TokenExchangeRequestDto) {
+    /**
+     * Grant type for token exchange as defined in RFC 8693
+     */
+    let grant_type;
+    (function (grant_type) {
+        grant_type["URN_IETF_PARAMS_OAUTH_GRANT_TYPE_TOKEN_EXCHANGE"] = "urn:ietf:params:oauth:grant-type:token-exchange";
+    })(grant_type = TokenExchangeRequestDto.grant_type || (TokenExchangeRequestDto.grant_type = {}));
+    /**
+     * Type identifier for the subject_token as defined in RFC 8693
+     */
+    let subject_token_type;
+    (function (subject_token_type) {
+        subject_token_type["URN_IETF_PARAMS_OAUTH_TOKEN_TYPE_ACCESS_TOKEN"] = "urn:ietf:params:oauth:token-type:access_token";
+    })(subject_token_type = TokenExchangeRequestDto.subject_token_type || (TokenExchangeRequestDto.subject_token_type = {}));
+})(TokenExchangeRequestDto || (TokenExchangeRequestDto = {}));

package/dist/src/client/models/TokenExchangeResponseDto.d.ts

@@ -0,0 +1,22 @@
+export type TokenExchangeResponseDto = {
+    /**
+     * The newly issued access token after successful exchange
+     */
+    access_token: string;
+    /**
+     * Type identifier for the issued token as defined in RFC 8693
+     */
+    issued_token_type: string;
+    /**
+     * Type of token issued, always Bearer for MCP clients
+     */
+    token_type: string;
+    /**
+     * Lifetime of the access token in seconds
+     */
+    expires_in: number;
+    /**
+     * Space-delimited list of scopes granted for the exchanged token
+     */
+    scope: string;
+};

package/dist/src/client/models/TokenExchangeResponseDto.js

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

package/dist/src/client/models/TokenRequestDto.d.ts

@@ -0,0 +1,43 @@
+export type TokenRequestDto = {
+    /**
+     * Grant type that determines which parameters must be supplied
+     */
+    grant_type: TokenRequestDto.grant_type;
+    /**
+     * Client identifier issued during dynamic registration
+     */
+    client_id: string;
+    /**
+     * Authorization code that was issued by the /authorize endpoint
+     */
+    code?: string;
+    /**
+     * Redirect URI used during authorization (required when code is present)
+     */
+    redirect_uri?: string;
+    /**
+     * PKCE code verifier used to validate the authorization code exchange
+     */
+    code_verifier?: string;
+    /**
+     * Refresh token issued earlier by the authorization server
+     */
+    refresh_token?: string;
+    /**
+     * Optional list of scopes to narrow when refreshing a token (space-delimited)
+     */
+    scope?: string;
+    /**
+     * Optional resource indicator (RFC 8707) - identifies the target resource server
+     */
+    resource?: string;
+};
+export declare namespace TokenRequestDto {
+    /**
+     * Grant type that determines which parameters must be supplied
+     */
+    enum grant_type {
+        AUTHORIZATION_CODE = "authorization_code",
+        REFRESH_TOKEN = "refresh_token"
+    }
+}

package/dist/src/client/models/TokenRequestDto.js

@@ -0,0 +1,11 @@
+export var TokenRequestDto;
+(function (TokenRequestDto) {
+    /**
+     * Grant type that determines which parameters must be supplied
+     */
+    let grant_type;
+    (function (grant_type) {
+        grant_type["AUTHORIZATION_CODE"] = "authorization_code";
+        grant_type["REFRESH_TOKEN"] = "refresh_token";
+    })(grant_type = TokenRequestDto.grant_type || (TokenRequestDto.grant_type = {}));
+})(TokenRequestDto || (TokenRequestDto = {}));

package/dist/src/client/models/TokenResponseDto.d.ts

@@ -0,0 +1,30 @@
+export type TokenResponseDto = {
+    /**
+     * Opaque access token used to access protected resources
+     */
+    access_token: string;
+    /**
+     * Type of token issued (MCP clients always receive Bearer tokens)
+     */
+    token_type: TokenResponseDto.token_type;
+    /**
+     * Lifetime of the access token in seconds
+     */
+    expires_in: number;
+    /**
+     * Refresh token that can be exchanged for a new access token
+     */
+    refresh_token: string;
+    /**
+     * Space-delimited scopes that were granted for this token
+     */
+    scope?: string;
+};
+export declare namespace TokenResponseDto {
+    /**
+     * Type of token issued (MCP clients always receive Bearer tokens)
+     */
+    enum token_type {
+        BEARER = "Bearer"
+    }
+}

package/dist/src/client/models/TokenResponseDto.js

@@ -0,0 +1,10 @@
+export var TokenResponseDto;
+(function (TokenResponseDto) {
+    /**
+     * Type of token issued (MCP clients always receive Bearer tokens)
+     */
+    let token_type;
+    (function (token_type) {
+        token_type["BEARER"] = "Bearer";
+    })(token_type = TokenResponseDto.token_type || (TokenResponseDto.token_type = {}));
+})(TokenResponseDto || (TokenResponseDto = {}));

package/dist/src/client/models/UpdateAgentRunDto.d.ts

@@ -0,0 +1,14 @@
+export type UpdateAgentRunDto = {
+    /**
+     * Timestamp when the run started
+     */
+    startedAt?: string | null;
+    /**
+     * Timestamp when the run ended
+     */
+    endedAt?: string | null;
+    /**
+     * Timestamp of the last ping/heartbeat
+     */
+    lastPing?: string | null;
+};

package/dist/src/client/models/UpdateAgentRunDto.js

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

package/dist/src/client/models/UpdateBlockDto.d.ts

@@ -0,0 +1,22 @@
+export type UpdateBlockDto = {
+    /**
+     * Updated title of the context block
+     */
+    title?: string;
+    /**
+     * Updated markdown content of the block
+     */
+    content?: string;
+    /**
+     * Array of tag names to associate with the block
+     */
+    tagNames?: Array<string>;
+    /**
+     * Parent block ID (null to remove parent)
+     */
+    parentId?: string | null;
+    /**
+     * Order within siblings
+     */
+    order?: number;
+};

package/dist/src/client/models/UpdateBlockDto.js

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

package/dist/src/client/models/UpdateConnectionDto.d.ts

@@ -0,0 +1,26 @@
+export type UpdateConnectionDto = {
+    /**
+     * Friendly name to identify this OAuth connection
+     */
+    friendlyName?: string;
+    /**
+     * Unique identifier for this connection (alphanumeric, dash, underscore only). Used for token exchange.
+     */
+    providedId?: string;
+    /**
+     * OAuth client ID for the downstream provider
+     */
+    clientId?: string;
+    /**
+     * OAuth client secret for the downstream provider
+     */
+    clientSecret?: string;
+    /**
+     * OAuth authorization endpoint URL
+     */
+    authorizeUrl?: string;
+    /**
+     * OAuth token endpoint URL
+     */
+    tokenUrl?: string;
+};

package/dist/src/client/models/UpdateConnectionDto.js

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

package/dist/src/client/models/UpdateServerDto.d.ts

@@ -0,0 +1,14 @@
+export type UpdateServerDto = {
+    /**
+     * Display name of the MCP server
+     */
+    name?: string;
+    /**
+     * Short description of the MCP server
+     */
+    description?: string;
+    /**
+     * URL that MCP Clients will use to connect to the server
+     */
+    url?: string;
+};

package/dist/src/client/models/UpdateServerDto.js

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

package/dist/src/client/models/UpdateTaskDto.d.ts

@@ -0,0 +1,26 @@
+export type UpdateTaskDto = {
+    /**
+     * Name of the task
+     */
+    name?: string;
+    /**
+     * Detailed description of the task
+     */
+    description?: string;
+    /**
+     * ID of the assignee
+     */
+    assigneeActorId?: string;
+    /**
+     * Session ID for tracking AI agent work
+     */
+    sessionId?: string;
+    /**
+     * Array of tag names to associate with the task
+     */
+    tagNames?: Array<string>;
+    /**
+     * Array of task IDs that this task depends on
+     */
+    dependsOnIds?: Array<string>;
+};

package/dist/src/client/models/UpdateTaskDto.js

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

package/dist/src/client/models/UpdateThreadDto.d.ts

@@ -0,0 +1,6 @@
+export type UpdateThreadDto = {
+    /**
+     * Updated title of the thread
+     */
+    title?: string;
+};

package/dist/src/client/models/UpdateThreadDto.js

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

package/dist/src/client/models/UpdateThreadStateDto.d.ts

@@ -0,0 +1,6 @@
+export type UpdateThreadStateDto = {
+    /**
+     * New content for the thread state
+     */
+    content: string;
+};

package/dist/src/client/models/UpdateThreadStateDto.js

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

package/dist/src/client/models/UserResponseDto.d.ts

@@ -0,0 +1,31 @@
+export type UserResponseDto = {
+    /**
+     * User ID
+     */
+    id: string;
+    /**
+     * User email address
+     */
+    email: string;
+    /**
+     * User display name
+     */
+    displayName: string;
+    /**
+     * User role
+     */
+    role: UserResponseDto.role;
+    /**
+     * Actor ID associated with this user
+     */
+    actorId: string;
+};
+export declare namespace UserResponseDto {
+    /**
+     * User role
+     */
+    enum role {
+        ADMIN = "admin",
+        STANDARD = "standard"
+    }
+}

package/dist/src/client/models/UserResponseDto.js

@@ -0,0 +1,11 @@
+export var UserResponseDto;
+(function (UserResponseDto) {
+    /**
+     * User role
+     */
+    let role;
+    (function (role) {
+        role["ADMIN"] = "admin";
+        role["STANDARD"] = "standard";
+    })(role = UserResponseDto.role || (UserResponseDto.role = {}));
+})(UserResponseDto || (UserResponseDto = {}));

package/dist/src/client/services/ActorsService.d.ts

@@ -0,0 +1,19 @@
+import type { ActorResponseDto } from '../models/ActorResponseDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class ActorsService {
+    /**
+     * List all actors (users and agents)
+     * @returns ActorResponseDto List of all actors
+     * @throws ApiError
+     */
+    static actorControllerListActors(): CancelablePromise<Array<ActorResponseDto>>;
+    /**
+     * Search actors by display name or slug
+     * @param query Search query string
+     * @param limit Maximum number of results to return
+     * @param threshold Minimum score threshold (0-1, higher is stricter)
+     * @returns ActorResponseDto Search results sorted by relevance
+     * @throws ApiError
+     */
+    static actorControllerSearchActors(query: string, limit?: number, threshold?: number): CancelablePromise<Array<ActorResponseDto>>;
+}

package/dist/src/client/services/ActorsService.js

@@ -0,0 +1,34 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class ActorsService {
+    /**
+     * List all actors (users and agents)
+     * @returns ActorResponseDto List of all actors
+     * @throws ApiError
+     */
+    static actorControllerListActors() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/actors',
+        });
+    }
+    /**
+     * Search actors by display name or slug
+     * @param query Search query string
+     * @param limit Maximum number of results to return
+     * @param threshold Minimum score threshold (0-1, higher is stricter)
+     * @returns ActorResponseDto Search results sorted by relevance
+     * @throws ApiError
+     */
+    static actorControllerSearchActors(query, limit = 10, threshold = 0.3) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/actors/search',
+            query: {
+                'query': query,
+                'limit': limit,
+                'threshold': threshold,
+            },
+        });
+    }
+}

package/dist/src/client/services/AgentRunService.d.ts

@@ -0,0 +1,39 @@
+import type { AgentRunListResponseDto } from '../models/AgentRunListResponseDto.js';
+import type { AgentRunResponseDto } from '../models/AgentRunResponseDto.js';
+import type { CreateAgentRunDto } from '../models/CreateAgentRunDto.js';
+import type { UpdateAgentRunDto } from '../models/UpdateAgentRunDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AgentRunService {
+    /**
+     * Create a new agent run
+     * @param requestBody
+     * @returns AgentRunResponseDto Agent run created successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerCreateAgentRun(requestBody: CreateAgentRunDto): CancelablePromise<AgentRunResponseDto>;
+    /**
+     * List agent runs with optional filters
+     * @param actorId Filter by actor ID
+     * @param parentTaskId Filter by parent task ID
+     * @param page Page number (1-indexed)
+     * @param limit Number of items per page
+     * @returns AgentRunListResponseDto List of agent runs retrieved successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerListAgentRuns(actorId?: string, parentTaskId?: string, page?: number, limit?: number): CancelablePromise<AgentRunListResponseDto>;
+    /**
+     * Get an agent run by ID
+     * @param runId Agent run ID
+     * @returns AgentRunResponseDto Agent run retrieved successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerGetAgentRunById(runId: string): CancelablePromise<AgentRunResponseDto>;
+    /**
+     * Update an agent run
+     * @param runId Agent run ID
+     * @param requestBody
+     * @returns AgentRunResponseDto Agent run updated successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerUpdateAgentRun(runId: string, requestBody: UpdateAgentRunDto): CancelablePromise<AgentRunResponseDto>;
+}

package/dist/src/client/services/AgentRunService.js

@@ -0,0 +1,82 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AgentRunService {
+    /**
+     * Create a new agent run
+     * @param requestBody
+     * @returns AgentRunResponseDto Agent run created successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerCreateAgentRun(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/agent-runs',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+            },
+        });
+    }
+    /**
+     * List agent runs with optional filters
+     * @param actorId Filter by actor ID
+     * @param parentTaskId Filter by parent task ID
+     * @param page Page number (1-indexed)
+     * @param limit Number of items per page
+     * @returns AgentRunListResponseDto List of agent runs retrieved successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerListAgentRuns(actorId, parentTaskId, page = 1, limit = 20) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/agent-runs',
+            query: {
+                'actorId': actorId,
+                'parentTaskId': parentTaskId,
+                'page': page,
+                'limit': limit,
+            },
+        });
+    }
+    /**
+     * Get an agent run by ID
+     * @param runId Agent run ID
+     * @returns AgentRunResponseDto Agent run retrieved successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerGetAgentRunById(runId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/agent-runs/{runId}',
+            path: {
+                'runId': runId,
+            },
+            errors: {
+                404: `Agent run not found`,
+            },
+        });
+    }
+    /**
+     * Update an agent run
+     * @param runId Agent run ID
+     * @param requestBody
+     * @returns AgentRunResponseDto Agent run updated successfully
+     * @throws ApiError
+     */
+    static agentRunsControllerUpdateAgentRun(runId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/agent-runs/{runId}',
+            path: {
+                'runId': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Agent run not found`,
+            },
+        });
+    }
+}

package/dist/src/client/services/AgentService.d.ts

@@ -0,0 +1,45 @@
+import type { AgentListResponseDto } from '../models/AgentListResponseDto.js';
+import type { AgentResponseDto } from '../models/AgentResponseDto.js';
+import type { CreateAgentDto } from '../models/CreateAgentDto.js';
+import type { PatchAgentDto } from '../models/PatchAgentDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AgentService {
+    /**
+     * Create a new agent
+     * @param requestBody
+     * @returns AgentResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerCreateAgent(requestBody: CreateAgentDto): CancelablePromise<AgentResponseDto>;
+    /**
+     * List agents with optional filtering and pagination
+     * @param isActive Filter by active status
+     * @param page Page number for pagination
+     * @param limit Number of items per page
+     * @returns AgentListResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerListAgents(isActive?: boolean, page?: number, limit?: number): CancelablePromise<AgentListResponseDto>;
+    /**
+     * Get an agent by slug
+     * @param slug Agent slug
+     * @returns AgentResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerGetAgentBySlug(slug: string): CancelablePromise<AgentResponseDto>;
+    /**
+     * Patch an agent (update system prompt, status triggers, tag triggers, and/or type)
+     * @param actorId Agent actor ID
+     * @param requestBody
+     * @returns AgentResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerPatchAgent(actorId: string, requestBody: PatchAgentDto): CancelablePromise<AgentResponseDto>;
+    /**
+     * Delete an agent
+     * @param actorId Agent actor ID
+     * @returns void
+     * @throws ApiError
+     */
+    static agentsControllerDeleteAgent(actorId: string): CancelablePromise<void>;
+}