lemma-sdk 0.2.28 → 0.2.30

package/dist/react/useWorkflowStart.d.ts

@@ -0,0 +1,33 @@
+import type { LemmaClient } from "../client.js";
+import type { FlowRun, FlowStartType, Workflow, WorkflowRunInputs } from "../types.js";
+import { type UseFlowSessionResult } from "./useFlowSession.js";
+export interface UseWorkflowStartOptions {
+    client: LemmaClient;
+    podId?: string;
+    workflowName: string;
+    runId?: string | null;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    autoPoll?: boolean;
+    pollIntervalMs?: number;
+    onRun?: (run: FlowRun) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseWorkflowStartResult extends Omit<UseFlowSessionResult, "start" | "listHistory"> {
+    workflow: Workflow | null;
+    startType: FlowStartType | "MANUAL";
+    inputSchema: Record<string, unknown> | null;
+    inputUiSchema: Record<string, unknown> | null;
+    isLoadingWorkflow: boolean;
+    isStarting: boolean;
+    error: Error | null;
+    refreshWorkflow: () => Promise<Workflow | null>;
+    listHistory: (options?: {
+        limit?: number;
+        pageToken?: string;
+    }) => Promise<FlowRun[]>;
+    start: (inputs?: WorkflowRunInputs, options?: {
+        forceResume?: boolean;
+    }) => Promise<FlowRun>;
+}
+export declare function useWorkflowStart({ client, podId, workflowName, runId, enabled, autoLoad, autoPoll, pollIntervalMs, onRun, onError, }: UseWorkflowStartOptions): UseWorkflowStartResult;

package/dist/react/useWorkflowStart.js

@@ -0,0 +1,155 @@
+import { useCallback, useEffect, useState } from "react";
+import { normalizeRunStatus } from "../run-utils.js";
+import { useFlowSession, } from "./useFlowSession.js";
+function normalizeError(error, fallback) {
+    if (error instanceof Error)
+        return error;
+    return new Error(fallback);
+}
+function resolvePodClient(client, podId) {
+    if (!podId || podId === client.podId)
+        return client;
+    return client.withPod(podId);
+}
+function findFirstFormNode(workflow) {
+    if (!workflow?.nodes?.length)
+        return null;
+    for (const node of workflow.nodes) {
+        if (!node || typeof node !== "object")
+            continue;
+        if (!("config" in node) || typeof node.config !== "object" || !node.config)
+            continue;
+        if ("input_schema" in node.config) {
+            return node;
+        }
+    }
+    return null;
+}
+function isWaitingFlowRun(run) {
+    if (!run)
+        return false;
+    const normalizedStatus = normalizeRunStatus(run.status);
+    return normalizedStatus === "WAITING"
+        || !!run.waiting_function_run_id
+        || !!run.waiting_task_id
+        || !!run.waiting_trigger_id;
+}
+export function useWorkflowStart({ client, podId, workflowName, runId = null, enabled = true, autoLoad = true, autoPoll = true, pollIntervalMs = 2000, onRun, onError, }) {
+    const [workflow, setWorkflow] = useState(null);
+    const [workflowError, setWorkflowError] = useState(null);
+    const [isLoadingWorkflow, setIsLoadingWorkflow] = useState(false);
+    const [isStarting, setIsStarting] = useState(false);
+    const hasWorkflowName = workflowName.trim().length > 0;
+    const isEnabled = enabled && hasWorkflowName;
+    const session = useFlowSession({
+        client,
+        podId,
+        flowName: workflowName,
+        runId,
+        autoPoll,
+        pollIntervalMs,
+        onRun,
+        onError,
+    });
+    const refreshWorkflow = useCallback(async () => {
+        if (!isEnabled) {
+            setWorkflow(null);
+            setWorkflowError(null);
+            setIsLoadingWorkflow(false);
+            return null;
+        }
+        setIsLoadingWorkflow(true);
+        setWorkflowError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextWorkflow = await scopedClient.workflows.get(workflowName);
+            setWorkflow(nextWorkflow);
+            return nextWorkflow;
+        }
+        catch (refreshError) {
+            const normalized = normalizeError(refreshError, "Failed to fetch workflow definition.");
+            setWorkflowError(normalized);
+            return null;
+        }
+        finally {
+            setIsLoadingWorkflow(false);
+        }
+    }, [client, isEnabled, podId, workflowName]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setWorkflow(null);
+            setWorkflowError(null);
+            setIsLoadingWorkflow(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        void refreshWorkflow();
+    }, [autoLoad, isEnabled, refreshWorkflow]);
+    const listHistory = useCallback((options = {}) => {
+        return session.listHistory({
+            flowName: workflowName,
+            limit: options.limit,
+            pageToken: options.pageToken,
+        });
+    }, [session, workflowName]);
+    const start = useCallback(async (inputs = {}, options = {}) => {
+        if (!hasWorkflowName) {
+            const missingWorkflowError = new Error("workflowName is required.");
+            setWorkflowError(missingWorkflowError);
+            throw missingWorkflowError;
+        }
+        setIsStarting(true);
+        setWorkflowError(null);
+        try {
+            const currentWorkflow = workflow?.name === workflowName
+                ? workflow
+                : await refreshWorkflow();
+            const startType = currentWorkflow?.start?.type ?? "MANUAL";
+            if (startType === "MANUAL") {
+                const created = await session.start({
+                    flowName: workflowName,
+                    inputs: {},
+                });
+                const shouldResume = !!created.id && (options.forceResume === true
+                    || Object.keys(inputs).length > 0
+                    || isWaitingFlowRun(created));
+                if (!shouldResume || !created.id) {
+                    return created;
+                }
+                return session.resume({
+                    runId: created.id,
+                    inputs,
+                });
+            }
+            return session.start({
+                flowName: workflowName,
+                inputs,
+            });
+        }
+        catch (startError) {
+            const normalized = normalizeError(startError, "Failed to start workflow.");
+            setWorkflowError(normalized);
+            throw normalized;
+        }
+        finally {
+            setIsStarting(false);
+        }
+    }, [hasWorkflowName, refreshWorkflow, session, workflow, workflowName]);
+    const formNode = findFirstFormNode(workflow);
+    const startType = workflow?.start?.type ?? "MANUAL";
+    const error = workflowError ?? session.error;
+    return {
+        ...session,
+        workflow,
+        startType,
+        inputSchema: formNode?.config.input_schema ?? null,
+        inputUiSchema: formNode?.config.ui_schema ?? null,
+        isLoadingWorkflow,
+        isStarting,
+        error,
+        refreshWorkflow,
+        listHistory,
+        start,
+    };
+}

