@applica-software-guru/persona-sdk 0.1.100 → 0.1.101

package/src/index.ts

@@ -1,7 +1,179 @@
-export * from './runtime';
-export * from './logging';
-export * from './protocol';
-export * from './types';
-export * from './tools';
-export * from './storage';
-export * from './projects';
+export { PersonaSdk } from './persona-sdk';
+export { ApiException } from './exceptions';
+export type { Paginated } from './paginated';
+export { ApiKeyAuthenticationProvider, BearerTokenAuthenticationProvider } from './auth';
+export type { AuthenticationProvider } from './auth';
+export { ProjectsApi } from './projects/projects-api';
+export type { Project, ProjectCreateRequest, ProjectUpdateRequest, ProjectDuplicateRequest, ProjectSubscription, ChangeProjectSubscriptionPlanRequest, AddProjectSubscriptionCreditsRequest } from './projects/types';
+export { AgentsApi } from './agents/agents-api';
+export type {
+  Agent,
+  AgentCreateRequest,
+  AgentUpdateRequest,
+  AgentProtocol,
+  CollaborationConfiguration,
+  Collaborator,
+  Feature,
+  FeatureConfiguration,
+  McpServerConfiguration,
+  FlagConfiguration,
+  SkillConfiguration,
+  SkillResource,
+  HttpTransport,
+  StdioTransport,
+  Transport,
+  KnowledgeConfiguration,
+  KnowledgeType,
+  LanguageCode,
+  ModelConfiguration,
+  NetworkConfiguration,
+  OrchestrationConfiguration,
+  OrchestrationAgent,
+  SynthesizerConfiguration,
+  SynthesizerName,
+  SynthesizerVoice,
+  TranscriberConfiguration,
+  TranscriberName,
+  TelegramConfiguration,
+  TwilioConfiguration,
+  Variable,
+  VariableSource,
+  WakeupConfiguration,
+  WhatsAppConfiguration,
+  Tool,
+  ToolType,
+  ToolConfig,
+  ToolLocalConfig,
+  ToolRemoteConfig,
+  ToolDefinition,
+  ToolkitConfiguration,
+  StmConfiguration,
+  StmType,
+  Revision,
+  AgentType,
+  ReasoningEffort,
+  ModelProvider,
+  CollaborationMode,
+  ContextManagementConfiguration,
+  AttachmentsPreprocessorConfiguration,
+  AttachmentsPreprocessorImageHandling,
+} from './agents/types';
+export { SessionsApi } from './sessions/sessions-api';
+export type {
+  Session,
+  GenerationRequest,
+  GenerationResponse,
+  Message,
+  AgentResponse,
+  AgentContext,
+  CommittedUsage,
+  UsageCost,
+  SessionFile,
+  FunctionCall,
+  FunctionResponse,
+  Image,
+  Source,
+  SourceChunk,
+  TransferAction,
+  CollaborationMode as SessionCollaborationMode,
+} from './sessions/types';
+export { KnowledgeBasesApi } from './knowledges/knowledge-bases-api';
+export { KnowledgeBaseDocumentsApi } from './knowledges/knowledge-base-documents-api';
+export type {
+  KnowledgeBase,
+  KnowledgeBaseCreateRequest,
+  KnowledgeBaseUpdateRequest,
+  KnowledgeBaseDocument,
+  KnowledgeBaseDocumentUploadRequest,
+  KnowledgeBaseDocumentStatus,
+  KnowledgeBaseQuality,
+  KnowledgeBaseChunkSize,
+  EmbeddingModelName,
+  DocumentExtractorName,
+  ChunkResult,
+  SearchChunksRequest,
+} from './knowledges/types';
+export { WorkflowsApi } from './workflows/workflows-api';
+export { WorkflowExecutionsApi } from './workflows/workflow-executions-api';
+export type {
+  Workflow,
+  Node,
+  NodeType,
+  StartNode,
+  Connection,
+  Handle,
+  Position,
+  Execution,
+  ExecutionStatus,
+  Step,
+  RunResult,
+  NodeExecutionResult,
+  WorkflowTrigger,
+  WorkflowVariable,
+  VariableType,
+  VariableDirection,
+  WorkflowResult,
+  ExecuteRequest,
+  AgentValue,
+  ContentItem,
+  ContentItemFile,
+  ContentValue,
+  Ref,
+} from './workflows/types';
+export { CredentialsApi } from './credentials/credentials-api';
+export type {
+  Credentials,
+  AuthorizeRequest,
+  AuthorizeResponse,
+  OAuth2CallbackResponse,
+  OAuth2State,
+} from './credentials/types';
+export { TriggersApi } from './triggers/triggers-api';
+export { TriggerExecutionsApi } from './triggers/trigger-executions-api';
+export type {
+  Trigger,
+  TriggerSource,
+  TriggerSourceType,
+  TriggerSourceConfiguration,
+  GmailTriggerSourceConfiguration,
+  ImapTriggerSourceConfiguration,
+  TriggerDestination,
+  TriggerExecutionResult,
+} from './triggers/types';
+export { FeaturesApi } from './features/features-api';
+export { FeatureTemplatesApi } from './features/feature-templates-api';
+export type {
+  FeatureTemplate,
+  FeatureType,
+  FeatureCredentialsConfiguration,
+  McpToolsResponse,
+} from './features/types';
+export { MissionsApi } from './missions/missions-api';
+export type { Mission, MissionStatus } from './missions/types';
+export { ServicePricesApi } from './service-prices/service-prices-api';
+export type { ServicePrice } from './service-prices/types';
+export { KnownModelsApi } from './known-models/known-models-api';
+export type { KnownModel } from './known-models/types';
+export type { Revision as RevisionType } from './revisions/types';
+export { BillingClient } from './billing/billing-client';
+export { ValuesApi } from './values/values-api';
+export type {
+  Customer,
+  Subscription,
+  Invoice,
+  LineItem,
+  Usage as BillingUsage,
+  Payment,
+  CreateCustomerRequest,
+  UpdateCustomerRequest,
+  CreateSubscriptionRequest,
+  UpgradeSubscriptionRequest,
+  DowngradeSubscriptionRequest,
+  MentorizeSubscriptionRequest,
+  UsageStats,
+  UsageTotals,
+  UsageDailyEntry,
+  UsageModelEntry,
+  UsageDetail,
+  UsagePage,
+} from './billing/types';

