@applica-software-guru/persona-sdk 0.0.1-preview6 → 0.1.2

package/src/features/types.ts

@@ -0,0 +1,25 @@
+import { FeatureConfiguration, McpServerConfiguration } from '../agents/types';
+import { ToolDefinition } from '../agents/types';
+
+export type FeatureType = 'mcp' | 'flag' | 'skill';
+
+export interface FeatureCredentialsConfiguration {
+  requireCredentials?: boolean;
+  credentialsType?: string;
+}
+
+export interface FeatureTemplate {
+  id?: string;
+  projectId?: string;
+  type?: FeatureType;
+  name?: string;
+  description?: string;
+  logoUrl?: string;
+  configuration?: FeatureConfiguration;
+  credentialsConfiguration?: FeatureCredentialsConfiguration;
+}
+
+export interface McpToolsResponse {
+  tools?: ToolDefinition[];
+  error?: string;
+}

package/src/http-api.ts

@@ -0,0 +1,95 @@
+import { ApiException } from './exceptions';
+import { AuthenticationProvider } from './auth/authentication-provider';
+import { ApiKeyAuthenticationProvider } from './auth/api-key-auth';
+
+export abstract class HttpApi {
+  private readonly baseUrl: string;
+  private readonly authProvider: AuthenticationProvider;
+
+  constructor(baseUrl: string, apiKey: string | AuthenticationProvider) {
+    this.baseUrl = baseUrl;
+    this.authProvider = typeof apiKey === 'string' ? new ApiKeyAuthenticationProvider(apiKey) : apiKey;
+  }
+
+  protected getBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  protected getAuthProvider(): AuthenticationProvider {
+    return this.authProvider;
+  }
+
+  private buildHeaders(): Headers {
+    const headers = new Headers();
+    headers.set('Content-Type', 'application/json');
+    this.authProvider.applyHeaders(headers);
+    return headers;
+  }
+
+  private buildUrl(path: string, params?: Record<string, unknown>): string {
+    const url = new URL(this.baseUrl + path);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+
+  private async handleResponse<T>(response: Response): Promise<T> {
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiException(response.status, body);
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : (undefined as T);
+  }
+
+  protected async httpGet<T>(path: string, params?: Record<string, unknown>): Promise<T> {
+    const response = await fetch(this.buildUrl(path, params), {
+      method: 'GET',
+      headers: this.buildHeaders(),
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  protected async httpPost<T>(path: string, body?: unknown): Promise<T> {
+    const response = await fetch(this.baseUrl + path, {
+      method: 'POST',
+      headers: this.buildHeaders(),
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  protected async httpPut<T>(path: string, body: unknown): Promise<T> {
+    const response = await fetch(this.baseUrl + path, {
+      method: 'PUT',
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body),
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  protected async httpPatch<T>(path: string, body: unknown): Promise<T> {
+    const response = await fetch(this.baseUrl + path, {
+      method: 'PATCH',
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body),
+    });
+    return this.handleResponse<T>(response);
+  }
+
+  protected async httpDelete(path: string): Promise<void> {
+    const response = await fetch(this.baseUrl + path, {
+      method: 'DELETE',
+      headers: this.buildHeaders(),
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiException(response.status, body);
+    }
+  }
+}

package/src/index.ts

@@ -1,4 +1,153 @@
-export * from './runtime';
-export * from './logging';
-export * from './protocol';
-export * from './types';
+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, 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,
+  ModelName,
+  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,
+} 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 type { Revision as RevisionType } from './revisions/types';

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

@@ -0,0 +1,38 @@
+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 params: Record<string, unknown> = { page, size };
+    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,47 @@
+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): Promise<Paginated<KnowledgeBase>> {
+    const params: Record<string, unknown> = { page, size };
+    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/missions/missions-api.ts

@@ -0,0 +1,60 @@
+import { HttpApi } from '../http-api';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { Mission } from './types';
+
+export class MissionsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(projectId?: string | null, status?: string | null, page?: number, size?: number): Promise<Mission[]> {
+    const params: Record<string, unknown> = { page, size };
+    if (projectId) params.projectId = projectId;
+    if (status) params.status = status;
+    return this.httpGet<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,81 @@
+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 { SessionsApi } from './sessions/sessions-api';
+import { MissionsApi } from './missions/missions-api';
+
+export class PersonaSdk {
+  private readonly baseUrl: string;
+  private readonly workflowsBaseUrl: string;
+
+  constructor(baseUrl: string, workflowsBaseUrl: string) {
+    this.baseUrl = baseUrl;
+    this.workflowsBaseUrl = workflowsBaseUrl;
+  }
+
+  projects(apiKey: string): ProjectsApi;
+  projects(authProvider: AuthenticationProvider): ProjectsApi;
+  projects(auth: string | AuthenticationProvider): ProjectsApi {
+    return new ProjectsApi(this.baseUrl, auth);
+  }
+
+  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);
+  }
+
+  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);
+  }
+}

package/src/projects/projects-api.ts

@@ -0,0 +1,55 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import {
+  Project,
+  ProjectCreateRequest,
+  ProjectUpdateRequest,
+  ProjectSubscription,
+  ChangeProjectSubscriptionPlanRequest,
+  AddProjectSubscriptionCreditsRequest,
+} from './types';
+
+export class ProjectsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword: string | null, page: number, size: number): Promise<Paginated<Project>> {
+    const params: Record<string, unknown> = { page, size };
+    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 getSubscription(projectId: string): Promise<ProjectSubscription> {
+    return this.httpGet<ProjectSubscription>('/projects/' + projectId + '/subscription');
+  }
+
+  async changeSubscriptionPlan(projectId: string, request: ChangeProjectSubscriptionPlanRequest): Promise<ProjectSubscription> {
+    return this.httpPost<ProjectSubscription>('/projects/' + projectId + '/subscription/plan', request);
+  }
+
+  async addSubscriptionCredits(projectId: string, request: AddProjectSubscriptionCreditsRequest): Promise<ProjectSubscription> {
+    return this.httpPost<ProjectSubscription>('/projects/' + projectId + '/subscription/credits', request);
+  }
+}