@taico/client 0.1.0 → 0.2.0

package/dist/src/{client → v1/client}/services/ToolsService.d.ts

@@ -14,6 +14,7 @@ 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';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class ToolsService {
     /**
      * Register a new MCP server
@@ -21,7 +22,7 @@ export declare class ToolsService {
      * @returns ServerResponseDto Server created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateServer(requestBody: CreateServerDto): CancelablePromise<ServerResponseDto>;
+    static mcpRegistryControllerCreateServer(requestBody: CreateServerDto, config?: OpenAPIConfig): CancelablePromise<ServerResponseDto>;
     /**
      * List all MCP servers with pagination
      * @param page
@@ -29,14 +30,14 @@ export declare class ToolsService {
      * @returns ServerListResponseDto List of servers
      * @throws ApiError
      */
-    static mcpRegistryControllerListServers(page?: number, limit?: number): CancelablePromise<ServerListResponseDto>;
+    static mcpRegistryControllerListServers(page?: number, limit?: number, config?: OpenAPIConfig): 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>;
+    static mcpRegistryControllerGetServer(serverId: string, config?: OpenAPIConfig): CancelablePromise<ServerResponseDto>;
     /**
      * Update MCP server details
      * @param serverId Server UUID
@@ -44,14 +45,14 @@ export declare class ToolsService {
      * @returns ServerResponseDto Server updated successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerUpdateServer(serverId: string, requestBody: UpdateServerDto): CancelablePromise<ServerResponseDto>;
+    static mcpRegistryControllerUpdateServer(serverId: string, requestBody: UpdateServerDto, config?: OpenAPIConfig): 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>;
+    static mcpRegistryControllerDeleteServer(serverId: string, config?: OpenAPIConfig): CancelablePromise<DeleteServerResponseDto>;
     /**
      * Create MCP scope(s) for a server
      * @param serverId Server UUID
@@ -59,14 +60,14 @@ export declare class ToolsService {
      * @returns ScopeResponseDto Scope(s) created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateScopes(serverId: string, requestBody: Array<CreateScopeDto>): CancelablePromise<Array<ScopeResponseDto>>;
+    static mcpRegistryControllerCreateScopes(serverId: string, requestBody: Array<CreateScopeDto>, config?: OpenAPIConfig): 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>>;
+    static mcpRegistryControllerListScopes(serverId: string, config?: OpenAPIConfig): CancelablePromise<Array<ScopeResponseDto>>;
     /**
      * Get a specific MCP scope
      * @param serverId Server UUID
@@ -74,7 +75,7 @@ export declare class ToolsService {
      * @returns ScopeResponseDto Scope found
      * @throws ApiError
      */
-    static mcpRegistryControllerGetScope(serverId: string, scopeId: string): CancelablePromise<ScopeResponseDto>;
+    static mcpRegistryControllerGetScope(serverId: string, scopeId: string, config?: OpenAPIConfig): CancelablePromise<ScopeResponseDto>;
     /**
      * Delete MCP scope (must have no mappings)
      * @param serverId Server UUID
@@ -82,7 +83,7 @@ export declare class ToolsService {
      * @returns DeleteScopeResponseDto Scope deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteScope(serverId: string, scopeId: string): CancelablePromise<DeleteScopeResponseDto>;
+    static mcpRegistryControllerDeleteScope(serverId: string, scopeId: string, config?: OpenAPIConfig): CancelablePromise<DeleteScopeResponseDto>;
     /**
      * Create OAuth connection for an MCP server
      * @param serverId Server UUID
@@ -90,21 +91,21 @@ export declare class ToolsService {
      * @returns ConnectionResponseDto Connection created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateConnection(serverId: string, requestBody: CreateConnectionDto): CancelablePromise<ConnectionResponseDto>;
+    static mcpRegistryControllerCreateConnection(serverId: string, requestBody: CreateConnectionDto, config?: OpenAPIConfig): 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>>;
+    static mcpRegistryControllerListConnections(serverId: string, config?: OpenAPIConfig): CancelablePromise<Array<ConnectionResponseDto>>;
     /**
      * Get a specific connection
      * @param connectionId Connection UUID
      * @returns ConnectionResponseDto Connection found
      * @throws ApiError
      */