package/src/knowledges/knowledge-base-documents-api.ts

@@ -0,0 +1,39 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import {
+  KnowledgeBaseDocument,
+  KnowledgeBaseDocumentUploadRequest,
+} from './types';
+
+export class KnowledgeBaseDocumentsApi extends HttpApi {
+  private readonly knowledgeBaseId: string;
+
+  constructor(baseUrl: string, auth: string | AuthenticationProvider, knowledgeBaseId: string) {
+    super(baseUrl, auth);
+    this.knowledgeBaseId = knowledgeBaseId;
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number): Promise<Paginated<KnowledgeBaseDocument>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<KnowledgeBaseDocument>>('/knowledge-bases/' + this.knowledgeBaseId + '/documents', params);
+  }
+
+  async upload(request: KnowledgeBaseDocumentUploadRequest): Promise<KnowledgeBaseDocument> {
+    return this.httpPost<KnowledgeBaseDocument>('/knowledge-bases/' + this.knowledgeBaseId + '/documents', request);
+  }
+
+  async get(documentId: string): Promise<KnowledgeBaseDocument> {
+    return this.httpGet<KnowledgeBaseDocument>('/knowledge-bases/' + this.knowledgeBaseId + '/documents/' + documentId);
+  }
+
+  async reprocess(documentId: string): Promise<KnowledgeBaseDocument> {
+    return this.httpPost<KnowledgeBaseDocument>('/knowledge-bases/' + this.knowledgeBaseId + '/documents', { document_id: documentId });
+  }
+
+  async remove(documentId: string): Promise<void> {
+    await this.httpDelete('/knowledge-bases/' + this.knowledgeBaseId + '/documents/' + documentId);
+  }
+}

