lemma-sdk 0.2.0 → 0.2.2

package/dist/namespaces/organizations.d.ts

@@ -0,0 +1,46 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import type { OrganizationCreateRequest } from "../openapi_client/models/OrganizationCreateRequest.js";
+import type { OrganizationInvitationListResponse } from "../openapi_client/models/OrganizationInvitationListResponse.js";
+import type { OrganizationInvitationRequest } from "../openapi_client/models/OrganizationInvitationRequest.js";
+import type { OrganizationInvitationStatus } from "../openapi_client/models/OrganizationInvitationStatus.js";
+import type { OrganizationRole } from "../openapi_client/models/OrganizationRole.js";
+export declare class OrganizationsNamespace {
+    private readonly client;
+    private readonly http;
+    constructor(client: GeneratedClientAdapter, http: HttpClient);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+        cursor?: string;
+    }): Promise<import("../index.js").OrganizationListResponse>;
+    get(orgId: string): Promise<import("../index.js").OrganizationResponse>;
+    create(payload: OrganizationCreateRequest): Promise<import("../index.js").OrganizationResponse>;
+    readonly members: {
+        list: (orgId: string, options?: {
+            limit?: number;
+            pageToken?: string;
+            cursor?: string;
+        }) => Promise<import("../index.js").OrganizationMemberListResponse>;
+        updateRole: (orgId: string, memberId: string, role: OrganizationRole) => Promise<import("../index.js").OrganizationMemberResponse>;
+        remove: (orgId: string, memberId: string) => Promise<void>;
+    };
+    readonly invitations: {
+        listMine: (options?: {
+            status?: OrganizationInvitationStatus;
+            limit?: number;
+            pageToken?: string;
+            cursor?: string;
+        }) => Promise<OrganizationInvitationListResponse>;
+        list: (orgId: string, options?: {
+            status?: OrganizationInvitationStatus;
+            limit?: number;
+            pageToken?: string;
+            cursor?: string;
+        }) => Promise<OrganizationInvitationListResponse>;
+        get: (invitationId: string) => Promise<import("../index.js").OrganizationInvitationResponse>;
+        invite: (orgId: string, payload: OrganizationInvitationRequest) => Promise<import("../index.js").OrganizationInvitationResponse>;
+        accept: (invitationId: string) => Promise<import("../index.js").OrganizationMessageResponse>;
+        revoke: (invitationId: string) => Promise<void>;
+    };
+}

package/dist/namespaces/organizations.js