-    static mcpRegistryControllerGetConnection(connectionId: string): CancelablePromise<ConnectionResponseDto>;
+    static mcpRegistryControllerGetConnection(connectionId: string, config?: OpenAPIConfig): CancelablePromise<ConnectionResponseDto>;
     /**
      * Update connection details
      * @param connectionId Connection UUID
@@ -112,14 +113,14 @@ export declare class ToolsService {
      * @returns ConnectionResponseDto Connection updated successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerUpdateConnection(connectionId: string, requestBody: UpdateConnectionDto): CancelablePromise<ConnectionResponseDto>;
+    static mcpRegistryControllerUpdateConnection(connectionId: string, requestBody: UpdateConnectionDto, config?: OpenAPIConfig): 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>;
+    static mcpRegistryControllerDeleteConnection(connectionId: string, config?: OpenAPIConfig): CancelablePromise<DeleteConnectionResponseDto>;
     /**
      * Create scope mapping
      * @param serverId Server UUID
@@ -127,7 +128,7 @@ export declare class ToolsService {
      * @returns MappingResponseDto Mapping created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateMapping(serverId: string, requestBody: CreateMappingDto): CancelablePromise<MappingResponseDto>;
+    static mcpRegistryControllerCreateMapping(serverId: string, requestBody: CreateMappingDto, config?: OpenAPIConfig): CancelablePromise<MappingResponseDto>;
     /**
      * List downstream scopes for an MCP scope
      * @param serverId Server UUID
@@ -135,12 +136,12 @@ export declare class ToolsService {
      * @returns MappingResponseDto List of mappings
      * @throws ApiError
      */
-    static mcpRegistryControllerListMappings(serverId: string, scopeId: string): CancelablePromise<Array<MappingResponseDto>>;
+    static mcpRegistryControllerListMappings(serverId: string, scopeId: string, config?: OpenAPIConfig): CancelablePromise<Array<MappingResponseDto>>;
     /**
      * Delete scope mapping
      * @param mappingId Mapping UUID
      * @returns DeleteMappingResponseDto Mapping deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteMapping(mappingId: string): CancelablePromise<DeleteMappingResponseDto>;
+    static mcpRegistryControllerDeleteMapping(mappingId: string, config?: OpenAPIConfig): CancelablePromise<DeleteMappingResponseDto>;
 }

package/dist/src/{client → v1/client}/services/ToolsService.js

@@ -7,8 +7,8 @@ export class ToolsService {
      * @returns ServerResponseDto Server created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateServer(requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerCreateServer(requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/mcp/servers',
             body: requestBody,
@@ -25,8 +25,8 @@ export class ToolsService {
      * @returns ServerListResponseDto List of servers
      * @throws ApiError
      */