package/src/knowledges/knowledge-bases-api.ts

@@ -0,0 +1,48 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import {
+  KnowledgeBase,
+  KnowledgeBaseCreateRequest,
+  KnowledgeBaseUpdateRequest,
+  ChunkResult,
+  SearchChunksRequest,
+} from './types';
+import { KnowledgeBaseDocumentsApi } from './knowledge-base-documents-api';
+
+export class KnowledgeBasesApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number, extraParams?: Record<string, string>): Promise<Paginated<KnowledgeBase>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s, ...extraParams };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<KnowledgeBase>>('/knowledge-bases', params);
+  }
+
+  async get(id: string): Promise<KnowledgeBase> {
+    return this.httpGet<KnowledgeBase>('/knowledge-bases/' + id);
+  }
+
+  async create(request: KnowledgeBaseCreateRequest): Promise<KnowledgeBase> {
+    return this.httpPost<KnowledgeBase>('/knowledge-bases', request);
+  }
+
+  async update(request: KnowledgeBaseUpdateRequest): Promise<KnowledgeBase> {
+    return this.httpPut<KnowledgeBase>('/knowledge-bases/' + request.id, request);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.httpDelete('/knowledge-bases/' + id);
+  }
+
+  documents(knowledgeBaseId: string): KnowledgeBaseDocumentsApi {
+    return new KnowledgeBaseDocumentsApi(this.getBaseUrl(), this.getAuthProvider(), knowledgeBaseId);
+  }
+
+  async searchChunks(id: string, request: SearchChunksRequest): Promise<ChunkResult[]> {
+    return this.httpPost<ChunkResult[]>('/knowledge-bases/' + id + '/search', request);
+  }
+}

package/src/knowledges/types.ts

@@ -0,0 +1,70 @@
+export type KnowledgeBaseQuality = 'extremely_high' | 'very_high' | 'high' | 'medium' | 'low';
+
+export type KnowledgeBaseChunkSize = 'small' | 'medium' | 'large';
+
+export type EmbeddingModelName = 'text-multilingual-embedding-002' | 'gemini-embedding-001';
+
+export type DocumentExtractorName = 'fitz' | 'document-ai' | 'gemini' | 'markdown';
+
+export type KnowledgeBaseDocumentStatus = 'pending' | 'processing' | 'completed' | 'failed';
+
+export interface KnowledgeBase {
+  id?: string;
+  projectId?: string;
+  name?: string;
+  description?: string;
+  quality?: KnowledgeBaseQuality;
+  chunkSize?: KnowledgeBaseChunkSize;
+  embeddingModel?: EmbeddingModelName;
+}
+
+export interface KnowledgeBaseCreateRequest {
+  name?: string;
+  description?: string;
+  quality?: KnowledgeBaseQuality;
+  chunkSize?: KnowledgeBaseChunkSize;
+  embeddingModel?: EmbeddingModelName;
+}
+
+export interface KnowledgeBaseUpdateRequest {
+  id?: string;
+  name?: string;
+  description?: string;
+}
+
+export interface KnowledgeBaseDocument {
+  id?: string;
+  knowledgeBaseId?: string;
+  path?: string;
+  name?: string;
+  size?: number;
+  contentType?: string;
+  status?: KnowledgeBaseDocumentStatus;
+  progress?: number;
+  extractor?: DocumentExtractorName;
+  error?: string;
+  metadata?: Record<string, unknown>;
+  totalPages?: number;
+  callbackUrl?: string;
+}
+
+export interface KnowledgeBaseDocumentUploadRequest {
+  uri?: string;
+  base64?: string;
+  name?: string;
+  extractor?: DocumentExtractorName;
+  callbackUrl?: string;
+}
+
+export interface ChunkResult {
+  id?: string;
+  text?: string;
+  score?: number;
+  metadata?: Record<string, unknown>;
+  documentId?: string;
+}
+
+export interface SearchChunksRequest {
+  query?: string;
+  limit?: number;
+}

