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

package/src/projects/types.ts

@@ -0,0 +1,42 @@
+export interface Project {
+  id?: string;
+  name?: string;
+  tag?: string;
+  apiKey?: string;
+}
+
+export interface ProjectCreateRequest {
+  name: string;
+  tag?: string;
+}
+
+export interface ProjectUpdateRequest {
+  projectId: string;
+  name?: string;
+  tag?: string;
+}
+
+export interface ProjectSubscription {
+  id?: string;
+  projectId?: string;
+  owner?: string;
+  planType?: string;
+  status?: string;
+  startDate?: string;
+  planCredits?: number;
+  extraCredits?: number;
+  keepCreditsOnRenew?: boolean;
+  endDate?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  stripeCustomerId?: string;
+  stripeSubscriptionId?: string;
+}
+
+export interface ChangeProjectSubscriptionPlanRequest {
+  toPlanType: string;
+}
+
+export interface AddProjectSubscriptionCreditsRequest {
+  credits: number;
+}

package/src/revisions/types.ts

@@ -0,0 +1,9 @@
+export interface Revision {
+  id?: string;
+  entityId?: string;
+  entityType?: string;
+  timestamp?: string;
+  data?: Record<string, unknown>;
+  userId?: string;
+  comment?: string;
+}

package/src/service-prices/service-prices-api.ts

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

package/src/service-prices/types.ts

@@ -0,0 +1,8 @@
+export interface ServicePrice {
+  id?: string;
+  service?: string;
+  cost?: number;
+  unit?: string;
+  markupPercentage?: number;
+  fixedPrice?: number;
+}

package/src/sessions/sessions-api.ts

@@ -0,0 +1,55 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import {
+  Session,
+  GenerationRequest,
+  GenerationResponse,
+  Message,
+  CommittedUsage,
+} from './types';
+
+export class SessionsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(
+    keyword?: string | null,
+    status?: string | null,
+    agentId?: string | null,
+    userId?: string | null,
+    page?: number,
+    size?: number,
+  ): Promise<Paginated<Session>> {
+    const params: Record<string, unknown> = { page, size };
+    if (keyword) params.keyword = keyword;
+    if (status) params.status = status;
+    if (agentId) params.agentId = agentId;
+    if (userId) params.userId = userId;
+    return this.httpGet<Paginated<Session>>('/sessions', params);
+  }
+
+  async get(sessionId: string): Promise<Session> {
+    return this.httpGet<Session>('/sessions/' + sessionId);
+  }
+
+  async getUsage(sessionId: string): Promise<CommittedUsage[]> {
+    return this.httpGet<CommittedUsage[]>('/sessions/' + sessionId + '/usage');
+  }
+
+  async generateMessage(code: string, request: GenerationRequest): Promise<GenerationResponse> {
+    return this.httpPost<GenerationResponse>('/sessions/' + code + '/messages', request);
+  }
+
+  async findMessages(code: string, page?: number, size?: number): Promise<Paginated<Message>> {
+    const params: Record<string, unknown> = {};
+    if (page !== undefined) params.page = page;
+    if (size !== undefined) params.size = size;
+    return this.httpGet<Paginated<Message>>('/sessions/' + code + '/messages', params);
+  }
+
+  async remove(code: string): Promise<void> {
+    await this.httpDelete('/sessions/' + code);
+  }
+}

package/src/sessions/types.ts