-    static mcpRegistryControllerListServers(page, limit) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerListServers(page, limit, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers',
             query: {
@@ -41,8 +41,8 @@ export class ToolsService {
      * @returns ServerResponseDto Server found
      * @throws ApiError
      */
-    static mcpRegistryControllerGetServer(serverId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerGetServer(serverId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers/{serverId}',
             path: {
@@ -60,8 +60,8 @@ export class ToolsService {
      * @returns ServerResponseDto Server updated successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerUpdateServer(serverId, requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerUpdateServer(serverId, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'PATCH',
             url: '/api/v1/mcp/servers/{serverId}',
             path: {
@@ -80,8 +80,8 @@ export class ToolsService {
      * @returns DeleteServerResponseDto Server deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteServer(serverId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerDeleteServer(serverId, config = OpenAPI) {
+        return __request(config, {
             method: 'DELETE',
             url: '/api/v1/mcp/servers/{serverId}',
             path: {
@@ -100,8 +100,8 @@ export class ToolsService {
      * @returns ScopeResponseDto Scope(s) created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateScopes(serverId, requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerCreateScopes(serverId, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/mcp/servers/{serverId}/scopes',
             path: {
@@ -121,8 +121,8 @@ export class ToolsService {
      * @returns ScopeResponseDto List of scopes
      * @throws ApiError
      */
-    static mcpRegistryControllerListScopes(serverId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerListScopes(serverId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers/{serverId}/scopes',
             path: {
@@ -140,8 +140,8 @@ export class ToolsService {
      * @returns ScopeResponseDto Scope found
      * @throws ApiError
      */
-    static mcpRegistryControllerGetScope(serverId, scopeId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerGetScope(serverId, scopeId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}',
             path: {
@@ -160,8 +160,8 @@ export class ToolsService {
      * @returns DeleteScopeResponseDto Scope deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteScope(serverId, scopeId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerDeleteScope(serverId, scopeId, config = OpenAPI) {
+        return __request(config, {
             method: 'DELETE',
             url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}',
             path: {
@@ -181,8 +181,8 @@ export class ToolsService {
      * @returns ConnectionResponseDto Connection created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateConnection(serverId, requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerCreateConnection(serverId, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/mcp/servers/{serverId}/connections',
             path: {
@@ -202,8 +202,8 @@ export class ToolsService {
      * @returns ConnectionResponseDto List of connections
      * @throws ApiError
      */
-    static mcpRegistryControllerListConnections(serverId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerListConnections(serverId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers/{serverId}/connections',
             path: {
@@ -220,8 +220,8 @@ export class ToolsService {
      * @returns ConnectionResponseDto Connection found
      * @throws ApiError
      */
-    static mcpRegistryControllerGetConnection(connectionId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerGetConnection(connectionId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/connections/{connectionId}',
             path: {
@@ -239,8 +239,8 @@ export class ToolsService {
      * @returns ConnectionResponseDto Connection updated successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerUpdateConnection(connectionId, requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerUpdateConnection(connectionId, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'PATCH',
             url: '/api/v1/mcp/connections/{connectionId}',
             path: {
@@ -260,8 +260,8 @@ export class ToolsService {
      * @returns DeleteConnectionResponseDto Connection deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteConnection(connectionId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerDeleteConnection(connectionId, config = OpenAPI) {
+        return __request(config, {
             method: 'DELETE',
             url: '/api/v1/mcp/connections/{connectionId}',
             path: {
@@ -280,8 +280,8 @@ export class ToolsService {
      * @returns MappingResponseDto Mapping created successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerCreateMapping(serverId, requestBody) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerCreateMapping(serverId, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/mcp/servers/{serverId}/mappings',
             path: {
@@ -302,8 +302,8 @@ export class ToolsService {
      * @returns MappingResponseDto List of mappings
      * @throws ApiError
      */
-    static mcpRegistryControllerListMappings(serverId, scopeId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerListMappings(serverId, scopeId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/mcp/servers/{serverId}/scopes/{scopeId}/mappings',
             path: {
@@ -321,8 +321,8 @@ export class ToolsService {
      * @returns DeleteMappingResponseDto Mapping deleted successfully
      * @throws ApiError
      */
-    static mcpRegistryControllerDeleteMapping(mappingId) {
-        return __request(OpenAPI, {
+    static mcpRegistryControllerDeleteMapping(mappingId, config = OpenAPI) {
+        return __request(config, {
             method: 'DELETE',
             url: '/api/v1/mcp/mappings/{mappingId}',
             path: {

package/dist/src/{client → v1/client}/services/WebAuthenticationService.d.ts

@@ -5,6 +5,7 @@ import type { OnboardingRequestDto } from '../models/OnboardingRequestDto.js';
 import type { OnboardingStatusResponseDto } from '../models/OnboardingStatusResponseDto.js';
 import type { UserResponseDto } from '../models/UserResponseDto.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class WebAuthenticationService {
     /**
      * Login with email and password
@@ -12,19 +13,19 @@ export declare class WebAuthenticationService {
      * @returns LoginResponseDto Login successful, tokens set in httpOnly cookies
      * @throws ApiError
      */
-    static webAuthControllerLogin(requestBody: LoginRequestDto): CancelablePromise<LoginResponseDto>;
+    static webAuthControllerLogin(requestBody: LoginRequestDto, config?: OpenAPIConfig): CancelablePromise<LoginResponseDto>;
     /**
      * Refresh access token using refresh token
      * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies
      * @throws ApiError
      */
-    static webAuthControllerRefresh(): CancelablePromise<LoginResponseDto>;
+    static webAuthControllerRefresh(config?: OpenAPIConfig): CancelablePromise<LoginResponseDto>;
     /**
      * Logout and revoke refresh token
      * @returns any Logout successful, cookies cleared
      * @throws ApiError
      */
-    static webAuthControllerLogout(): CancelablePromise<{
+    static webAuthControllerLogout(config?: OpenAPIConfig): CancelablePromise<{
         ok?: boolean;
     }>;
     /**
@@ -32,14 +33,14 @@ export declare class WebAuthenticationService {
      * @returns UserResponseDto Current user information
      * @throws ApiError
      */
-    static webAuthControllerMe(): CancelablePromise<UserResponseDto>;
+    static webAuthControllerMe(config?: OpenAPIConfig): CancelablePromise<UserResponseDto>;
     /**
      * Change password for authenticated user
      * @param requestBody
      * @returns any Password changed successfully
      * @throws ApiError
      */
-    static webAuthControllerChangePassword(requestBody: ChangePasswordRequestDto): CancelablePromise<{
+    static webAuthControllerChangePassword(requestBody: ChangePasswordRequestDto, config?: OpenAPIConfig): CancelablePromise<{
         ok?: boolean;
     }>;
     /**
@@ -47,20 +48,20 @@ export declare class WebAuthenticationService {
      * @returns OnboardingStatusResponseDto Onboarding status
      * @throws ApiError
      */
-    static webAuthControllerGetOnboardingStatus(): CancelablePromise<OnboardingStatusResponseDto>;
+    static webAuthControllerGetOnboardingStatus(config?: OpenAPIConfig): CancelablePromise<OnboardingStatusResponseDto>;
     /**
      * Create first admin user (only works if no admins exist)
      * @param requestBody
      * @returns LoginResponseDto First admin user created and logged in
      * @throws ApiError
      */
-    static webAuthControllerOnboard(requestBody: OnboardingRequestDto): CancelablePromise<LoginResponseDto>;
+    static webAuthControllerOnboard(requestBody: OnboardingRequestDto, config?: OpenAPIConfig): CancelablePromise<LoginResponseDto>;
     /**
      * Mark walkthrough as seen for authenticated user
      * @returns any Walkthrough marked as seen
      * @throws ApiError
      */
-    static webAuthControllerMarkWalkthroughSeen(): CancelablePromise<{
+    static webAuthControllerMarkWalkthroughSeen(config?: OpenAPIConfig): CancelablePromise<{
         ok?: boolean;
     }>;
 }

package/dist/src/{client → v1/client}/services/WebAuthenticationService.js

@@ -7,8 +7,8 @@ export class WebAuthenticationService {
      * @returns LoginResponseDto Login successful, tokens set in httpOnly cookies
      * @throws ApiError
      */
-    static webAuthControllerLogin(requestBody) {
-        return __request(OpenAPI, {
+    static webAuthControllerLogin(requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/login',
             body: requestBody,
@@ -23,8 +23,8 @@ export class WebAuthenticationService {
      * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies
      * @throws ApiError
      */
-    static webAuthControllerRefresh() {
-        return __request(OpenAPI, {
+    static webAuthControllerRefresh(config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/refresh',
             errors: {
@@ -37,8 +37,8 @@ export class WebAuthenticationService {
      * @returns any Logout successful, cookies cleared
      * @throws ApiError
      */
-    static webAuthControllerLogout() {
-        return __request(OpenAPI, {
+    static webAuthControllerLogout(config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/logout',
         });
@@ -48,8 +48,8 @@ export class WebAuthenticationService {
      * @returns UserResponseDto Current user information
      * @throws ApiError
      */
-    static webAuthControllerMe() {
-        return __request(OpenAPI, {
+    static webAuthControllerMe(config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/me',
             errors: {
@@ -63,8 +63,8 @@ export class WebAuthenticationService {
      * @returns any Password changed successfully
      * @throws ApiError
      */
-    static webAuthControllerChangePassword(requestBody) {
-        return __request(OpenAPI, {
+    static webAuthControllerChangePassword(requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/change-password',
             body: requestBody,
@@ -79,8 +79,8 @@ export class WebAuthenticationService {
      * @returns OnboardingStatusResponseDto Onboarding status
      * @throws ApiError
      */
-    static webAuthControllerGetOnboardingStatus() {
-        return __request(OpenAPI, {
+    static webAuthControllerGetOnboardingStatus(config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/onboarding-status',
         });
@@ -91,8 +91,8 @@ export class WebAuthenticationService {
      * @returns LoginResponseDto First admin user created and logged in
      * @throws ApiError
      */
-    static webAuthControllerOnboard(requestBody) {
-        return __request(OpenAPI, {
+    static webAuthControllerOnboard(requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/onboard',
             body: requestBody,
@@ -107,8 +107,8 @@ export class WebAuthenticationService {
      * @returns any Walkthrough marked as seen
      * @throws ApiError
      */
-    static webAuthControllerMarkWalkthroughSeen() {
-        return __request(OpenAPI, {
+    static webAuthControllerMarkWalkthroughSeen(config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/mark-walkthrough-seen',
             errors: {

package/dist/src/v1/createTaicoClient.d.ts

@@ -0,0 +1,28 @@
+import * as generatedClient from './client/index.js';
+import type { OpenAPIConfig } from './client/core/OpenAPI.js';
+type GeneratedClientModule = typeof generatedClient;
+type ServiceKey = {
+    [K in keyof GeneratedClientModule]: K extends `${string}Service` ? GeneratedClientModule[K] extends object ? K : never : never;
+}[keyof GeneratedClientModule];
+type StripConfigArg<Args extends unknown[]> = Args extends [...infer Rest, OpenAPIConfig?] ? Rest : Args;
+type BoundService<TService> = {
+    [K in keyof TService as TService[K] extends (...args: any[]) => any ? K : never]: TService[K] extends (...args: infer TArgs) => infer TResult ? (...args: StripConfigArg<TArgs>) => TResult : never;
+};
+export type TaicoClient = {
+    config: OpenAPIConfig;
+} & {
+    [K in ServiceKey]: BoundService<GeneratedClientModule[K]>;
+};
+export type CreateTaicoClientOptions = {
+    baseUrl: string;
+    token?: OpenAPIConfig['TOKEN'];
+    version?: string;
+    withCredentials?: boolean;
+    credentials?: RequestCredentials;
+    username?: OpenAPIConfig['USERNAME'];
+    password?: OpenAPIConfig['PASSWORD'];
+    headers?: OpenAPIConfig['HEADERS'];
+    encodePath?: OpenAPIConfig['ENCODE_PATH'];
+};
+export declare function createTaicoClient(options: CreateTaicoClientOptions): TaicoClient;
+export {};

package/dist/src/v1/createTaicoClient.js

@@ -0,0 +1,38 @@
+import * as generatedClient from './client/index.js';
+function bindService(service, config) {
+    const boundService = {};
+    for (const propertyName of Object.getOwnPropertyNames(service)) {
+        if (propertyName === 'length' || propertyName === 'name' || propertyName === 'prototype') {
+            continue;
+        }
+        const value = service[propertyName];
+        if (typeof value !== 'function') {
+            continue;
+        }
+        boundService[propertyName] = (...args) => {
+            return value(...args, config);
+        };
+    }
+    return boundService;
+}
+export function createTaicoClient(options) {
+    const config = {
+        BASE: options.baseUrl,
+        VERSION: options.version ?? '1.0',
+        WITH_CREDENTIALS: options.withCredentials ?? false,
+        CREDENTIALS: options.credentials ?? 'include',
+        TOKEN: options.token,
+        USERNAME: options.username,
+        PASSWORD: options.password,
+        HEADERS: options.headers,
+        ENCODE_PATH: options.encodePath,
+    };
+    const client = { config };
+    for (const [name, value] of Object.entries(generatedClient)) {
+        if (!name.endsWith('Service') || typeof value !== 'function') {
+            continue;
+        }
+        client[name] = bindService(value, config);
+    }
+    return client;
+}

package/dist/src/v1/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client/index.js';
+export * from '../../contracts/types.js';
+export * from './createTaicoClient.js';

package/dist/src/{index.js → v1/index.js}

@@ -1,4 +1,6 @@
 // Re-export generated client for ergonomics
 export * from './client/index.js';
 // Re-export generated types for ergonomics
-export * from '../contracts/types.js';
+export * from '../../contracts/types.js';
+// Instance-safe client factory
+export * from './createTaicoClient.js';

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

@@ -0,0 +1,16 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { ActorResponseDto } from './types.js';
+export declare class ActorsResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** List all actors (users and agents) */
+    ActorController_listActors(params?: {
+        signal?: AbortSignal;
+    }): Promise<ActorResponseDto[]>;
+    /** Search actors by display name or slug */
+    ActorController_searchActors(params: {
+        query: string;
+        limit?: number;
+        threshold?: number;
+        signal?: AbortSignal;
+    }): Promise<ActorResponseDto[]>;
+}

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

@@ -0,0 +1,14 @@
+import { BaseClient } from './base-client.js';
+export class ActorsResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** List all actors (users and agents) */
+    async ActorController_listActors(params) {
+        return this.request('GET', '/api/v1/actors', { signal: params?.signal });
+    }
+    /** Search actors by display name or slug */
+    async ActorController_searchActors(params) {
+        return this.request('GET', '/api/v1/actors/search', { params: { query: params.query, limit: params.limit, threshold: params.threshold }, signal: params?.signal });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AgentExecutionTokenResponseDto, RequestAgentExecutionTokenDto } from './types.js';
+export declare class AgentExecutionTokensResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Request a short-lived execution token for an agent */
+    AgentExecutionTokensController_requestExecutionToken(params: {
+        slug: string;
+        body: RequestAgentExecutionTokenDto;
+        signal?: AbortSignal;
+    }): Promise<AgentExecutionTokenResponseDto>;
+}

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

@@ -0,0 +1,10 @@
+import { BaseClient } from './base-client.js';
+export class AgentExecutionTokensResource extends BaseClient {
+    constructor(config) {
+        super(config);
+    }
+    /** Request a short-lived execution token for an agent */
+    async AgentExecutionTokensController_requestExecutionToken(params) {
+        return this.request('POST', `/api/v1/agents/${params.slug}/execution-token`, { body: params.body, signal: params?.signal });
+    }
+}

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

@@ -0,0 +1,33 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AgentListResponseDto, AgentResponseDto, CreateAgentDto, PatchAgentDto } from './types.js';
+export declare class AgentResource extends BaseClient {
+    constructor(config: ClientConfig);
+    /** Create a new agent */
+    AgentsController_createAgent(params: {
+        body: CreateAgentDto;
+        signal?: AbortSignal;
+    }): Promise<AgentResponseDto>;
+    /** List agents with optional filtering and pagination */
+    AgentsController_listAgents(params?: {
+        isActive?: boolean;
+        page?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<AgentListResponseDto>;
+    /** Get an agent by slug */
+    AgentsController_getAgentBySlug(params: {
+        slug: string;
+        signal?: AbortSignal;
+    }): Promise<AgentResponseDto>;
+    /** Patch an agent and its linked actor fields */
+    AgentsController_patchAgent(params: {
+        actorId: string;
+        body: PatchAgentDto;
+        signal?: AbortSignal;
+    }): Promise<AgentResponseDto>;
+    /** Delete an agent */
+    AgentsController_deleteAgent(params: {
+        actorId: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}