package/src/known-models/known-models-api.ts

@@ -0,0 +1,33 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { KnownModel } from './types';
+
+export class KnownModelsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number, extraParams?: Record<string, string>): Promise<Paginated<KnownModel>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s, ...extraParams };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<KnownModel>>('/known-models', params);
+  }
+
+  async get(id: string): Promise<KnownModel> {
+    return this.httpGet<KnownModel>('/known-models/' + id);
+  }
+
+  async create(knownModel: KnownModel): Promise<KnownModel> {
+    return this.httpPost<KnownModel>('/known-models', knownModel);
+  }
+
+  async update(id: string, knownModel: KnownModel): Promise<KnownModel> {
+    return this.httpPut<KnownModel>('/known-models/' + id, knownModel);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.httpDelete('/known-models/' + id);
+  }
+}

package/src/known-models/types.ts

@@ -0,0 +1,7 @@
+export interface KnownModel {
+  id?: string;
+  provider?: string;
+  modelName?: string;
+  label?: string;
+  deprecated?: boolean;
+}

package/src/missions/missions-api.ts

@@ -0,0 +1,62 @@
+import { HttpApi } from '../http-api';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { Paginated } from '../paginated';
+import { Mission } from './types';
+
+export class MissionsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number, status?: string | null): Promise<Paginated<Mission>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s };
+    if (keyword) params.keyword = keyword;
+    if (status) params.status = status;
+    return this.httpGet<Paginated<Mission>>('/missions', params);
+  }
+
+  async get(missionId: string): Promise<Mission> {
+    return this.httpGet<Mission>('/missions/' + missionId);
+  }
+
+  async create(mission: Mission): Promise<Mission> {
+    return this.httpPost<Mission>('/missions', mission);
+  }
+
+  async update(missionId: string, mission: Mission): Promise<Mission> {
+    return this.httpPut<Mission>('/missions/' + missionId, mission);
+  }
+
+  async remove(missionId: string): Promise<void> {
+    await this.httpDelete('/missions/' + missionId);
+  }
+
+  async generate(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/generate');
+  }
+
+  async execute(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/execute');
+  }
+
+  async retry(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/retry');
+  }
+
+  async replan(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/replan');
+  }
+
+  async sendInstruction(missionId: string, instruction: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/instructions', { instruction });
+  }
+
+  async stop(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/stop');
+  }
+
+  async resume(missionId: string): Promise<Mission> {
+    return this.httpPost<Mission>('/missions/' + missionId + '/continue');
+  }
+}

package/src/missions/types.ts

@@ -0,0 +1,25 @@
+export type MissionStatus =
+  | 'draft'
+  | 'planned'
+  | 'active'
+  | 'review'
+  | 'paused'
+  | 'completed'
+  | 'failed'
+  | 'cancelled';
+
+export interface Mission {
+  id?: string;
+  projectId?: string;
+  name?: string;
+  goal?: string;
+  status?: MissionStatus;
+  plannerAgentId?: string;
+  workerAgents?: Record<string, unknown>[];
+  steps?: Record<string, unknown>[];
+  currentStepId?: string;
+  version?: number;
+  userInstructions?: string[];
+  createdAt?: string;
+  updatedAt?: string;
+}

package/src/paginated.ts

@@ -0,0 +1,6 @@
+export interface Paginated<T> {
+  items: T[];
+  total: number;
+  page: number;
+  size: number;
+}

package/src/persona-sdk.ts

