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

package/src/workflows/types.ts

@@ -0,0 +1,173 @@
+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;
+  eventsHook?: string;
+}
+
+export interface HumanTask {
+  id: string;
+  projectId?: string;
+  workflowId?: string;
+  workflowName?: string;
+  executionId?: string;
+  nodeId?: string;
+  stepId?: string;
+  origin?: 'node' | 'agent_escalation';
+  question?: string;
+  payload?: Record<string, unknown>;
+  assignee?: string;
+  role?: string;
+  status: string;
+  response?: unknown;
+  respondedBy?: string;
+  respondedAt?: string;
+  createdAt?: string;
+  timeoutAt?: string;
+  sessionCode?: 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,94 @@
+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 { page: p, size: s } = this.normalizePageParams(page, size);
+    const params: Record<string, unknown> = { page: p, size: s };
+    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);
+  }
+
+  /** Runs across all workflows in the project (filter by status/workflow/date). */
+  async listRuns(filters: {
+    status?: string;
+    workflowId?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    page?: number;
+    size?: number;
+  } = {}): Promise<Paginated<Execution>> {
+    const { page, size } = this.normalizePageParams(filters.page, filters.size);
+    const params: Record<string, unknown> = { page, size };
+    if (filters.status) params.status = filters.status;
+    if (filters.workflowId) params.workflowId = filters.workflowId;
+    if (filters.dateFrom) params.dateFrom = filters.dateFrom;
+    if (filters.dateTo) params.dateTo = filters.dateTo;
+    return this.httpGet<Paginated<Execution>>('/executions', params);
+  }
+
+  /** Request cancellation of a running/waiting execution (cascades to sub-workflows). */
+  async cancel(workflowId: string, executionId: string): Promise<Execution> {
+    return this.httpPost<Execution>(
+      '/workflows/' + workflowId + '/executions/' + executionId + '/cancel',
+      {},
+    );
+  }
+
+  /** Re-run an execution from a given node. mode: 'reuse_outputs' | 'fresh'. */
+  async rerun(
+    workflowId: string,
+    executionId: string,
+    fromNodeId: string,
+    mode: 'reuse_outputs' | 'fresh' = 'reuse_outputs',
+  ): Promise<Execution> {
+    return this.httpPost<Execution>(
+      '/workflows/' + workflowId + '/executions/' + executionId + '/rerun',
+      { fromNodeId, mode },
+    );
+  }
+
+  /** Execute a single node in isolation with the given inputs (debugging). */
+  async dryRunNode(
+    workflowId: string,
+    nodeId: string,
+    inputs: Record<string, unknown> = {},
+  ): Promise<Record<string, unknown>> {
+    return this.httpPost<Record<string, unknown>>(
+      '/workflows/' + workflowId + '/nodes/' + nodeId + '/dry-run',
+      { inputs },
+    );
+  }
+
+  /** Normalized action trace of an agent step (reasoning, tool calls, messages). */
+  async stepTrace(
+    workflowId: string,
+    executionId: string,
+    stepId: string,
+    page?: number,
+    size?: number,
+  ): Promise<Record<string, unknown>> {
+    const { page: p, size: s } = this.normalizePageParams(page, size ?? 200);
+    return this.httpGet<Record<string, unknown>>(
+      '/workflows/' + workflowId + '/executions/' + executionId + '/steps/' + stepId + '/trace',
+      { page: p, size: s },
+    );
+  }
+}

package/src/workflows/workflows-api.ts

@@ -0,0 +1,57 @@
+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';
+import { HumanTasksApi } from './human-tasks-api';
+
+export class WorkflowsApi 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<Workflow>> {
+    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<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());
+  }
+
+  humanTasks(): HumanTasksApi {
+    return new HumanTasksApi(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"]
 }

package/vite.config.ts

@@ -1,74 +1,27 @@
-import react from '@vitejs/plugin-react';
-import * as packageJson from './package.json';
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
 import { resolve } from 'path';
-import { ConfigEnv, defineConfig, UserConfig } from 'vite';
-import { default as dts } from 'vite-plugin-dts';
-import tailwindcss from '@tailwindcss/vite';
 
-export default defineConfig((configEnv: ConfigEnv) => {
-  const { mode } = configEnv;
-  const isDevelopment = mode === 'development';
-  const config: UserConfig = {
-    build: {
-      sourcemap: true,
-      lib: {
-        entry: resolve('src', 'index.ts'),
-        name: 'personaSDK',
-        formats: ['es', 'umd', 'cjs', 'iife'],
-        fileName: (format: string) => `bundle.${format}.js`,
-      },
-      rollupOptions: {
-        external: [
-          ...Object.keys(packageJson.peerDependencies),
-          ...Object.keys(packageJson.dependencies || {}),
-          /^react\//,
-          /^react-dom\//,
-          /^@radix-ui\//,
-        ],
-        input: resolve(__dirname, 'src', 'index.ts'),
-        output: {
-          globals: {
-            'react-dom': 'ReactDOM',
-            react: 'React',
-            'react/jsx-runtime': 'React',
-            'react/jsx-dev-runtime': 'React',
-            '@assistant-ui/react': 'AssistantUI',
-            '@radix-ui/react-dialog': 'RadixDialog',
-            '@radix-ui/react-slot': 'RadixSlot',
-            'rehype-raw': 'rehypeRaw',
-            zustand: 'zustand',
-          },
-        },
-      },
+export default defineConfig({
+  plugins: [dts({ rollupTypes: true })],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'PersonaSDK',
+      formats: ['es', 'cjs'],
+      fileName: (format) => `bundle.${format}.js`,
     },
-    resolve: {
-      dedupe: Object.keys(packageJson.peerDependencies || {}),
-      alias: {
-        '@applica-software-guru/persona-sdk': resolve(__dirname, 'src'),
-        '@': resolve(__dirname, 'playground/src'),
-        '@/*': resolve(__dirname, 'playground/src/*'),
-        '*': resolve(__dirname, 'src/*'),
+    rollupOptions: {
+      external: [],
+      output: {
+        globals: {},
       },
     },
-    plugins: [
-      dts({
-        include: ['./src/**/*.{js,jsx,ts,tsx}'],
-      }),
-      react(),
-    ],
-    define: {
-      'process.env': {
-        NODE_ENV: 'production',
-      },
+    sourcemap: true,
+  },
+  resolve: {
+    alias: {
+      '@applica-software-guru/persona-sdk': resolve(__dirname, 'src'),
     },
-    optimizeDeps: {
-      include: Object.keys(packageJson.peerDependencies || {}),
-    },
-  };
-  if (isDevelopment) {
-    config.plugins = [react(), tailwindcss()];
-    config.root = resolve(__dirname, 'playground');
-  }
-
-  return config;
+  },
 });

package/.github/copilot-instructions.md

@@ -1,3 +0,0 @@
-# Copilot Instructions
-
-Please refer to the [README.md](../README.md) for project documentation and guidelines.

package/CLAUDE.md

@@ -1,3 +0,0 @@
-# Claude Instructions
-
-Please refer to the [README.md](README.md) for project documentation and guidelines.

package/GEMINI.md

@@ -1,3 +0,0 @@
-# Gemini Instructions
-
-Please refer to the [README.md](README.md) for project documentation and guidelines.

package/components.json

@@ -1,24 +0,0 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "new-york",
-  "rsc": false,
-  "tsx": true,
-  "tailwind": {
-    "config": "",
-    "css": "playground/src/styles.css",
-    "baseColor": "neutral",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "iconLibrary": "lucide",
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "registries": {
-    "@assistant-ui": "https://r.assistant-ui.com/{name}.json"
-  }
-}