@@ -0,0 +1,51 @@
+import { OrganizationsService } from "../openapi_client/services/OrganizationsService.js";
+export class OrganizationsNamespace {
+    client;
+    http;
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
+    }
+    list(options = {}) {
+        return this.client.request(() => OrganizationsService.orgList(options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    get(orgId) {
+        return this.client.request(() => OrganizationsService.orgGet(orgId));
+    }
+    create(payload) {
+        return this.client.request(() => OrganizationsService.orgCreate(payload));
+    }
+    members = {
+        list: (orgId, options = {}) => this.client.request(() => OrganizationsService.orgMemberList(orgId, options.limit ?? 100, options.pageToken ?? options.cursor)),
+        updateRole: (orgId, memberId, role) => this.client.request(() => OrganizationsService.orgMemberUpdateRole(orgId, memberId, { role })),
+        remove: (orgId, memberId) => this.client.request(() => OrganizationsService.orgMemberRemove(orgId, memberId)),
+    };
+    invitations = {
+        listMine: async (options = {}) => {
+            if (options.status) {
+                return this.client.request(() => OrganizationsService.orgInvitationListMine(options.status, options.limit ?? 100, options.pageToken ?? options.cursor));
+            }
+            return this.http.request("GET", "/organizations/invitations", {
+                params: {
+                    limit: options.limit ?? 100,
+                    page_token: options.pageToken ?? options.cursor,
+                },
+            });
+        },
+        list: async (orgId, options = {}) => {
+            if (options.status) {
+                return this.client.request(() => OrganizationsService.orgInvitationList(orgId, options.status, options.limit ?? 100, options.pageToken ?? options.cursor));
+            }
+            return this.http.request("GET", `/organizations/${encodeURIComponent(orgId)}/invitations`, {
+                params: {
+                    limit: options.limit ?? 100,
+                    page_token: options.pageToken ?? options.cursor,
+                },
+            });
+        },
+        get: (invitationId) => this.client.request(() => OrganizationsService.orgInvitationGet(invitationId)),
+        invite: (orgId, payload) => this.client.request(() => OrganizationsService.orgInvitationInvite(orgId, payload)),
+        accept: (invitationId) => this.client.request(() => OrganizationsService.orgInvitationAccept(invitationId)),
+        revoke: (invitationId) => this.client.request(() => OrganizationsService.orgInvitationRevoke(invitationId)),
+    };
+}

package/dist/namespaces/pod-members.d.ts

@@ -0,0 +1,15 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { PodMemberAddRequest } from "../openapi_client/models/PodMemberAddRequest.js";
+import type { PodRole } from "../openapi_client/models/PodRole.js";
+export declare class PodMembersNamespace {
+    private readonly client;
+    constructor(client: GeneratedClientAdapter);
+    list(podId: string, options?: {
+        limit?: number;
+        pageToken?: string;
+        cursor?: string;
+    }): Promise<import("../index.js").PodMemberListResponse>;
+    add(podId: string, payload: PodMemberAddRequest): Promise<import("../index.js").PodMemberResponse>;
+    updateRole(podId: string, memberId: string, role: PodRole): Promise<import("../index.js").PodMemberResponse>;
+    remove(podId: string, memberId: string): Promise<void>;
+}

package/dist/namespaces/pod-members.js

@@ -0,0 +1,19 @@
+import { PodMembersService } from "../openapi_client/services/PodMembersService.js";
+export class PodMembersNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(podId, options = {}) {
+        return this.client.request(() => PodMembersService.podMemberList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    add(podId, payload) {
+        return this.client.request(() => PodMembersService.podMemberAdd(podId, payload));
+    }
+    updateRole(podId, memberId, role) {
+        return this.client.request(() => PodMembersService.podMemberUpdateRole(podId, memberId, { role }));
+    }
+    remove(podId, memberId) {
+        return this.client.request(() => PodMembersService.podMemberRemove(podId, memberId));
+    }
+}

package/dist/namespaces/pod-surfaces.d.ts

@@ -0,0 +1,16 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateSurfaceRequest } from "../openapi_client/models/CreateSurfaceRequest.js";
+import type { UpdateSurfaceRequest } from "../openapi_client/models/UpdateSurfaceRequest.js";
+export declare class PodSurfacesNamespace {
+    private readonly client;
+    constructor(client: GeneratedClientAdapter);
+    list(podId: string, options?: {
+        limit?: number;
+        pageToken?: string;
+        cursor?: string;
+    }): Promise<import("../index.js").AssistantSurfaceListResponse>;
+    create(podId: string, payload: CreateSurfaceRequest): Promise<any>;
+    get(podId: string, surfaceId: string): Promise<any>;
+    updateConfig(podId: string, surfaceId: string, payload: UpdateSurfaceRequest): Promise<any>;
+    toggle(podId: string, surfaceId: string, isActive: boolean): Promise<any>;
+}

package/dist/namespaces/pod-surfaces.js

@@ -0,0 +1,22 @@
+import { AssistantSurfacesService } from "../openapi_client/services/AssistantSurfacesService.js";
+export class PodSurfacesNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(podId, options = {}) {
+        return this.client.request(() => AssistantSurfacesService.assistantSurfaceList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    create(podId, payload) {
+        return this.client.request(() => AssistantSurfacesService.assistantSurfaceCreate(podId, payload));
+    }
+    get(podId, surfaceId) {
+        return this.client.request(() => AssistantSurfacesService.assistantSurfaceGet(podId, surfaceId));
+    }
+    updateConfig(podId, surfaceId, payload) {
+        return this.client.request(() => AssistantSurfacesService.assistantSurfaceUpdateConfig(podId, surfaceId, payload));
+    }
+    toggle(podId, surfaceId, isActive) {
+        return this.client.request(() => AssistantSurfacesService.assistantSurfaceToggle(podId, surfaceId, { is_active: isActive }));
+    }
+}

package/dist/namespaces/pods.d.ts

@@ -0,0 +1,26 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import type { PodCreateRequest } from "../openapi_client/models/PodCreateRequest.js";
+import type { PodListResponse } from "../openapi_client/models/PodListResponse.js";
+import type { PodUpdateRequest } from "../openapi_client/models/PodUpdateRequest.js";
+export declare class PodsNamespace {
+    private readonly client;
+    private readonly http;
+    constructor(client: GeneratedClientAdapter, http: HttpClient);
+    list(options?: {
+        organizationId?: string;
+        limit?: number;
+        pageToken?: string;
+        cursor?: string;
+    }): Promise<PodListResponse>;
+    listByOrganization(organizationId: string, options?: {
+        limit?: number;
+        pageToken?: string;
+        cursor?: string;
+    }): Promise<PodListResponse>;
+    get(podId: string): Promise<import("../index.js").PodResponse>;
+    create(payload: PodCreateRequest): Promise<import("../index.js").PodResponse>;
+    update(podId: string, payload: PodUpdateRequest): Promise<import("../index.js").PodResponse>;
+    delete(podId: string): Promise<void>;
+    config(podId: string): Promise<import("../index.js").PodConfigResponse>;
+}

package/dist/namespaces/pods.js

@@ -0,0 +1,41 @@
+import { PodsService } from "../openapi_client/services/PodsService.js";
+export class PodsNamespace {
+    client;
+    http;
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
+    }
+    list(options = {}) {
+        if (options.organizationId) {
+            return this.listByOrganization(options.organizationId, {
+                limit: options.limit,
+                pageToken: options.pageToken ?? options.cursor,
+            });
+        }
+        return this.http.request("GET", "/pods", {
+            params: {
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
+            },
+        });
+    }
+    listByOrganization(organizationId, options = {}) {
+        return this.client.request(() => PodsService.podList(organizationId, options.limit ?? 100, options.pageToken ?? options.cursor));
+    }
+    get(podId) {
+        return this.client.request(() => PodsService.podGet(podId));
+    }
+    create(payload) {
+        return this.client.request(() => PodsService.podCreate(payload));
+    }
+    update(podId, payload) {
+        return this.client.request(() => PodsService.podUpdate(podId, payload));
+    }
+    delete(podId) {
+        return this.client.request(() => PodsService.podDelete(podId));
+    }
+    config(podId) {
+        return this.client.request(() => PodsService.podConfigGet(podId));
+    }
+}

package/dist/namespaces/records.d.ts

@@ -1,16 +1,20 @@
 import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import type { RecordListResponse } from "../openapi_client/models/RecordListResponse.js";
 import type { RecordQueryRequest } from "../openapi_client/models/RecordQueryRequest.js";
 import type { ListRecordsOptions } from "../types.js";
 export declare class RecordsNamespace {
     private readonly client;
+    private readonly http;
     private readonly podId;
-    constructor(client: GeneratedClientAdapter, podId: () => string);
-    list(datastore: string, table: string, options?: ListRecordsOptions): Promise<import("../index.js").RecordListResponse>;
+    constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
+    list(datastore: string, table: string, options?: ListRecordsOptions): Promise<RecordListResponse>;
+    listWithParams(datastore: string, table: string, params: Record<string, string | number | boolean | undefined | null>): Promise<RecordListResponse>;
     create(datastore: string, table: string, data: Record<string, unknown>): Promise<import("../index.js").RecordResponse>;
     get(datastore: string, table: string, recordId: string): Promise<import("../index.js").RecordResponse>;
     update(datastore: string, table: string, recordId: string, data: Record<string, unknown>): Promise<import("../index.js").RecordResponse>;
     delete(datastore: string, table: string, recordId: string): Promise<import("../index.js").DatastoreMessageResponse>;
-    query(datastore: string, table: string, payload: RecordQueryRequest): Promise<import("../index.js").RecordListResponse>;
+    query(datastore: string, table: string, payload: RecordQueryRequest): Promise<RecordListResponse>;
     readonly bulk: {
         create: (datastore: string, table: string, records: Record<string, unknown>[]) => Promise<import("../index.js").DatastoreMessageResponse>;
         update: (datastore: string, table: string, records: Record<string, unknown>[]) => Promise<import("../index.js").DatastoreMessageResponse>;

package/dist/namespaces/records.js

@@ -1,19 +1,50 @@
 import { RecordsService } from "../openapi_client/services/RecordsService.js";
+function getRecordsPath(podId, datastore, table) {
+    return `/pods/${encodeURIComponent(podId)}/datastores/${encodeURIComponent(datastore)}/tables/${encodeURIComponent(table)}/records`;
+}
 export class RecordsNamespace {
     client;
+    http;
     podId;
-    constructor(client, podId) {
+    constructor(client, http, podId) {
         this.client = client;
+        this.http = http;
         this.podId = podId;
     }
     list(datastore, table, options = {}) {
-        const { filters, sort, limit, pageToken } = options;
+        const { filters, sort, limit, pageToken, offset, sortBy, order, params } = options;
         if (filters || sort) {
-            const payload = { filters, sort, limit, page_token: pageToken };
+            const payload = {
+                filters,
+                sort,
+                limit,
+                page_token: pageToken,
+            };
             return this.client.request(() => RecordsService.recordQuery(this.podId(), datastore, table, payload));
         }
+        const hasCustomParams = typeof offset === "number" ||
+            typeof sortBy === "string" ||
+            typeof order === "string" ||
+            !!params;
+        if (hasCustomParams) {
+            return this.http.request("GET", getRecordsPath(this.podId(), datastore, table), {
+                params: {
+                    limit: limit ?? 20,
+                    page_token: pageToken,
+                    offset,
+                    sort_by: sortBy,
+                    order,
+                    ...(params ?? {}),
+                },
+            });
+        }
         return this.client.request(() => RecordsService.recordList(this.podId(), datastore, table, limit ?? 20, pageToken));
     }
+    listWithParams(datastore, table, params) {
+        return this.http.request("GET", getRecordsPath(this.podId(), datastore, table), {
+            params,
+        });
+    }
     create(datastore, table, data) {
         return this.client.request(() => RecordsService.recordCreate(this.podId(), datastore, table, { data }));
     }

package/dist/namespaces/resources.d.ts

@@ -0,0 +1,16 @@
+import type { HttpClient } from "../http.js";
+export type ResourceType = "conversation" | "assistant" | "task" | string;
+export declare class ResourcesNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(resourceType: ResourceType, resourceId: string, options?: {
+        path?: string;
+    }): Promise<unknown>;
+    upload(resourceType: ResourceType, resourceId: string, file: Blob, options?: {
+        path?: string;
+        name?: string;
+        fieldName?: string;
+    }): Promise<unknown>;
+    delete(resourceType: ResourceType, resourceId: string, filePath: string): Promise<unknown>;
+    download(resourceType: ResourceType, resourceId: string, filePath: string): Promise<Blob>;
+}

package/dist/namespaces/resources.js

@@ -0,0 +1,32 @@
+export class ResourcesNamespace {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(resourceType, resourceId, options = {}) {
+        return this.http.request("GET", `/files/${resourceType}/${resourceId}/list`, {
+            params: {
+                path: options.path,
+            },
+        });
+    }
+    upload(resourceType, resourceId, file, options = {}) {
+        const formData = new FormData();
+        const fieldName = options.fieldName ?? "file";
+        const name = options.name ?? (file instanceof File ? file.name : "upload.bin");
+        formData.append(fieldName, file, name);
+        return this.http.request("POST", `/files/${resourceType}/${resourceId}/upload`, {
+            params: {
+                path: options.path,
+            },
+            body: formData,
+            isFormData: true,
+        });
+    }
+    delete(resourceType, resourceId, filePath) {
+        return this.http.request("DELETE", `/files/${resourceType}/${resourceId}/delete/${filePath}`);
+    }
+    download(resourceType, resourceId, filePath) {
+        return this.http.requestBytes("GET", `/files/${resourceType}/${resourceId}/download/${filePath}`);
+    }
+}

package/dist/namespaces/tables.d.ts

@@ -2,6 +2,11 @@ import type { GeneratedClientAdapter } from "../generated.js";
 import type { AddColumnRequest } from "../openapi_client/models/AddColumnRequest.js";
 import type { CreateTableRequest } from "../openapi_client/models/CreateTableRequest.js";
 import type { UpdateTableRequest } from "../openapi_client/models/UpdateTableRequest.js";
+type LegacyCreateTableRequest = Omit<CreateTableRequest, "name"> & {
+    table_name: string;
+    name?: string;
+};
+export type CreateTableInput = CreateTableRequest | LegacyCreateTableRequest;
 export declare class TablesNamespace {
     private readonly client;
     private readonly podId;
@@ -10,7 +15,7 @@ export declare class TablesNamespace {
         limit?: number;
         pageToken?: string;
     }): Promise<import("../index.js").TableListResponse>;
-    create(datastore: string, payload: CreateTableRequest): Promise<import("../index.js").TableResponse>;
+    create(datastore: string, payload: CreateTableInput): Promise<import("../index.js").TableResponse>;
     get(datastore: string, tableName: string): Promise<import("../index.js").TableResponse>;
     update(datastore: string, tableName: string, payload: UpdateTableRequest): Promise<import("../index.js").TableResponse>;
     delete(datastore: string, tableName: string): Promise<import("../index.js").DatastoreMessageResponse>;
@@ -19,3 +24,4 @@ export declare class TablesNamespace {
         remove: (datastore: string, tableName: string, columnName: string) => Promise<import("../index.js").DatastoreMessageResponse>;
     };
 }
+export {};

package/dist/namespaces/tables.js

@@ -1,4 +1,14 @@
 import { TablesService } from "../openapi_client/services/TablesService.js";
+function normalizeCreateTablePayload(payload) {
+    if ("table_name" in payload) {
+        const { table_name, name, ...rest } = payload;
+        return {
+            ...rest,
+            name: name ?? table_name,
+        };
+    }
+    return payload;
+}
 export class TablesNamespace {
     client;
     podId;
@@ -10,7 +20,7 @@ export class TablesNamespace {
         return this.client.request(() => TablesService.tableList(this.podId(), datastore, options.limit ?? 100, options.pageToken));
     }
     create(datastore, payload) {
-        return this.client.request(() => TablesService.tableCreate(this.podId(), datastore, payload));
+        return this.client.request(() => TablesService.tableCreate(this.podId(), datastore, normalizeCreateTablePayload(payload)));
     }
     get(datastore, tableName) {
         return this.client.request(() => TablesService.tableGet(this.podId(), datastore, tableName));

package/dist/namespaces/tasks.d.ts

@@ -1,22 +1,28 @@
-import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
 import type { CreateTaskOptions } from "../types.js";
 export declare class TasksNamespace {
-    private readonly client;
+    private readonly http;
     private readonly podId;
-    constructor(client: GeneratedClientAdapter, podId: () => string);
+    constructor(http: HttpClient, podId: () => string);
     list(options?: {
         agentName?: string;
+        agentId?: string;
         limit?: number;
         pageToken?: string;
-    }): Promise<import("../index.js").TaskListResponse>;
-    create(options: CreateTaskOptions): Promise<import("../index.js").TaskResponse>;
-    get(taskId: string): Promise<import("../index.js").TaskResponse>;
-    stop(taskId: string): Promise<import("../index.js").TaskResponse>;
+        cursor?: string;
+    }): Promise<unknown>;
+    create(options: CreateTaskOptions): Promise<unknown>;
+    get(taskId: string): Promise<unknown>;
+    stop(taskId: string): Promise<unknown>;
+    stream(taskId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
     readonly messages: {
         list: (taskId: string, options?: {
             limit?: number;
             pageToken?: string;
-        }) => Promise<import("../index.js").TaskMessageListResponse>;
-        add: (taskId: string, content: string) => Promise<import("../index.js").TaskResponse>;
+            cursor?: string;
+        }) => Promise<unknown>;
+        add: (taskId: string, content: string) => Promise<unknown>;
     };
 }

package/dist/namespaces/tasks.js

@@ -1,29 +1,61 @@
-import { TasksService } from "../openapi_client/services/TasksService.js";
 export class TasksNamespace {
-    client;
+    http;
     podId;
-    constructor(client, podId) {
-        this.client = client;
+    constructor(http, podId) {
+        this.http = http;
         this.podId = podId;
     }
     list(options = {}) {
-        return this.client.request(() => TasksService.taskList(this.podId(), options.agentName, options.limit ?? 100, options.pageToken));
+        return this.http.request("GET", `/pods/${this.podId()}/tasks`, {
+            params: {
+                agent_name: options.agentName,
+                agent_id: options.agentId,
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
+                cursor: options.cursor,
+            },
+        });
     }
     create(options) {
-        const payload = { agent_name: options.agentName, input_data: options.input };
-        return this.client.request(() => TasksService.taskCreate(this.podId(), payload));
+        if (!options.agentId && !options.agentName) {
+            throw new Error("Either agentId or agentName is required.");
+        }
+        return this.http.request("POST", `/pods/${this.podId()}/tasks`, {
+            body: {
+                agent_id: options.agentId,
+                agent_name: options.agentName ?? options.agentId,
+                input_data: options.input,
+                runtime_account_ids: options.runtimeAccountIds,
+            },
+        });
     }
     get(taskId) {
-        return this.client.request(() => TasksService.taskGet(this.podId(), taskId));
+        return this.http.request("GET", `/pods/${this.podId()}/tasks/${taskId}`);
     }
     stop(taskId) {
-        return this.client.request(() => TasksService.taskStop(this.podId(), taskId));
+        return this.http.request("PATCH", `/pods/${this.podId()}/tasks/${taskId}/stop`);
+    }
+    stream(taskId, options = {}) {
+        return this.http.stream(`/pods/${this.podId()}/tasks/${taskId}/stream`, {
+            signal: options.signal,
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
     }
     messages = {
-        list: (taskId, options = {}) => this.client.request(() => TasksService.taskMessageList(this.podId(), taskId, options.limit ?? 100, options.pageToken)),
+        list: (taskId, options = {}) => this.http.request("GET", `/pods/${this.podId()}/tasks/${taskId}/messages`, {
+            params: {
+                limit: options.limit ?? 100,
+                page_token: options.pageToken ?? options.cursor,
+                cursor: options.cursor,
+            },
+        }),
         add: (taskId, content) => {
             const payload = { content };
-            return this.client.request(() => TasksService.taskMessageAdd(this.podId(), taskId, payload));
+            return this.http.request("POST", `/pods/${this.podId()}/tasks/${taskId}/messages`, {
+                body: payload,
+            });
         },
     };
 }

package/dist/namespaces/users.d.ts

@@ -0,0 +1,9 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { UserProfileRequest } from "../openapi_client/models/UserProfileRequest.js";
+export declare class UsersNamespace {
+    private readonly client;
+    constructor(client: GeneratedClientAdapter);
+    current(): Promise<import("../index.js").UserResponse>;
+    getProfile(): Promise<import("../index.js").UserResponse>;
+    upsertProfile(payload: UserProfileRequest): Promise<import("../index.js").UserResponse>;
+}

package/dist/namespaces/users.js

@@ -0,0 +1,16 @@
+import { UsersService } from "../openapi_client/services/UsersService.js";
+export class UsersNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    current() {
+        return this.client.request(() => UsersService.userCurrentGet());
+    }
+    getProfile() {
+        return this.client.request(() => UsersService.userProfileGet());
+    }
+    upsertProfile(payload) {
+        return this.client.request(() => UsersService.userProfileUpsert(payload));
+    }
+}

package/dist/namespaces/workflows.d.ts

@@ -1,4 +1,5 @@
 import type { GeneratedClientAdapter } from "../generated.js";
+import { type HttpClient } from "../http.js";
 import type { WorkflowCreateRequest } from "../openapi_client/models/WorkflowCreateRequest.js";
 import type { WorkflowGraphUpdateRequest } from "../openapi_client/models/WorkflowGraphUpdateRequest.js";
 import type { WorkflowInstallRequest } from "../openapi_client/models/WorkflowInstallRequest.js";
@@ -6,8 +7,9 @@ import type { WorkflowUpdateRequest } from "../openapi_client/models/WorkflowUpd
 import type { WorkflowRunInputs } from "../types.js";
 export declare class WorkflowsNamespace {
     private readonly client;
+    private readonly http;
     private readonly podId;
-    constructor(client: GeneratedClientAdapter, podId: () => string);
+    constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
     list(options?: {
         limit?: number;
         pageToken?: string;
@@ -16,6 +18,7 @@ export declare class WorkflowsNamespace {
     get(workflowName: string): Promise<import("../index.js").FlowEntity>;
     update(workflowName: string, payload: WorkflowUpdateRequest): Promise<import("../index.js").FlowEntity>;
     delete(workflowName: string): Promise<void>;
+    visualize(workflowName: string): Promise<string>;
     readonly graph: {
         update: (workflowName: string, graph: WorkflowGraphUpdateRequest) => Promise<import("../index.js").FlowEntity>;
     };
@@ -23,6 +26,7 @@ export declare class WorkflowsNamespace {
         create: (workflowName: string, payload?: WorkflowInstallRequest) => Promise<import("../index.js").FlowInstallEntity>;
         delete: (workflowName: string, installId: string) => Promise<void>;
     };
+    private postRunAction;
     readonly runs: {
         start: (workflowName: string, inputs?: WorkflowRunInputs) => Promise<import("../index.js").FlowRunEntity>;
         list: (workflowName: string, options?: {
@@ -31,5 +35,8 @@ export declare class WorkflowsNamespace {
         }) => Promise<import("../index.js").WorkflowRunListResponse>;
         get: (runId: string, podId?: string) => Promise<import("../index.js").FlowRunEntity>;
         resume: (runId: string, inputs?: WorkflowRunInputs, podId?: string) => Promise<import("../index.js").FlowRunEntity>;
+        visualize: (runId: string, podId?: string) => Promise<string>;
+        cancel: (runId: string, podId?: string) => Promise<Record<string, unknown>>;
+        retry: (runId: string, podId?: string) => Promise<Record<string, unknown>>;
     };
 }