@@ -0,0 +1,104 @@
+import { AuthenticationProvider } from './auth/authentication-provider';
+import { ProjectsApi } from './projects/projects-api';
+import { AgentsApi } from './agents/agents-api';
+import { KnowledgeBasesApi } from './knowledges/knowledge-bases-api';
+import { WorkflowsApi } from './workflows/workflows-api';
+import { CredentialsApi } from './credentials/credentials-api';
+import { FeaturesApi } from './features/features-api';
+import { TriggersApi } from './triggers/triggers-api';
+import { ServicePricesApi } from './service-prices/service-prices-api';
+import { KnownModelsApi } from './known-models/known-models-api';
+import { SessionsApi } from './sessions/sessions-api';
+import { MissionsApi } from './missions/missions-api';
+import { BillingClient } from './billing/billing-client';
+import { ValuesApi } from './values/values-api';
+
+export class PersonaSdk {
+  private readonly baseUrl: string;
+  private readonly workflowsBaseUrl: string;
+  private readonly billingBaseUrl: string;
+
+  constructor(baseUrl: string, workflowsBaseUrl: string, billingBaseUrl?: string) {
+    this.baseUrl = baseUrl;
+    this.workflowsBaseUrl = workflowsBaseUrl;
+    this.billingBaseUrl = billingBaseUrl || 'https://persona.applica.guru/billing';
+  }
+
+  projects(apiKey: string): ProjectsApi;
+  projects(authProvider: AuthenticationProvider): ProjectsApi;
+  projects(auth: string | AuthenticationProvider): ProjectsApi {
+    return new ProjectsApi(this.baseUrl, auth, this.billingBaseUrl);
+  }
+
+  agents(apiKey: string): AgentsApi;
+  agents(authProvider: AuthenticationProvider): AgentsApi;
+  agents(auth: string | AuthenticationProvider): AgentsApi {
+    return new AgentsApi(this.baseUrl, auth);
+  }
+
+  knowledgeBases(apiKey: string): KnowledgeBasesApi;
+  knowledgeBases(authProvider: AuthenticationProvider): KnowledgeBasesApi;
+  knowledgeBases(auth: string | AuthenticationProvider): KnowledgeBasesApi {
+    return new KnowledgeBasesApi(this.baseUrl, auth);
+  }
+
+  workflows(apiKey: string): WorkflowsApi;
+  workflows(authProvider: AuthenticationProvider): WorkflowsApi;
+  workflows(auth: string | AuthenticationProvider): WorkflowsApi {
+    return new WorkflowsApi(this.workflowsBaseUrl, auth);
+  }
+
+  credentials(apiKey: string): CredentialsApi;
+  credentials(authProvider: AuthenticationProvider): CredentialsApi;
+  credentials(auth: string | AuthenticationProvider): CredentialsApi {
+    return new CredentialsApi(this.baseUrl, auth);
+  }
+
+  features(apiKey: string): FeaturesApi;
+  features(authProvider: AuthenticationProvider): FeaturesApi;
+  features(auth: string | AuthenticationProvider): FeaturesApi {
+    return new FeaturesApi(this.baseUrl, auth);
+  }
+
+  triggers(apiKey: string): TriggersApi;
+  triggers(authProvider: AuthenticationProvider): TriggersApi;
+  triggers(auth: string | AuthenticationProvider): TriggersApi {
+    return new TriggersApi(this.baseUrl, auth);
+  }
+
+  servicePrices(apiKey: string): ServicePricesApi;
+  servicePrices(authProvider: AuthenticationProvider): ServicePricesApi;
+  servicePrices(auth: string | AuthenticationProvider): ServicePricesApi {
+    return new ServicePricesApi(this.baseUrl, auth);
+  }
+
+  knownModels(apiKey: string): KnownModelsApi;
+  knownModels(authProvider: AuthenticationProvider): KnownModelsApi;
+  knownModels(auth: string | AuthenticationProvider): KnownModelsApi {
+    return new KnownModelsApi(this.baseUrl, auth);
+  }
+
+  sessions(apiKey: string): SessionsApi;
+  sessions(authProvider: AuthenticationProvider): SessionsApi;
+  sessions(auth: string | AuthenticationProvider): SessionsApi {
+    return new SessionsApi(this.baseUrl, auth);
+  }
+
+  missions(apiKey: string): MissionsApi;
+  missions(authProvider: AuthenticationProvider): MissionsApi;
+  missions(auth: string | AuthenticationProvider): MissionsApi {
+    return new MissionsApi(this.baseUrl, auth);
+  }
+
+  billing(apiKey: string): BillingClient;
+  billing(authProvider: AuthenticationProvider): BillingClient;
+  billing(auth: string | AuthenticationProvider): BillingClient {
+    return new BillingClient(this.billingBaseUrl, auth);
+  }
+
+  values(apiKey: string): ValuesApi;
+  values(authProvider: AuthenticationProvider): ValuesApi;
+  values(auth: string | AuthenticationProvider): ValuesApi {
+    return new ValuesApi(this.baseUrl, auth);
+  }
+}

