lemma-sdk 0.2.0

package/dist/openapi_client/services/WorkflowsService.js

@@ -0,0 +1,326 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class WorkflowsService {
+    /**
+     * Create Workflow
+     * Create a workflow definition. Use this before uploading graph nodes/edges with `workflow.graph.update`.
+     * @param podId
+     * @param requestBody
+     * @returns FlowEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowCreate(podId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/workflows',
+            path: {
+                'pod_id': podId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * List Workflows
+     * List all workflows in a pod.
+     * @param podId
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowList(podId, limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflows',
+            path: {
+                'pod_id': podId,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Workflow
+     * Get a single workflow definition including graph and start configuration.
+     * @param podId
+     * @param workflowName
+     * @returns FlowEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowGet(podId, workflowName) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Update Workflow Metadata
+     * Update workflow-level metadata such as description/install requirements. Workflow names are immutable after creation. Use `workflow.graph.update` for nodes and edges.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowUpdate(podId, workflowName, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Delete Workflow
+     * Delete a workflow definition.
+     * @param podId
+     * @param workflowName
+     * @returns void
+     * @throws ApiError
+     */
+    static workflowDelete(podId, workflowName) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/workflows/{workflow_name}',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Update Workflow Graph
+     * Replace the workflow graph. Agent/function node `input_mapping` entries must use explicit typed bindings. Use `{type: "expression", value: "start.payload.issue.key"}` for context lookups and `{type: "literal", value: "abc"}` for fixed JSON values.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowGraphUpdate(podId, workflowName, requestBody) {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/graph',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Install Workflow
+     * Install a workflow for runtime execution. Provide `account_id` when the workflow needs an integration account binding.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowInstallEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowInstallCreate(podId, workflowName, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/install',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Uninstall Workflow
+     * Remove a previously created workflow installation binding.
+     * @param podId
+     * @param workflowName
+     * @param installId
+     * @returns void
+     * @throws ApiError
+     */
+    static workflowInstallDelete(podId, workflowName, installId) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/installs/{install_id}',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+                'install_id': installId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Start Workflow
+     * Start a new workflow run. For event/scheduled/datastore starts, the request body is treated as initial trigger payload and merged into execution context.
+     * @param podId
+     * @param workflowName
+     * @param requestBody
+     * @returns FlowRunEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowStart(podId, workflowName, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/start',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Visualize Workflow
+     * Render an HTML visualization for debugging workflow graph structure.
+     * @param podId
+     * @param workflowName
+     * @returns string Successful Response
+     * @throws ApiError
+     */
+    static workflowVisualize(podId, workflowName) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/visualize',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Resume Workflow Run
+     * Resume a run in WAITING or EXECUTING state. The payload is written back into the current waiting node output and execution continues.
+     * @param podId
+     * @param runId
+     * @param requestBody
+     * @returns FlowRunEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowRunResume(podId, runId, requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/resume',
+            path: {
+                'pod_id': podId,
+                'run_id': runId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Get Workflow Run
+     * Get current state, context, and step history of a workflow run.
+     * @param podId
+     * @param runId
+     * @returns FlowRunEntity Successful Response
+     * @throws ApiError
+     */
+    static workflowRunGet(podId, runId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}',
+            path: {
+                'pod_id': podId,
+                'run_id': runId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * List Workflow Runs
+     * List recent runs for a given workflow.
+     * @param podId
+     * @param workflowName
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowRunListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowRunList(podId, workflowName, limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflow-runs/{workflow_name}/runs',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Visualize Workflow Run
+     * Render an HTML view of a run overlaid on its workflow graph.
+     * @param podId
+     * @param runId
+     * @returns string Successful Response
+     * @throws ApiError
+     */
+    static workflowRunVisualize(podId, runId) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/visualize',
+            path: {
+                'pod_id': podId,
+                'run_id': runId,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+}

package/dist/react/AuthGuard.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+import type { LemmaClient } from "../client.js";
+export interface AuthGuardProps {
+    client: LemmaClient;
+    children: ReactNode;
+    /** Optional custom loading element. Defaults to a blank screen. */
+    loadingFallback?: ReactNode;
+    /** Optional custom unauthenticated element. Defaults to a centered sign-in page. */
+    unauthenticatedFallback?: ReactNode;
+}
+/**
+ * AuthGuard wraps your application and handles auth state:
+ * - Loading: shows loadingFallback (blank by default)
+ * - Unauthenticated: shows sign-in page (or custom unauthenticatedFallback)
+ * - Authenticated: renders children
+ *
+ * Usage:
+ *   <AuthGuard client={getClient()}>
+ *     <App />
+ *   </AuthGuard>
+ */
+export declare function AuthGuard({ client, children, loadingFallback, unauthenticatedFallback, }: AuthGuardProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/AuthGuard.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useAuth } from "./useAuth.js";
+function DefaultSignInPage({ onSignIn }) {
+    return (_jsx("div", { style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            minHeight: "100vh",
+            fontFamily: "system-ui, -apple-system, sans-serif",
+            backgroundColor: "#f9fafb",
+            gap: "16px",
+        }, children: _jsxs("div", { style: {
+                backgroundColor: "#fff",
+                borderRadius: "12px",
+                boxShadow: "0 1px 4px rgba(0,0,0,0.1)",
+                padding: "40px 48px",
+                textAlign: "center",
+                maxWidth: "360px",
+                width: "100%",
+            }, children: [_jsx("div", { style: {
+                        width: "40px",
+                        height: "40px",
+                        borderRadius: "8px",
+                        backgroundColor: "#111827",
+                        margin: "0 auto 20px",
+                    } }), _jsx("h1", { style: { margin: "0 0 8px", fontSize: "20px", fontWeight: 600, color: "#111827" }, children: "Sign in to continue" }), _jsx("p", { style: { margin: "0 0 24px", fontSize: "14px", color: "#6b7280" }, children: "You need to be signed in to access this app." }), _jsx("button", { onClick: onSignIn, style: {
+                        width: "100%",
+                        padding: "10px 16px",
+                        backgroundColor: "#111827",
+                        color: "#fff",
+                        border: "none",
+                        borderRadius: "8px",
+                        fontSize: "14px",
+                        fontWeight: 500,
+                        cursor: "pointer",
+                    }, children: "Sign In" })] }) }));
+}
+/**
+ * AuthGuard wraps your application and handles auth state:
+ * - Loading: shows loadingFallback (blank by default)
+ * - Unauthenticated: shows sign-in page (or custom unauthenticatedFallback)
+ * - Authenticated: renders children
+ *
+ * Usage:
+ *   <AuthGuard client={getClient()}>
+ *     <App />
+ *   </AuthGuard>
+ */
+export function AuthGuard({ client, children, loadingFallback = null, unauthenticatedFallback, }) {
+    const { isLoading, isAuthenticated, redirectToAuth } = useAuth(client);
+    if (isLoading) {
+        return _jsx(_Fragment, { children: loadingFallback });
+    }
+    if (!isAuthenticated) {
+        if (unauthenticatedFallback !== undefined) {
+            return _jsx(_Fragment, { children: unauthenticatedFallback });
+        }
+        return _jsx(DefaultSignInPage, { onSignIn: redirectToAuth });
+    }
+    return _jsx(_Fragment, { children: children });
+}

package/dist/react/index.d.ts

@@ -0,0 +1,4 @@
+export { AuthGuard } from "./AuthGuard.js";
+export type { AuthGuardProps } from "./AuthGuard.js";
+export { useAuth } from "./useAuth.js";
+export type { UseAuthResult } from "./useAuth.js";

package/dist/react/index.js

@@ -0,0 +1,2 @@
+export { AuthGuard } from "./AuthGuard.js";
+export { useAuth } from "./useAuth.js";

package/dist/react/useAuth.d.ts

@@ -0,0 +1,16 @@
+import type { LemmaClient } from "../client.js";
+import type { AuthState } from "../auth.js";
+export interface UseAuthResult {
+    status: AuthState["status"];
+    user: AuthState["user"];
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    redirectToAuth: () => void;
+}
+/**
+ * React hook for subscribing to Lemma auth state.
+ *
+ * Usage:
+ *   const { isAuthenticated, isLoading, redirectToAuth } = useAuth(client);
+ */
+export declare function useAuth(client: LemmaClient): UseAuthResult;

package/dist/react/useAuth.js

@@ -0,0 +1,29 @@
+import { useState, useEffect } from "react"; // peer dependency
+/**
+ * React hook for subscribing to Lemma auth state.
+ *
+ * Usage:
+ *   const { isAuthenticated, isLoading, redirectToAuth } = useAuth(client);
+ */
+export function useAuth(client) {
+    const [state, setState] = useState(client.auth.getState());
+    useEffect(() => {
+        // Subscribe to future state changes
+        const unsubscribe = client.auth.subscribe((next) => setState(next));
+        // If still in loading state, trigger the auth check
+        if (state.status === "loading") {
+            client.auth.checkAuth().catch(() => {
+                // checkAuth already handles errors internally
+            });
+        }
+        return unsubscribe;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [client]);
+    return {
+        status: state.status,
+        user: state.user,
+        isLoading: state.status === "loading",
+        isAuthenticated: state.status === "authenticated",
+        redirectToAuth: () => client.auth.redirectToAuth(),
+    };
+}

package/dist/supertokens.d.ts

@@ -0,0 +1 @@
+export declare function ensureCookieSessionSupport(apiUrl: string, onUnauthorised?: () => void): void;

package/dist/supertokens.js

@@ -0,0 +1,67 @@
+import SuperTokens from "supertokens-web-js";
+import Session from "supertokens-web-js/recipe/session";
+const APP_NAME = "Lemma";
+const SESSION_API_SUFFIX = "/st/auth";
+let initializedSignature = null;
+const unauthorisedListeners = new Set();
+function normalizePath(pathname) {
+    const trimmed = pathname.trim();
+    if (!trimmed || trimmed === "/") {
+        return "";
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    return withLeadingSlash.endsWith("/") ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
+}
+function resolveApiBase(apiUrl) {
+    if (typeof window === "undefined") {
+        throw new Error("Cookie session support requires a browser environment.");
+    }
+    if (/^https?:\/\//.test(apiUrl)) {
+        const url = new URL(apiUrl);
+        const apiPrefix = normalizePath(url.pathname);
+        return {
+            apiDomain: url.origin,
+            apiBasePath: `${apiPrefix}${SESSION_API_SUFFIX}` || SESSION_API_SUFFIX,
+        };
+    }
+    const apiPrefix = normalizePath(apiUrl);
+    return {
+        apiDomain: window.location.origin,
+        apiBasePath: `${apiPrefix}${SESSION_API_SUFFIX}` || SESSION_API_SUFFIX,
+    };
+}
+export function ensureCookieSessionSupport(apiUrl, onUnauthorised) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    if (onUnauthorised) {
+        unauthorisedListeners.add(onUnauthorised);
+    }
+    const { apiDomain, apiBasePath } = resolveApiBase(apiUrl);
+    const signature = `${apiDomain}${apiBasePath}`;
+    if (initializedSignature === signature) {
+        return;
+    }
+    if (initializedSignature !== null && initializedSignature !== signature) {
+        console.warn(`[lemma] SuperTokens was already initialised for ${initializedSignature}; continuing with the existing session config.`);
+        return;
+    }
+    SuperTokens.init({
+        appInfo: {
+            appName: APP_NAME,
+            apiDomain,
+            apiBasePath,
+        },
+        recipeList: [
+            Session.init({
+                tokenTransferMethod: "cookie",
+                onHandleEvent: (event) => {
+                    if (event.action === "UNAUTHORISED") {
+                        unauthorisedListeners.forEach((listener) => listener());
+                    }
+                },
+            }),
+        ],
+    });
+    initializedSignature = signature;
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+import type { RecordFilter as GeneratedRecordFilter } from "./openapi_client/models/RecordFilter.js";
+import type { RecordSort as GeneratedRecordSort } from "./openapi_client/models/RecordSort.js";
+/** Public ergonomic types. */
+export interface PageResult<T> {
+    items: T[];
+    nextPageToken?: string;
+    total?: number;
+}
+export type RecordFilter = GeneratedRecordFilter;
+export type RecordSort = GeneratedRecordSort;
+export interface ListRecordsOptions {
+    filters?: RecordFilter[];
+    sort?: RecordSort[];
+    limit?: number;
+    pageToken?: string;
+}
+export interface RunFunctionOptions {
+    /** Input payload for the function */
+    input?: Record<string, unknown>;
+}
+export interface CreateTaskOptions {
+    agentName: string;
+    input?: Record<string, unknown>;
+}
+export interface WorkflowRunInputs {
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "lemma-sdk",
+  "version": "0.2.0",
+  "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gappyai/lemma-typescript.git"
+  },
+  "homepage": "https://github.com/gappyai/lemma-typescript#readme",
+  "bugs": {
+    "url": "https://github.com/gappyai/lemma-typescript/issues"
+  },
+  "keywords": [
+    "lemma",
+    "sdk",
+    "typescript",
+    "api",
+    "react"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./browser-bundle": "./dist/browser/lemma-client.js"
+  },
+  "unpkg": "dist/browser/lemma-client.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "generate:client": "./scripts/generate_openapi_client.sh",
+    "build": "npm run clean && tsc -p tsconfig.json && npm run build:bundle",
+    "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run",
+    "docs:dev": "cd docs && npx mintlify dev",
+    "docs:validate": "cd docs && npx mintlify validate"
+  },
+  "peerDependencies": {
+    "react": ">=17"
+  },
+  "peerDependenciesMeta": {
+    "react": { "optional": true }
+  },
+  "dependencies": {
+    "supertokens-web-js": "^0.16.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.28",
+    "openapi-typescript-codegen": "^0.29.0",
+    "typescript": "^5.6.3"
+  }
+}