@@ -0,0 +1,129 @@
+export interface Image {
+  content?: string;
+  contentType?: string;
+}
+
+export interface SessionFile {
+  name?: string;
+  url?: string;
+  base64?: string;
+  contentType?: string;
+}
+
+export interface FunctionCall {
+  name?: string;
+  args?: Record<string, unknown>;
+  id?: string;
+}
+
+export interface FunctionResponse {
+  name?: string;
+  result?: Record<string, unknown>;
+  functionCallId?: string;
+}
+
+export interface SourceChunk {
+  start?: number;
+  end?: number;
+}
+
+export interface Source {
+  type?: string;
+  url?: string;
+  documentId?: string;
+  pageId?: string;
+  pageNumber?: number;
+  chunks?: SourceChunk[];
+  mostRelevant?: boolean;
+}
+
+export type CollaborationMode = 'delegate_and_return' | 'persistent_transfer' | 'consult_then_respond';
+
+export interface TransferAction {
+  request?: string;
+  thought?: string;
+  agent?: string;
+  functionCallMessage?: Message;
+  functionResponseMessage?: Message;
+  collaborationMode?: CollaborationMode;
+}
+
+export interface Message {
+  id?: string;
+  sessionId?: string;
+  text?: string;
+  image?: Image;
+  file?: SessionFile;
+  role?: string;
+  timestamp?: number;
+  createdAt?: string;
+  functionCalls?: FunctionCall[];
+  functionResponse?: FunctionResponse;
+  finishReason?: string;
+  sources?: Source[];
+  task?: Record<string, unknown>;
+  sender?: string;
+  thought?: boolean;
+}
+
+export interface AgentResponse {
+  messages?: Message[];
+  transfer?: TransferAction;
+}
+
+export interface AgentContext {}
+
+export interface UsageCost {
+  service?: string;
+  value?: number;
+  cost?: number;
+  price?: number;
+  credits?: number;
+  unit?: string;
+}
+
+export interface CommittedUsage {
+  id?: string;
+  committedAt?: string;
+  projectId?: string;
+  sessionId?: string;
+  creditsUsed?: number;
+  totalCost?: number;
+  totalPrice?: number;
+  userId?: string;
+  details?: UsageCost[];
+}
+
+export interface Session {
+  id?: string;
+  code?: string;
+  name?: string;
+  projectId?: string;
+  agentId?: string;
+  currentAgentId?: string;
+  userId?: string;
+  status?: string;
+  visibility?: string;
+  type?: string;
+  createdAt?: string;
+  finishedAt?: string;
+  parentSessionId?: string;
+  protocol?: string;
+  extras?: Record<string, unknown>;
+  isNew?: boolean;
+}
+
+export interface GenerationRequest {
+  agentId?: string;
+  userMessage?: unknown;
+  initialContext?: AgentContext;
+  responseSchema?: Record<string, unknown>;
+  parentSessionId?: string;
+  userId?: string;
+}
+
+export interface GenerationResponse {
+  json?: unknown;
+  response?: AgentResponse;
+  sessionId?: string;
+}

package/src/triggers/trigger-executions-api.ts

@@ -0,0 +1,27 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { TriggerExecutionResult } from './types';
+
+export class TriggerExecutionsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(triggerId: string, page?: number, size?: number): Promise<Paginated<TriggerExecutionResult>> {
+    const params: Record<string, unknown> = { page, size };
+    return this.httpGet<Paginated<TriggerExecutionResult>>('/triggers/' + triggerId + '/executions', params);
+  }
+
+  async execute(triggerId: string, execution: TriggerExecutionResult): Promise<TriggerExecutionResult> {
+    return this.httpPost<TriggerExecutionResult>('/triggers/' + triggerId + '/executions', execution);
+  }
+
+  async get(executionId: string): Promise<TriggerExecutionResult> {
+    return this.httpGet<TriggerExecutionResult>('/triggers/executions/' + executionId);
+  }
+
+  async remove(executionId: string): Promise<void> {
+    await this.httpDelete('/triggers/executions/' + executionId);
+  }
+}

package/src/triggers/triggers-api.ts

@@ -0,0 +1,37 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { Trigger } from './types';
+import { TriggerExecutionsApi } from './trigger-executions-api';
+
+export class TriggersApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number): Promise<Paginated<Trigger>> {
+    const params: Record<string, unknown> = { page, size };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<Trigger>>('/triggers', params);
+  }
+
+  async create(trigger: Trigger): Promise<Trigger> {
+    return this.httpPost<Trigger>('/triggers', trigger);
+  }
+
+  async update(triggerId: string, trigger: Trigger): Promise<Trigger> {
+    return this.httpPut<Trigger>('/triggers/' + triggerId, trigger);
+  }
+
+  async remove(triggerId: string): Promise<void> {
+    await this.httpDelete('/triggers/' + triggerId);
+  }
+
+  async get(triggerId: string): Promise<Trigger> {
+    return this.httpGet<Trigger>('/triggers/' + triggerId);
+  }
+
+  executions(): TriggerExecutionsApi {
+    return new TriggerExecutionsApi(this.getBaseUrl(), this.getAuthProvider());
+  }
+}

package/src/triggers/types.ts

