@taico/client 0.1.0 → 0.2.1

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,51 @@
+import { BaseClient, ClientConfig } from './base-client.js';
+import type { AgentListResponseDto, AgentResponseDto, AgentToolPermissionResponseDto, CreateAgentDto, PatchAgentDto, UpsertAgentToolPermissionDto } 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>;
+    /** List tool permissions for an agent */
+    AgentToolPermissionsController_listAgentToolPermissions(params: {
+        actorId: string;
+        signal?: AbortSignal;
+    }): Promise<AgentToolPermissionResponseDto[]>;
+    /** Create or replace an agent tool permission assignment */
+    AgentToolPermissionsController_upsertAgentToolPermission(params: {
+        actorId: string;
+        serverId: string;
+        body: UpsertAgentToolPermissionDto;
+        signal?: AbortSignal;
+    }): Promise<AgentToolPermissionResponseDto>;
+    /** Delete an agent tool permission assignment */
+    AgentToolPermissionsController_deleteAgentToolPermission(params: {
+        actorId: string;
+        serverId: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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