package/dist/record-form.d.ts

@@ -0,0 +1,30 @@
+import { type ForeignKeyReference } from "./datastore-query.js";
+import { type ColumnSchema, type Table } from "./types.js";
+export type RecordSchemaFieldKind = "text" | "textarea" | "number" | "boolean" | "json" | "date" | "datetime" | "select" | "foreign-key" | "uuid";
+export interface RecordSchemaField {
+    name: string;
+    label: string;
+    kind: RecordSchemaFieldKind;
+    column: ColumnSchema;
+    required: boolean;
+    readOnly: boolean;
+    system: boolean;
+    computed: boolean;
+    auto: boolean;
+    options: string[];
+    foreignKey: ForeignKeyReference | null;
+}
+export interface BuildRecordPayloadOptions {
+    mode?: "create" | "update";
+}
+export interface BuildRecordPayloadResult {
+    data: Record<string, unknown>;
+    errors: Record<string, string>;
+    isValid: boolean;
+}
+export declare function getRecordFieldKind(column: ColumnSchema): RecordSchemaFieldKind;
+export declare function buildRecordSchemaFields(table: Table): RecordSchemaField[];
+export declare function getEditableRecordFields(table: Table): RecordSchemaField[];
+export declare function formatRecordValueForForm(column: ColumnSchema, value: unknown): unknown;
+export declare function buildRecordFormValues(table: Table, values?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildRecordPayload(table: Table, values: Record<string, unknown>, options?: BuildRecordPayloadOptions): BuildRecordPayloadResult;

package/dist/record-form.js

@@ -0,0 +1,199 @@
+import { parseForeignKeyReference } from "./datastore-query.js";
+import { DatastoreDataType } from "./types.js";
+function sentenceCase(value) {
+    return value
+        .replace(/_/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function isBlank(value) {
+    return value === null || typeof value === "undefined" || (typeof value === "string" && value.trim() === "");
+}
+function isIntegerLike(value) {
+    return Number.isInteger(value);
+}
+function getRawColumnDefault(column) {
+    return column.default;
+}
+function shouldUseTextarea(column) {
+    if (typeof column.max_length === "number" && column.max_length >= 240) {
+        return true;
+    }
+    return /(description|content|body|note|instruction|summary|message)/i.test(column.name);
+}
+function toDateInputValue(value) {
+    if (typeof value === "string") {
+        return value.includes("T") ? value.slice(0, 10) : value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString().slice(0, 10);
+    }
+    return String(value);
+}
+function toDateTimeLocalInputValue(value) {
+    if (typeof value === "string") {
+        const timestamp = new Date(value);
+        if (!Number.isNaN(timestamp.getTime())) {
+            const pad = (part) => String(part).padStart(2, "0");
+            return [
+                timestamp.getFullYear(),
+                pad(timestamp.getMonth() + 1),
+                pad(timestamp.getDate()),
+            ].join("-") + `T${pad(timestamp.getHours())}:${pad(timestamp.getMinutes())}`;
+        }
+        return value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        const pad = (part) => String(part).padStart(2, "0");
+        return [
+            value.getFullYear(),
+            pad(value.getMonth() + 1),
+            pad(value.getDate()),
+        ].join("-") + `T${pad(value.getHours())}:${pad(value.getMinutes())}`;
+    }
+    return String(value);
+}
+export function getRecordFieldKind(column) {
+    if (column.foreign_key?.references)
+        return "foreign-key";
+    if (column.type === DatastoreDataType.ENUM)
+        return "select";
+    if (column.type === DatastoreDataType.BOOLEAN)
+        return "boolean";
+    if (column.type === DatastoreDataType.JSON || column.type === DatastoreDataType.VECTOR)
+        return "json";
+    if (column.type === DatastoreDataType.INTEGER
+        || column.type === DatastoreDataType.FLOAT
+        || column.type === DatastoreDataType.SERIAL) {
+        return "number";
+    }
+    if (column.type === DatastoreDataType.DATE)
+        return "date";
+    if (column.type === DatastoreDataType.DATETIME)
+        return "datetime";
+    if (column.type === DatastoreDataType.UUID)
+        return "uuid";
+    if (column.type === DatastoreDataType.TEXT && shouldUseTextarea(column))
+        return "textarea";
+    return "text";
+}
+export function buildRecordSchemaFields(table) {
+    return table.columns.map((column) => {
+        const foreignKey = column.foreign_key?.references
+            ? parseForeignKeyReference(column.foreign_key.references)
+            : null;
+        return {
+            name: column.name,
+            label: sentenceCase(column.name),
+            kind: getRecordFieldKind(column),
+            column,
+            required: column.required === true,
+            readOnly: column.system === true || column.computed === true || column.auto === true,
+            system: column.system === true,
+            computed: column.computed === true,
+            auto: column.auto === true,
+            options: column.options ?? [],
+            foreignKey,
+        };
+    });
+}
+export function getEditableRecordFields(table) {
+    return buildRecordSchemaFields(table).filter((field) => !field.readOnly);
+}
+export function formatRecordValueForForm(column, value) {
+    const kind = getRecordFieldKind(column);
+    if (value === null || typeof value === "undefined") {
+        if (kind === "boolean")
+            return false;
+        return "";
+    }
+    if (kind === "boolean") {
+        return Boolean(value);
+    }
+    if (kind === "json") {
+        if (typeof value === "string")
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    if (kind === "date") {
+        return toDateInputValue(value);
+    }
+    if (kind === "datetime") {
+        return toDateTimeLocalInputValue(value);
+    }
+    if (kind === "number") {
+        return String(value);
+    }
+    return String(value);
+}
+export function buildRecordFormValues(table, values = {}) {
+    const next = {};
+    buildRecordSchemaFields(table).forEach((field) => {
+        const provided = values[field.name];
+        const rawDefault = getRawColumnDefault(field.column);
+        const source = typeof provided !== "undefined" ? provided : rawDefault;
+        next[field.name] = formatRecordValueForForm(field.column, source);
+    });
+    return next;
+}
+function coerceEmptyValue(mode, name, target) {
+    if (mode === "update") {
+        target[name] = null;
+    }
+}
+export function buildRecordPayload(table, values, options = {}) {
+    const mode = options.mode ?? "create";
+    const data = {};
+    const errors = {};
+    getEditableRecordFields(table).forEach((field) => {
+        const rawValue = values[field.name];
+        const value = typeof rawValue === "string" ? rawValue : rawValue;
+        if (field.kind === "boolean") {
+            data[field.name] = Boolean(rawValue);
+            return;
+        }
+        if (isBlank(value)) {
+            if (field.required) {
+                errors[field.name] = `${field.label} is required.`;
+                return;
+            }
+            coerceEmptyValue(mode, field.name, data);
+            return;
+        }
+        if (field.kind === "number") {
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed)) {
+                errors[field.name] = `${field.label} must be a valid number.`;
+                return;
+            }
+            if ((field.column.type === DatastoreDataType.INTEGER || field.column.type === DatastoreDataType.SERIAL)
+                && !isIntegerLike(parsed)) {
+                errors[field.name] = `${field.label} must be a whole number.`;
+                return;
+            }
+            data[field.name] = parsed;
+            return;
+        }
+        if (field.kind === "json") {
+            try {
+                data[field.name] = typeof value === "string" ? JSON.parse(value) : value;
+            }
+            catch {
+                errors[field.name] = `${field.label} must be valid JSON.`;
+            }
+            return;
+        }
+        data[field.name] = typeof value === "string" ? value : String(value);
+    });
+    return {
+        data,
+        errors,
+        isValid: Object.keys(errors).length === 0,
+    };
+}

package/dist/schema-form.d.ts

@@ -0,0 +1,41 @@
+export type JsonSchemaPrimitiveType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+export interface JsonSchemaLike {
+    type?: JsonSchemaPrimitiveType | JsonSchemaPrimitiveType[];
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: unknown;
+    enum?: unknown[];
+    properties?: Record<string, JsonSchemaLike>;
+    required?: string[];
+    items?: JsonSchemaLike;
+    anyOf?: JsonSchemaLike[];
+    oneOf?: JsonSchemaLike[];
+    allOf?: JsonSchemaLike[];
+    [key: string]: unknown;
+}
+export type SchemaFormFieldKind = "text" | "textarea" | "number" | "boolean" | "select" | "json" | "date" | "datetime" | "email";
+export interface SchemaFormField {
+    name: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    kind: SchemaFormFieldKind;
+    type: JsonSchemaPrimitiveType | "unknown";
+    format?: string;
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    defaultValue?: unknown;
+    schema: JsonSchemaLike;
+}
+export interface BuildSchemaFormPayloadResult {
+    data: Record<string, unknown>;
+    errors: Record<string, string>;
+    isValid: boolean;
+}
+export declare function buildSchemaFormFields(schema: JsonSchemaLike | null | undefined, uiSchema?: Record<string, unknown> | null): SchemaFormField[];
+export declare function formatSchemaFieldValueForForm(field: SchemaFormField, value: unknown): unknown;
+export declare function buildSchemaFormValues(schema: JsonSchemaLike | null | undefined, values?: Record<string, unknown>, uiSchema?: Record<string, unknown> | null): Record<string, unknown>;
+export declare function buildSchemaFormPayload(schema: JsonSchemaLike | null | undefined, values: Record<string, unknown>, uiSchema?: Record<string, unknown> | null): BuildSchemaFormPayloadResult;

package/dist/schema-form.js

@@ -0,0 +1,200 @@
+function sentenceCase(value) {
+    return value
+        .replace(/_/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isBlank(value) {
+    return value === null || typeof value === "undefined" || (typeof value === "string" && value.trim() === "");
+}
+function normalizeSchemaType(schema) {
+    if (Array.isArray(schema.type)) {
+        const nonNull = schema.type.find((entry) => entry !== "null");
+        return nonNull ?? "unknown";
+    }
+    if (typeof schema.type === "string") {
+        return schema.type;
+    }
+    if (schema.enum?.length) {
+        return "string";
+    }
+    if (schema.properties && isRecord(schema.properties)) {
+        return "object";
+    }
+    if (schema.items) {
+        return "array";
+    }
+    return "unknown";
+}
+function getSchemaFieldKind(schema) {
+    if (schema.enum?.length)
+        return "select";
+    const type = normalizeSchemaType(schema);
+    const format = typeof schema.format === "string" ? schema.format : undefined;
+    if (type === "boolean")
+        return "boolean";
+    if (type === "number" || type === "integer")
+        return "number";
+    if (format === "date")
+        return "date";
+    if (format === "date-time")
+        return "datetime";
+    if (format === "email")
+        return "email";
+    if (type === "object" || type === "array")
+        return "json";
+    if (format === "textarea")
+        return "textarea";
+    const title = `${schema.title ?? ""} ${schema.description ?? ""}`.toLowerCase();
+    if (/(description|body|content|message|note|summary|instructions)/.test(title)) {
+        return "textarea";
+    }
+    return "text";
+}
+function formatDateInputValue(value) {
+    if (typeof value === "string") {
+        return value.includes("T") ? value.slice(0, 10) : value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString().slice(0, 10);
+    }
+    return String(value);
+}
+function formatDateTimeLocalInputValue(value) {
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime())) {
+        return String(value);
+    }
+    const pad = (part) => String(part).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+export function buildSchemaFormFields(schema, uiSchema) {
+    if (!schema || !isRecord(schema.properties))
+        return [];
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const order = Array.isArray(uiSchema?.["ui:order"])
+        ? (uiSchema?.["ui:order"]).filter((entry) => typeof entry === "string")
+        : [];
+    const orderIndex = new Map(order.map((name, index) => [name, index]));
+    const fields = Object.entries(schema.properties).map(([name, propertySchema]) => {
+        const property = isRecord(propertySchema) ? propertySchema : {};
+        const uiFieldConfig = isRecord(uiSchema?.[name]) ? uiSchema?.[name] : {};
+        const widget = typeof uiFieldConfig["ui:widget"] === "string" ? uiFieldConfig["ui:widget"] : undefined;
+        const kind = widget === "textarea" ? "textarea" : getSchemaFieldKind(property);
+        return {
+            name,
+            label: typeof property.title === "string" && property.title.trim().length > 0
+                ? property.title
+                : sentenceCase(name),
+            description: typeof property.description === "string" ? property.description : undefined,
+            required: required.includes(name),
+            kind,
+            type: normalizeSchemaType(property),
+            format: typeof property.format === "string" ? property.format : undefined,
+            options: (property.enum ?? []).map((value) => ({
+                label: typeof value === "string" ? value : JSON.stringify(value),
+                value: typeof value === "string" ? value : JSON.stringify(value),
+            })),
+            defaultValue: property.default,
+            schema: property,
+        };
+    });
+    return fields.sort((left, right) => {
+        const leftIndex = orderIndex.get(left.name);
+        const rightIndex = orderIndex.get(right.name);
+        if (typeof leftIndex === "number" && typeof rightIndex === "number") {
+            return leftIndex - rightIndex;
+        }
+        if (typeof leftIndex === "number")
+            return -1;
+        if (typeof rightIndex === "number")
+            return 1;
+        return left.label.localeCompare(right.label);
+    });
+}
+export function formatSchemaFieldValueForForm(field, value) {
+    if (value === null || typeof value === "undefined") {
+        if (field.kind === "boolean")
+            return false;
+        return "";
+    }
+    if (field.kind === "boolean")
+        return Boolean(value);
+    if (field.kind === "number")
+        return String(value);
+    if (field.kind === "date")
+        return formatDateInputValue(value);
+    if (field.kind === "datetime")
+        return formatDateTimeLocalInputValue(value);
+    if (field.kind === "json") {
+        if (typeof value === "string")
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+export function buildSchemaFormValues(schema, values = {}, uiSchema) {
+    const fields = buildSchemaFormFields(schema, uiSchema);
+    const next = {};
+    fields.forEach((field) => {
+        const provided = values[field.name];
+        const source = typeof provided !== "undefined" ? provided : field.defaultValue;
+        next[field.name] = formatSchemaFieldValueForForm(field, source);
+    });
+    return next;
+}
+export function buildSchemaFormPayload(schema, values, uiSchema) {
+    const fields = buildSchemaFormFields(schema, uiSchema);
+    const data = {};
+    const errors = {};
+    fields.forEach((field) => {
+        const rawValue = values[field.name];
+        if (field.kind === "boolean") {
+            data[field.name] = Boolean(rawValue);
+            return;
+        }
+        if (isBlank(rawValue)) {
+            if (field.required) {
+                errors[field.name] = `${field.label} is required.`;
+            }
+            return;
+        }
+        if (field.kind === "number") {
+            const parsed = Number(rawValue);
+            if (!Number.isFinite(parsed)) {
+                errors[field.name] = `${field.label} must be a valid number.`;
+                return;
+            }
+            if (field.type === "integer" && !Number.isInteger(parsed)) {
+                errors[field.name] = `${field.label} must be a whole number.`;
+                return;
+            }
+            data[field.name] = parsed;
+            return;
+        }
+        if (field.kind === "json") {
+            try {
+                data[field.name] = typeof rawValue === "string" ? JSON.parse(rawValue) : rawValue;
+            }
+            catch {
+                errors[field.name] = `${field.label} must be valid JSON.`;
+            }
+            return;
+        }
+        data[field.name] = rawValue;
+    });
+    return {
+        data,
+        errors,
+        isValid: Object.keys(errors).length === 0,
+    };
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AssistantResponse, AvailableModels, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, FlowRunEntity, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -51,6 +51,10 @@ export type Task = TaskResponse;
 export type TaskMessage = TaskMessageResponse;
 export type FunctionRun = FunctionRunResponse;
 export type FlowRun = FlowRunEntity;
+export type Workflow = FlowResponse;
+export type Table = TableResponse;
+export type TableColumn = ColumnSchema;
+export type DatastoreQueryResult = DatastoreQueryResponse;
 export type Pod = PodResponse;
 export type PodConfig = PodConfigResponse;
 export type PodMember = PodMemberResponse;