@@ -0,0 +1,50 @@
+export type TriggerSourceType = 'webhook' | 'schedule' | 'gmail' | 'imap';
+
+export interface GmailTriggerSourceConfiguration {
+  event?: string;
+  query?: string;
+  credentialsId?: string;
+  userEmail?: string;
+  watchExpiration?: number;
+  lastHistoryId?: number;
+}
+
+export interface ImapTriggerSourceConfiguration {
+  event?: string;
+  credentialsId?: string;
+  mailbox?: string;
+  searchCriteria?: string;
+  processAttachments?: boolean;
+  allowedMimeTypes?: string[];
+}
+
+export type TriggerSourceConfiguration = GmailTriggerSourceConfiguration | ImapTriggerSourceConfiguration | Record<string, unknown>;
+
+export interface TriggerSource {
+  type?: TriggerSourceType;
+  configuration?: TriggerSourceConfiguration;
+}
+
+export interface TriggerDestination {
+  type?: string;
+  configuration?: Record<string, unknown>;
+}
+
+export interface Trigger {
+  id?: string;
+  projectId?: string;
+  name?: string;
+  source?: TriggerSource;
+  destination?: TriggerDestination;
+  enabled?: boolean;
+  createdAt?: string;
+  processedAt?: string;
+}
+
+export interface TriggerExecutionResult {
+  id?: string;
+  triggerId?: string;
+  success?: boolean;
+  message?: string;
+  processedAt?: string;
+}

package/src/workflows/types.ts

@@ -0,0 +1,150 @@
+export type NodeType =
+  | 'start'
+  | 'action'
+  | 'condition'
+  | 'loop'
+  | 'tool'
+  | 'agent'
+  | 'set_var'
+  | 'output'
+  | 'workflow'
+  | 'resource'
+  | 'script';
+
+export type VariableType = 'string' | 'number' | 'boolean' | 'object' | 'file' | 'list';
+
+export type VariableDirection = 'in' | 'out';
+
+export type ExecutionStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+
+export interface Position {
+  x?: number;
+  y?: number;
+}
+
+export interface Handle {
+  name?: string;
+  description?: string;
+  type?: string;
+}
+
+export interface WorkflowVariable {
+  name?: string;
+  description?: string;
+  type?: VariableType;
+  direction?: VariableDirection;
+  defaultValue?: unknown;
+}
+
+export interface WorkflowTrigger {
+  type?: string;
+}
+
+export interface Node {
+  id?: string;
+  type?: NodeType;
+  name?: string;
+  description?: string;
+  position?: Position;
+  allowDynamicInputVariables?: boolean;
+  allowDynamicOutputVariables?: boolean;
+  allowDynamicHandles?: boolean;
+  staticVariables?: WorkflowVariable[];
+  variables?: WorkflowVariable[];
+  values?: Record<string, unknown>;
+  staticHandles?: Handle[];
+  handles?: Handle[];
+}
+
+export interface StartNode extends Node {
+  trigger?: WorkflowTrigger;
+}
+
+export interface Connection {
+  id?: string;
+  sourceId?: string;
+  targetId?: string;
+  sourceHandle?: string;
+  targetHandle?: string;
+}
+
+export interface Step {
+  id?: string;
+  nodeId?: string;
+  status?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: Record<string, unknown>;
+  error?: string;
+  output?: Record<string, unknown>;
+}
+
+export interface RunResult {
+  source?: Node;
+  success?: boolean;
+  message?: string;
+  nextNodes?: string[];
+}
+
+export interface NodeExecutionResult {
+  nextNodes?: Node[];
+  output?: Record<string, unknown>;
+}
+
+export interface Execution {
+  id?: string;
+  workflowId?: string;
+  status?: string;
+  userId?: string;
+  steps?: Step[];
+  startedAt?: string;
+  endedAt?: string;
+  output?: Record<string, unknown>;
+  error?: string;
+}
+
+export interface WorkflowResult {
+  workflowId?: string;
+  steps?: RunResult[];
+}
+
+export interface AgentValue {
+  agentId?: string;
+  initialContext?: Record<string, unknown>;
+}
+
+export interface ContentItemFile {
+  content?: string;
+  contentType?: string;
+}
+
+export interface Ref {
+  nodeId?: string;
+  variableName?: string;
+}
+
+export interface ContentItem {
+  text?: string | Ref;
+  file?: ContentItemFile | Ref;
+}
+
+export interface ContentValue {
+  content?: ContentItem[];
+}
+
+export interface ExecuteRequest {
+  userId?: string;
+  initialData?: Record<string, unknown>;
+  callbackUrl?: string;
+}
+
+export interface Workflow {
+  id?: string;
+  projectId?: string;
+  name?: string;
+  description?: string;
+  rootNode?: StartNode;
+  nodes?: Node[];
+  connections?: Connection[];
+  features?: import('../agents/types').Feature[];
+}

