@taico/client 0.0.1

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

@@ -0,0 +1,85 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AgentService {
+    /**
+     * Create a new agent
+     * @param requestBody
+     * @returns AgentResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerCreateAgent(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/agents',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * 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, page = 1, limit = 20) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/agents',
+            query: {
+                'isActive': isActive,
+                'page': page,
+                'limit': limit,
+            },
+        });
+    }
+    /**
+     * Get an agent by slug
+     * @param slug Agent slug
+     * @returns AgentResponseDto
+     * @throws ApiError
+     */
+    static agentsControllerGetAgentBySlug(slug) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/agents/{slug}',
+            path: {
+                'slug': slug,
+            },
+        });
+    }
+    /**
+     * 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, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v1/agents/{actorId}',
+            path: {
+                'actorId': actorId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete an agent
+     * @param actorId Agent actor ID
+     * @returns void
+     * @throws ApiError
+     */
+    static agentsControllerDeleteAgent(actorId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/agents/{actorId}',
+            path: {
+                'actorId': actorId,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { IssueAccessTokenRequestDto } from '../models/IssueAccessTokenRequestDto.js';
+import type { IssueAccessTokenResponseDto } from '../models/IssueAccessTokenResponseDto.js';
+import type { IssuedAccessTokenResponseDto } from '../models/IssuedAccessTokenResponseDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AgentTokensService {
+    /**
+     * Issue a new access token for an agent
+     * @param slug Agent slug
+     * @param requestBody
+     * @returns IssueAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerIssueToken(slug: string, requestBody: IssueAccessTokenRequestDto): CancelablePromise<IssueAccessTokenResponseDto>;
+    /**
+     * List all tokens for an agent
+     * @param slug Agent slug
+     * @returns IssuedAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerListTokens(slug: string): CancelablePromise<Array<IssuedAccessTokenResponseDto>>;
+    /**
+     * Revoke an agent token
+     * @param slug Agent slug
+     * @param tokenId Token ID to revoke
+     * @returns IssuedAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerRevokeToken(slug: string, tokenId: string): CancelablePromise<IssuedAccessTokenResponseDto>;
+}

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

@@ -0,0 +1,54 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AgentTokensService {
+    /**
+     * Issue a new access token for an agent
+     * @param slug Agent slug
+     * @param requestBody
+     * @returns IssueAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerIssueToken(slug, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/agents/{slug}/tokens',
+            path: {
+                'slug': slug,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * List all tokens for an agent
+     * @param slug Agent slug
+     * @returns IssuedAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerListTokens(slug) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/agents/{slug}/tokens',
+            path: {
+                'slug': slug,
+            },
+        });
+    }
+    /**
+     * Revoke an agent token
+     * @param slug Agent slug
+     * @param tokenId Token ID to revoke
+     * @returns IssuedAccessTokenResponseDto
+     * @throws ApiError
+     */
+    static agentTokensControllerRevokeToken(slug, tokenId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v1/agents/{slug}/tokens/{tokenId}',
+            path: {
+                'slug': slug,
+                'tokenId': tokenId,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AppService {
+    /**
+     * Health check endpoint
+     * @returns string Returns a greeting message
+     * @throws ApiError
+     */
+    static appControllerGetHello(): CancelablePromise<string>;
+}

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

@@ -0,0 +1,15 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AppService {
+    /**
+     * Health check endpoint
+     * @returns string Returns a greeting message
+     * @throws ApiError
+     */
+    static appControllerGetHello() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1',
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { AuthJourneyResponseDto } from '../models/AuthJourneyResponseDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AuthorizationJourneysService {
+    /**
+     * Get authorization journeys for an MCP server (debug/monitoring)
+     * @param serverId Server UUID
+     * @returns AuthJourneyResponseDto List of authorization journeys
+     * @throws ApiError
+     */
+    static authJourneysControllerGetAuthJourneys(serverId: string): CancelablePromise<Array<AuthJourneyResponseDto>>;
+}

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

@@ -0,0 +1,22 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AuthorizationJourneysService {
+    /**
+     * Get authorization journeys for an MCP server (debug/monitoring)
+     * @param serverId Server UUID
+     * @returns AuthJourneyResponseDto List of authorization journeys
+     * @throws ApiError
+     */
+    static authJourneysControllerGetAuthJourneys(serverId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth-journeys/servers/{serverId}',
+            path: {
+                'serverId': serverId,
+            },
+            errors: {
+                404: `Server not found`,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,123 @@
+import type { ClientRegistrationResponseDto } from '../models/ClientRegistrationResponseDto.js';
+import type { ConsentDecisionDto } from '../models/ConsentDecisionDto.js';
+import type { GetConsentMetadataResponseDto } from '../models/GetConsentMetadataResponseDto.js';
+import type { IntrospectTokenRequestDto } from '../models/IntrospectTokenRequestDto.js';
+import type { IntrospectTokenResponseDto } from '../models/IntrospectTokenResponseDto.js';
+import type { RegisterClientDto } from '../models/RegisterClientDto.js';
+import type { ScopesResponseDto } from '../models/ScopesResponseDto.js';
+import type { TokenExchangeRequestDto } from '../models/TokenExchangeRequestDto.js';
+import type { TokenExchangeResponseDto } from '../models/TokenExchangeResponseDto.js';
+import type { TokenRequestDto } from '../models/TokenRequestDto.js';
+import type { TokenResponseDto } from '../models/TokenResponseDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+export declare class AuthorizationServerService {
+    /**
+     * Register a new OAuth 2.0 client (Dynamic Client Registration)
+     * Implements RFC 7591 Dynamic Client Registration for OAuth 2.0. Validates client metadata, generates credentials, and persists the client configuration. Requires authorization_code and refresh_token grant types with PKCE support per MCP specification.
+     * @param serverId
+     * @param version
+     * @param requestBody
+     * @returns ClientRegistrationResponseDto Client registered successfully with generated credentials
+     * @throws ApiError
+     */
+    static clientRegistrationControllerRegisterClient(serverId: string, version: string, requestBody: RegisterClientDto): CancelablePromise<ClientRegistrationResponseDto>;
+    /**
+     * Retrieve client registration information
+     * Returns the registration metadata for a client. The client_secret is NOT included in the response for security reasons.
+     * @param clientId
+     * @returns ClientRegistrationResponseDto Client registration information retrieved successfully
+     * @throws ApiError
+     */
+    static clientRegistrationControllerGetClient(clientId: string): CancelablePromise<ClientRegistrationResponseDto>;
+    /**
+     * List all registered clients (Admin)
+     * Returns a list of all registered OAuth clients. Intended for administrative purposes. Client secrets are not included.
+     * @returns ClientRegistrationResponseDto List of registered clients
+     * @throws ApiError
+     */
+    static clientRegistrationControllerListClients(): CancelablePromise<Array<ClientRegistrationResponseDto>>;
+    /**
+     * OAuth 2.0 Authorization Endpoint
+     * Handles authorization requests from MCP clients. Validates the request, stores PKCE parameters, and redirects to the consent screen UI.
+     * @param responseType OAuth 2.0 response type (must be "code" for authorization code flow)
+     * @param clientId Client identifier issued during registration
+     * @param codeChallenge PKCE code challenge derived from the code verifier
+     * @param codeChallengeMethod PKCE code challenge method (S256 for SHA-256)
+     * @param redirectUri Redirect URI where the authorization response will be sent
+     * @param state Opaque state value for CSRF protection
+     * @param resource Resource server URL that the client wants to access
+     * @param serverIdentifier
+     * @param version
+     * @param scope Space-delimited list of scopes being requested
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerAuthorize(responseType: 'code', clientId: string, codeChallenge: string, codeChallengeMethod: string, redirectUri: string, state: string, resource: string, serverIdentifier: string, version: string, scope?: string): CancelablePromise<void>;
+    /**
+     * OAuth 2.0 Authorization Consent Handler
+     * Handles user consent decision. Validates the flow ID (CSRF token), generates an authorization code if approved, and redirects back to the client with the code or error.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerAuthorizeConsent(serverIdentifier: string, version: string, requestBody: ConsentDecisionDto): CancelablePromise<void>;
+    /**
+     * Get metadata for the consent screen from flow ID
+     * Retrieves authorization flow details for the consent screen
+     * @param flowId Unique identifier of the authorization flow
+     * @returns GetConsentMetadataResponseDto Consent metadata retrieved successfully
+     * @throws ApiError
+     */
+    static authorizationControllerGetConsentMetadata(flowId: string): CancelablePromise<GetConsentMetadataResponseDto>;
+    /**
+     * OAuth 2.0 Token Endpoint
+     * Exchanges authorization code for access token. Validates PKCE code_verifier, issues signed JWT access token and refresh token.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns TokenResponseDto Access token issued successfully
+     * @throws ApiError
+     */
+    static authorizationControllerToken(serverIdentifier: string, version: string, requestBody: TokenRequestDto): CancelablePromise<TokenResponseDto>;
+    /**
+     * OAuth 2.0 Token Introspection Endpoint
+     * Introspects an access token to validate it and retrieve its metadata. Verifies JWT signature, expiration, and claims according to RFC 7662.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns IntrospectTokenResponseDto Token introspection response (active true/false with metadata)
+     * @throws ApiError
+     */
+    static authorizationControllerIntrospect(serverIdentifier: string, version: string, requestBody: IntrospectTokenRequestDto): CancelablePromise<IntrospectTokenResponseDto>;
+    /**
+     * RFC 8693 Token Exchange Endpoint
+     * Exchanges MCP JWT access token for downstream system tokens. Validates MCP token, resolves scope mappings, and returns downstream access token with automatic refresh if needed.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns TokenExchangeResponseDto Token exchange successful - returns downstream access token
+     * @throws ApiError
+     */
+    static authorizationControllerTokenExchange(serverIdentifier: string, version: string, requestBody: TokenExchangeRequestDto): CancelablePromise<TokenExchangeResponseDto>;
+    /**
+     * OAuth 2.0 Callback Endpoint for Downstream Systems
+     * Handles callbacks from downstream OAuth providers. Validates the state, exchanges authorization code for tokens, and continues the auth flow.
+     * @param code Authorization code from downstream OAuth provider
+     * @param state State parameter that identifies the connection flow
+     * @param error Error code if authorization failed
+     * @param scope Space-delimited list of scopes that were granted
+     * @param errorDescription Error description if authorization failed
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerCallback(code: string, state: string, error?: string, scope?: string, errorDescription?: string): CancelablePromise<void>;
+    /**
+     * List All Available Scopes
+     * Returns a list of all scopes available in the system. Each scope includes its identifier string and a human-readable description.
+     * @returns ScopesResponseDto List of all available scopes
+     * @throws ApiError
+     */
+    static authorizationControllerGetScopes(): CancelablePromise<ScopesResponseDto>;
+}

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

@@ -0,0 +1,265 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AuthorizationServerService {
+    /**
+     * Register a new OAuth 2.0 client (Dynamic Client Registration)
+     * Implements RFC 7591 Dynamic Client Registration for OAuth 2.0. Validates client metadata, generates credentials, and persists the client configuration. Requires authorization_code and refresh_token grant types with PKCE support per MCP specification.
+     * @param serverId
+     * @param version
+     * @param requestBody
+     * @returns ClientRegistrationResponseDto Client registered successfully with generated credentials
+     * @throws ApiError
+     */
+    static clientRegistrationControllerRegisterClient(serverId, version, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/clients/register/mcp/{serverId}/{version}',
+            path: {
+                'serverId': serverId,
+                'version': version,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid client metadata (missing fields, invalid redirect URIs, unsupported grant types, or PKCE not configured)`,
+                409: `A client with this name is already registered`,
+            },
+        });
+    }
+    /**
+     * Retrieve client registration information
+     * Returns the registration metadata for a client. The client_secret is NOT included in the response for security reasons.
+     * @param clientId
+     * @returns ClientRegistrationResponseDto Client registration information retrieved successfully
+     * @throws ApiError
+     */
+    static clientRegistrationControllerGetClient(clientId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/clients/{clientId}',
+            path: {
+                'clientId': clientId,
+            },
+            errors: {
+                404: `Client not found`,
+            },
+        });
+    }
+    /**
+     * List all registered clients (Admin)
+     * Returns a list of all registered OAuth clients. Intended for administrative purposes. Client secrets are not included.
+     * @returns ClientRegistrationResponseDto List of registered clients
+     * @throws ApiError
+     */
+    static clientRegistrationControllerListClients() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/clients',
+        });
+    }
+    /**
+     * OAuth 2.0 Authorization Endpoint
+     * Handles authorization requests from MCP clients. Validates the request, stores PKCE parameters, and redirects to the consent screen UI.
+     * @param responseType OAuth 2.0 response type (must be "code" for authorization code flow)
+     * @param clientId Client identifier issued during registration
+     * @param codeChallenge PKCE code challenge derived from the code verifier
+     * @param codeChallengeMethod PKCE code challenge method (S256 for SHA-256)
+     * @param redirectUri Redirect URI where the authorization response will be sent
+     * @param state Opaque state value for CSRF protection
+     * @param resource Resource server URL that the client wants to access
+     * @param serverIdentifier
+     * @param version
+     * @param scope Space-delimited list of scopes being requested
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerAuthorize(responseType, clientId, codeChallenge, codeChallengeMethod, redirectUri, state, resource, serverIdentifier, version, scope) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/authorize/mcp/{serverIdentifier}/{version}',
+            path: {
+                'serverIdentifier': serverIdentifier,
+                'version': version,
+            },
+            query: {
+                'response_type': responseType,
+                'scope': scope,
+                'client_id': clientId,
+                'code_challenge': codeChallenge,
+                'code_challenge_method': codeChallengeMethod,
+                'redirect_uri': redirectUri,
+                'state': state,
+                'resource': resource,
+            },
+            errors: {
+                302: `Redirects to consent screen with authorization request ID`,
+                400: `Invalid authorization request parameters`,
+                404: `MCP server or client not found`,
+            },
+        });
+    }
+    /**
+     * OAuth 2.0 Authorization Consent Handler
+     * Handles user consent decision. Validates the flow ID (CSRF token), generates an authorization code if approved, and redirects back to the client with the code or error.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerAuthorizeConsent(serverIdentifier, version, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/authorize/mcp/{serverIdentifier}/{version}',
+            path: {
+                'serverIdentifier': serverIdentifier,
+                'version': version,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                302: `Redirects to client redirect_uri with authorization code or error`,
+                400: `Invalid consent decision or flow state`,
+                401: `Authorization flow has already been used`,
+                404: `Authorization flow not found`,
+            },
+        });
+    }
+    /**
+     * Get metadata for the consent screen from flow ID
+     * Retrieves authorization flow details for the consent screen
+     * @param flowId Unique identifier of the authorization flow
+     * @returns GetConsentMetadataResponseDto Consent metadata retrieved successfully
+     * @throws ApiError
+     */
+    static authorizationControllerGetConsentMetadata(flowId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/consent/{flowId}',
+            path: {
+                'flowId': flowId,
+            },
+            errors: {
+                401: `Authentication required to access consent metadata`,
+                404: `Authorization flow not found`,
+            },
+        });
+    }
+    /**
+     * OAuth 2.0 Token Endpoint
+     * Exchanges authorization code for access token. Validates PKCE code_verifier, issues signed JWT access token and refresh token.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns TokenResponseDto Access token issued successfully
+     * @throws ApiError
+     */
+    static authorizationControllerToken(serverIdentifier, version, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/token/mcp/{serverIdentifier}/{version}',
+            path: {
+                'serverIdentifier': serverIdentifier,
+                'version': version,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid token request parameters`,
+                401: `Invalid authorization code, code_verifier, or expired code`,
+            },
+        });
+    }
+    /**
+     * OAuth 2.0 Token Introspection Endpoint
+     * Introspects an access token to validate it and retrieve its metadata. Verifies JWT signature, expiration, and claims according to RFC 7662.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns IntrospectTokenResponseDto Token introspection response (active true/false with metadata)
+     * @throws ApiError
+     */
+    static authorizationControllerIntrospect(serverIdentifier, version, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/introspect/mcp/{serverIdentifier}/{version}',
+            path: {
+                'serverIdentifier': serverIdentifier,
+                'version': version,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid introspection request parameters`,
+            },
+        });
+    }
+    /**
+     * RFC 8693 Token Exchange Endpoint
+     * Exchanges MCP JWT access token for downstream system tokens. Validates MCP token, resolves scope mappings, and returns downstream access token with automatic refresh if needed.
+     * @param serverIdentifier
+     * @param version
+     * @param requestBody
+     * @returns TokenExchangeResponseDto Token exchange successful - returns downstream access token
+     * @throws ApiError
+     */
+    static authorizationControllerTokenExchange(serverIdentifier, version, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v1/auth/token-exchange/mcp/{serverIdentifier}/{version}',
+            path: {
+                'serverIdentifier': serverIdentifier,
+                'version': version,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid token exchange request parameters`,
+                401: `Invalid or expired MCP JWT`,
+                403: `Insufficient scope - requested scope not entitled`,
+                404: `Connection not found`,
+            },
+        });
+    }
+    /**
+     * OAuth 2.0 Callback Endpoint for Downstream Systems
+     * Handles callbacks from downstream OAuth providers. Validates the state, exchanges authorization code for tokens, and continues the auth flow.
+     * @param code Authorization code from downstream OAuth provider
+     * @param state State parameter that identifies the connection flow
+     * @param error Error code if authorization failed
+     * @param scope Space-delimited list of scopes that were granted
+     * @param errorDescription Error description if authorization failed
+     * @returns void
+     * @throws ApiError
+     */
+    static authorizationControllerCallback(code, state, error, scope, errorDescription) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/callback',
+            query: {
+                'code': code,
+                'state': state,
+                'error': error,
+                'scope': scope,
+                'error_description': errorDescription,
+            },
+            errors: {
+                302: `Redirects to next step in the authorization flow`,
+                400: `Invalid callback parameters or state`,
+                404: `Connection flow not found for provided state`,
+            },
+        });
+    }
+    /**
+     * List All Available Scopes
+     * Returns a list of all scopes available in the system. Each scope includes its identifier string and a human-readable description.
+     * @returns ScopesResponseDto List of all available scopes
+     * @throws ApiError
+     */
+    static authorizationControllerGetScopes() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v1/auth/scopes',
+        });
+    }
+}