@taico/client 0.0.1

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

@@ -0,0 +1,114 @@
+import type { AddParticipantDto } from '../models/AddParticipantDto.js';
+import type { AppendThreadStateDto } from '../models/AppendThreadStateDto.js';
+import type { AttachTaskDto } from '../models/AttachTaskDto.js';
+import type { CreateTagDto } from '../models/CreateTagDto.js';
+import type { CreateThreadDto } from '../models/CreateThreadDto.js';
+import type { ReferenceContextBlockDto } from '../models/ReferenceContextBlockDto.js';
+import type { ThreadListResponseDto } from '../models/ThreadListResponseDto.js';
+import type { ThreadResponseDto } from '../models/ThreadResponseDto.js';
+import type { ThreadStateResponseDto } from '../models/ThreadStateResponseDto.js';
+import type { UpdateThreadDto } from '../models/UpdateThreadDto.js';
+import type { UpdateThreadStateDto } from '../models/UpdateThreadStateDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class ThreadsService {
+    /**
+     * Create a new thread
+     * @param requestBody
+     * @returns ThreadResponseDto Thread created successfully
+     * @throws ApiError
+     */
+    static threadsControllerCreateThread(requestBody: CreateThreadDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * List all threads with lightweight retrieval
+     * @param page Page number (1-based)
+     * @param limit Number of items per page
+     * @returns ThreadListResponseDto Paginated list of threads
+     * @throws ApiError
+     */
+    static threadsControllerListThreads(page?: number, limit?: number): CancelablePromise<ThreadListResponseDto>;
+    /**
+     * Update thread title
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Thread updated successfully
+     * @throws ApiError
+     */
+    static threadsControllerUpdateThread(id: string, requestBody: UpdateThreadDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Get a thread by ID with full details
+     * @param id Thread UUID
+     * @returns ThreadResponseDto Thread found
+     * @throws ApiError
+     */
+    static threadsControllerGetThread(id: string): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Delete a thread
+     * @param id Thread UUID
+     * @returns void
+     * @throws ApiError
+     */
+    static threadsControllerDeleteThread(id: string): CancelablePromise<void>;
+    /**
+     * Attach a task to the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Task attached successfully
+     * @throws ApiError
+     */
+    static threadsControllerAttachTask(id: string, requestBody: AttachTaskDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Reference a context block in the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Context block referenced successfully
+     * @throws ApiError
+     */
+    static threadsControllerReferenceContextBlock(id: string, requestBody: ReferenceContextBlockDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Add a tag to a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Tag added to thread successfully
+     * @throws ApiError
+     */
+    static threadsControllerAddTagToThread(id: string, requestBody: CreateTagDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Remove a tag from a thread
+     * @param id
+     * @param tagId
+     * @returns ThreadResponseDto Tag removed from thread successfully
+     * @throws ApiError
+     */
+    static threadsControllerRemoveTagFromThread(id: string, tagId: string): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Add a participant to the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Participant added successfully
+     * @throws ApiError
+     */
+    static threadsControllerAddParticipant(id: string, requestBody: AddParticipantDto): CancelablePromise<ThreadResponseDto>;
+    /**
+     * Get the state of a thread
+     * @param id Thread UUID
+     * @returns ThreadStateResponseDto Thread state retrieved successfully
+     * @throws ApiError
+     */
+    static threadsControllerGetThreadState(id: string): CancelablePromise<ThreadStateResponseDto>;
+    /**
+     * Update the state of a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadStateResponseDto Thread state updated successfully
+     * @throws ApiError
+     */
+    static threadsControllerUpdateThreadState(id: string, requestBody: UpdateThreadStateDto): CancelablePromise<ThreadStateResponseDto>;
+    /**
+     * Append content to the state of a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadStateResponseDto Content appended to thread state successfully
+     * @throws ApiError
+     */
+    static threadsControllerAppendThreadState(id: string, requestBody: AppendThreadStateDto): CancelablePromise<ThreadStateResponseDto>;
+}

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

@@ -0,0 +1,266 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class ThreadsService {
+    /**
+     * Create a new thread
+     * @param requestBody
+     * @returns ThreadResponseDto Thread created successfully
+     * @throws ApiError
+     */
+    static threadsControllerCreateThread(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+            },
+        });
+    }
+    /**
+     * List all threads with lightweight retrieval
+     * @param page Page number (1-based)
+     * @param limit Number of items per page
+     * @returns ThreadListResponseDto Paginated list of threads
+     * @throws ApiError
+     */
+    static threadsControllerListThreads(page, limit) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/threads',
+            query: {
+                'page': page,
+                'limit': limit,
+            },
+        });
+    }
+    /**
+     * Update thread title
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Thread updated successfully
+     * @throws ApiError
+     */
+    static threadsControllerUpdateThread(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/threads/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Get a thread by ID with full details
+     * @param id Thread UUID
+     * @returns ThreadResponseDto Thread found
+     * @throws ApiError
+     */
+    static threadsControllerGetThread(id) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/threads/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Delete a thread
+     * @param id Thread UUID
+     * @returns void
+     * @throws ApiError
+     */
+    static threadsControllerDeleteThread(id) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/threads/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Attach a task to the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Task attached successfully
+     * @throws ApiError
+     */
+    static threadsControllerAttachTask(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads/{id}/tasks',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread or task not found`,
+            },
+        });
+    }
+    /**
+     * Reference a context block in the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Context block referenced successfully
+     * @throws ApiError
+     */
+    static threadsControllerReferenceContextBlock(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads/{id}/context-blocks',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread or context block not found`,
+            },
+        });
+    }
+    /**
+     * Add a tag to a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Tag added to thread successfully
+     * @throws ApiError
+     */
+    static threadsControllerAddTagToThread(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads/{id}/tags',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Remove a tag from a thread
+     * @param id
+     * @param tagId
+     * @returns ThreadResponseDto Tag removed from thread successfully
+     * @throws ApiError
+     */
+    static threadsControllerRemoveTagFromThread(id, tagId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/threads/{id}/tags/{tagId}',
+            path: {
+                'id': id,
+                'tagId': tagId,
+            },
+            errors: {
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Add a participant to the thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadResponseDto Participant added successfully
+     * @throws ApiError
+     */
+    static threadsControllerAddParticipant(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads/{id}/participants',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread or actor not found`,
+            },
+        });
+    }
+    /**
+     * Get the state of a thread
+     * @param id Thread UUID
+     * @returns ThreadStateResponseDto Thread state retrieved successfully
+     * @throws ApiError
+     */
+    static threadsControllerGetThreadState(id) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/threads/{id}/state',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Update the state of a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadStateResponseDto Thread state updated successfully
+     * @throws ApiError
+     */
+    static threadsControllerUpdateThreadState(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/threads/{id}/state',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread not found`,
+            },
+        });
+    }
+    /**
+     * Append content to the state of a thread
+     * @param id Thread UUID
+     * @param requestBody
+     * @returns ThreadStateResponseDto Content appended to thread state successfully
+     * @throws ApiError
+     */
+    static threadsControllerAppendThreadState(id, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/threads/{id}/state/append',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Thread not found`,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,146 @@
+import type { ConnectionResponseDto } from '../models/ConnectionResponseDto.js';
+import type { CreateConnectionDto } from '../models/CreateConnectionDto.js';
+import type { CreateMappingDto } from '../models/CreateMappingDto.js';
+import type { CreateScopeDto } from '../models/CreateScopeDto.js';
+import type { CreateServerDto } from '../models/CreateServerDto.js';
+import type { DeleteConnectionResponseDto } from '../models/DeleteConnectionResponseDto.js';
+import type { DeleteMappingResponseDto } from '../models/DeleteMappingResponseDto.js';
+import type { DeleteScopeResponseDto } from '../models/DeleteScopeResponseDto.js';
+import type { DeleteServerResponseDto } from '../models/DeleteServerResponseDto.js';
+import type { MappingResponseDto } from '../models/MappingResponseDto.js';
+import type { ScopeResponseDto } from '../models/ScopeResponseDto.js';
+import type { ServerListResponseDto } from '../models/ServerListResponseDto.js';
+import type { ServerResponseDto } from '../models/ServerResponseDto.js';
+import type { UpdateConnectionDto } from '../models/UpdateConnectionDto.js';
+import type { UpdateServerDto } from '../models/UpdateServerDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class ToolsService {
+    /**
+     * Register a new MCP server
+     * @param requestBody
+     * @returns ServerResponseDto Server created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateServer(requestBody: CreateServerDto): CancelablePromise<ServerResponseDto>;
+    /**
+     * List all MCP servers with pagination
+     * @param page
+     * @param limit
+     * @returns ServerListResponseDto List of servers
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListServers(page?: number, limit?: number): CancelablePromise<ServerListResponseDto>;
+    /**
+     * Get MCP server by UUID or provided ID
+     * @param serverId Server UUID or provided ID
+     * @returns ServerResponseDto Server found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetServer(serverId: string): CancelablePromise<ServerResponseDto>;
+    /**
+     * Update MCP server details
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns ServerResponseDto Server updated successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerUpdateServer(serverId: string, requestBody: UpdateServerDto): CancelablePromise<ServerResponseDto>;
+    /**
+     * Delete MCP server (must have no dependencies)
+     * @param serverId Server UUID
+     * @returns DeleteServerResponseDto Server deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteServer(serverId: string): CancelablePromise<DeleteServerResponseDto>;
+    /**
+     * Create MCP scope(s) for a server
+     * @param serverId Server UUID
+     * @param requestBody Array of scopes to create
+     * @returns ScopeResponseDto Scope(s) created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateScopes(serverId: string, requestBody: Array<CreateScopeDto>): CancelablePromise<Array<ScopeResponseDto>>;
+    /**
+     * List all scopes for an MCP server
+     * @param serverId Server UUID
+     * @returns ScopeResponseDto List of scopes
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListScopes(serverId: string): CancelablePromise<Array<ScopeResponseDto>>;
+    /**
+     * Get a specific MCP scope
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns ScopeResponseDto Scope found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetScope(serverId: string, scopeId: string): CancelablePromise<ScopeResponseDto>;
+    /**
+     * Delete MCP scope (must have no mappings)
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns DeleteScopeResponseDto Scope deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteScope(serverId: string, scopeId: string): CancelablePromise<DeleteScopeResponseDto>;
+    /**
+     * Create OAuth connection for an MCP server
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns ConnectionResponseDto Connection created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateConnection(serverId: string, requestBody: CreateConnectionDto): CancelablePromise<ConnectionResponseDto>;
+    /**
+     * List all connections for an MCP server
+     * @param serverId Server UUID
+     * @returns ConnectionResponseDto List of connections
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListConnections(serverId: string): CancelablePromise<Array<ConnectionResponseDto>>;
+    /**
+     * Get a specific connection
+     * @param connectionId Connection UUID
+     * @returns ConnectionResponseDto Connection found
+     * @throws ApiError
+     */
+    static mcpRegistryControllerGetConnection(connectionId: string): CancelablePromise<ConnectionResponseDto>;
+    /**
+     * Update connection details
+     * @param connectionId Connection UUID
+     * @param requestBody
+     * @returns ConnectionResponseDto Connection updated successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerUpdateConnection(connectionId: string, requestBody: UpdateConnectionDto): CancelablePromise<ConnectionResponseDto>;
+    /**
+     * Delete connection (must have no mappings)
+     * @param connectionId Connection UUID
+     * @returns DeleteConnectionResponseDto Connection deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteConnection(connectionId: string): CancelablePromise<DeleteConnectionResponseDto>;
+    /**
+     * Create scope mapping
+     * @param serverId Server UUID
+     * @param requestBody
+     * @returns MappingResponseDto Mapping created successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerCreateMapping(serverId: string, requestBody: CreateMappingDto): CancelablePromise<MappingResponseDto>;
+    /**
+     * List downstream scopes for an MCP scope
+     * @param serverId Server UUID
+     * @param scopeId Scope ID string
+     * @returns MappingResponseDto List of mappings
+     * @throws ApiError
+     */
+    static mcpRegistryControllerListMappings(serverId: string, scopeId: string): CancelablePromise<Array<MappingResponseDto>>;
+    /**
+     * Delete scope mapping
+     * @param mappingId Mapping UUID
+     * @returns DeleteMappingResponseDto Mapping deleted successfully
+     * @throws ApiError
+     */
+    static mcpRegistryControllerDeleteMapping(mappingId: string): CancelablePromise<DeleteMappingResponseDto>;
+}