package/src/workflows/workflow-executions-api.ts

@@ -0,0 +1,27 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { Execution, ExecuteRequest } from './types';
+
+export class WorkflowExecutionsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(workflowId: string, page?: number, size?: number): Promise<Paginated<Execution>> {
+    const params: Record<string, unknown> = { page, size };
+    return this.httpGet<Paginated<Execution>>('/workflows/' + workflowId + '/executions', params);
+  }
+
+  async get(workflowId: string, executionId: string): Promise<Execution> {
+    return this.httpGet<Execution>('/workflows/' + workflowId + '/executions/' + executionId);
+  }
+
+  async run(workflowId: string, request: ExecuteRequest): Promise<Execution> {
+    return this.httpPost<Execution>('/workflows/' + workflowId + '/executions', request);
+  }
+
+  async queue(workflowId: string, request: ExecuteRequest): Promise<Execution> {
+    return this.httpPost<Execution>('/workflows/' + workflowId + '/executions/queue', request);
+  }
+}

package/src/workflows/workflows-api.ts

@@ -0,0 +1,51 @@
+import { HttpApi } from '../http-api';
+import { Paginated } from '../paginated';
+import { AuthenticationProvider } from '../auth/authentication-provider';
+import { Revision } from '../revisions/types';
+import { Workflow } from './types';
+import { WorkflowExecutionsApi } from './workflow-executions-api';
+
+export class WorkflowsApi extends HttpApi {
+  constructor(baseUrl: string, auth: string | AuthenticationProvider) {
+    super(baseUrl, auth);
+  }
+
+  async list(keyword?: string | null, page?: number, size?: number): Promise<Paginated<Workflow>> {
+    const params: Record<string, unknown> = { page, size };
+    if (keyword) params.keyword = keyword;
+    return this.httpGet<Paginated<Workflow>>('/workflows', params);
+  }
+
+  async create(workflow: Workflow): Promise<Workflow> {
+    return this.httpPost<Workflow>('/workflows', workflow);
+  }
+
+  async update(workflowId: string, workflow: Workflow): Promise<Workflow> {
+    workflow.id = workflowId;
+    return this.httpPut<Workflow>('/workflows/' + workflowId, workflow);
+  }
+
+  async remove(workflowId: string): Promise<void> {
+    await this.httpDelete('/workflows/' + workflowId);
+  }
+
+  async get(workflowId: string): Promise<Workflow> {
+    return this.httpGet<Workflow>('/workflows/' + workflowId);
+  }
+
+  executions(): WorkflowExecutionsApi {
+    return new WorkflowExecutionsApi(this.getBaseUrl(), this.getAuthProvider());
+  }
+
+  async listRevisions(workflowId: string): Promise<Revision[]> {
+    return this.httpGet<Revision[]>('/workflows/' + workflowId + '/revisions');
+  }
+
+  async getRevision(workflowId: string, revisionId: string): Promise<Revision> {
+    return this.httpGet<Revision>('/workflows/' + workflowId + '/revisions/' + revisionId);
+  }
+
+  async rollback(workflowId: string, revisionId: string): Promise<Workflow> {
+    return this.httpPost<Workflow>('/workflows/' + workflowId + '/revisions/' + revisionId + '/rollback', {});
+  }
+}

package/tsconfig.json

@@ -1,36 +1,28 @@
 {
   "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "baseUrl": ".",
-    "declaration": true,
-    "declarationMap": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
     "isolatedModules": true,
+    "noEmit": true,
     "jsx": "react-jsx",
-    "lib": ["DOM", "DOM.Iterable", "ESNext"],
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "noEmit": false,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "outDir": "dist",
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": ".",
     "paths": {
-      "@/*": ["playground/src/*"],
       "@applica-software-guru/persona-sdk": ["src/index.ts"]
-    },
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "target": "ESNext",
-    "typeRoots": ["node_modules/@types", "src/assets.d.ts", "src/index.d.ts", "src/types.d.ts"],
-    "useDefineForClassFields": true
-  },
-  "include": ["src", "playground/src"],
-  "references": [
-    {
-      "path": "./jsconfig.node.json"
     }
-  ]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
 }