package/src/projects/projects-api.ts

@@ -0,0 +1,90 @@
+import { HttpApi } from '../http-api';
+import { ApiException } from '../exceptions';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import {
+  Project,
+  ProjectCreateRequest,
+  ProjectUpdateRequest,
+  ProjectDuplicateRequest,
+  ProjectSubscription,
+  ChangeProjectSubscriptionPlanRequest,
+  AddProjectSubscriptionCreditsRequest,
+  SetProjectSubscriptionInfiniteCreditsRequest,
+} from './types';
+
+export class ProjectsApi extends HttpApi {
+  private readonly billingBaseUrl: string;
+
+  constructor(baseUrl: string, auth: string | AuthenticationProvider, billingBaseUrl?: string) {
+    super(baseUrl, auth);
+    this.billingBaseUrl = (billingBaseUrl || baseUrl).replace(/\/$/, '');
+  }
+
+  async list(keyword: string | null, page: number, size: number): Promise<Paginated<Project>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<Project>>('/projects', params);
+  }
+
+  async get(projectId: string): Promise<Project> {
+    return this.httpGet<Project>('/projects/' + projectId);
+  }
+
+  async getMine(): Promise<Project> {
+    return this.httpGet<Project>('/projects/mine');
+  }
+
+  async create(request: ProjectCreateRequest): Promise<Project> {
+    return this.httpPost<Project>('/projects', request);
+  }
+
+  async update(request: ProjectUpdateRequest): Promise<Project> {
+    return this.httpPut<Project>('/projects/' + request.projectId, request);
+  }
+
+  async remove(projectId: string): Promise<void> {
+    await this.httpDelete('/projects/' + projectId);
+  }
+
+  async duplicate(projectId: string, request: ProjectDuplicateRequest): Promise<Project> {
+    return this.httpPost<Project>('/projects/' + projectId + '/actions/duplicate', request);
+  }
+
+  async getSubscription(projectId: string): Promise<ProjectSubscription> {
+    return this.billingRequest<ProjectSubscription>('/projects/' + projectId + '/subscription', 'GET');
+  }
+
+  async changeSubscriptionPlan(projectId: string, request: ChangeProjectSubscriptionPlanRequest): Promise<ProjectSubscription> {
+    return this.billingRequest<ProjectSubscription>('/projects/' + projectId + '/subscription/actions/change-plan', 'POST', request);
+  }
+
+  async addSubscriptionCredits(projectId: string, request: AddProjectSubscriptionCreditsRequest): Promise<ProjectSubscription> {
+    return this.billingRequest<ProjectSubscription>('/projects/' + projectId + '/subscription/actions/add-credits', 'POST', request);
+  }
+
+  async setInfiniteCredits(projectId: string, request: SetProjectSubscriptionInfiniteCreditsRequest): Promise<ProjectSubscription> {
+    return this.billingRequest<ProjectSubscription>('/projects/' + projectId + '/subscription/actions/set-infinite-credits', 'POST', request);
+  }
+
+  private async billingRequest<T>(path: string, method: string, body?: unknown): Promise<T> {
+    const headers = new Headers();
+    headers.set('Content-Type', 'application/json');
+    this.getAuthProvider().applyHeaders(headers);
+
+    const response = await fetch(this.billingBaseUrl + path, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new ApiException(response.status, text);
+    }
+
+    const text = await response.text();
+    return text ? JSON.parse(text) : (undefined as T);
+  }
+}