@knowledge-stack/ksapi 1.88.0 → 1.89.0

package/src/apis/PathPartsApi.ts

@@ -356,7 +356,7 @@ export interface PathPartsApiInterface {
     listPathPartsRequestOpts(requestParameters: ListPathPartsRequest): Promise<runtime.RequestOpts>;
 
     /**
-     * List path parts (folders) under a parent with traversal.  This is a generic endpoint for traversing the folder hierarchy. It returns only FOLDER type path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
+     * List path parts under a parent with traversal.  This is a generic endpoint for traversing the path hierarchy. It returns the navigable, container-like nodes of the tree: FOLDER, WORKFLOW_DEFINITION, and WORKFLOW_RUN path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
      * @summary List Path Parts Handler
      * @param {string} [parentPathId] Parent PathPart ID (defaults to root)
      * @param {number} [maxDepth] Maximum depth to traverse (1 &#x3D; direct children, default: 1)
@@ -372,7 +372,7 @@ export interface PathPartsApiInterface {
     listPathPartsRaw(requestParameters: ListPathPartsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedResponsePathPartResponse>>;
 
     /**
-     * List path parts (folders) under a parent with traversal.  This is a generic endpoint for traversing the folder hierarchy. It returns only FOLDER type path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
+     * List path parts under a parent with traversal.  This is a generic endpoint for traversing the path hierarchy. It returns the navigable, container-like nodes of the tree: FOLDER, WORKFLOW_DEFINITION, and WORKFLOW_RUN path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
      * List Path Parts Handler
      */
     listPathParts(requestParameters: ListPathPartsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponsePathPartResponse>;
@@ -863,7 +863,7 @@ export class PathPartsApi extends runtime.BaseAPI implements PathPartsApiInterfa
     }
 
     /**
-     * List path parts (folders) under a parent with traversal.  This is a generic endpoint for traversing the folder hierarchy. It returns only FOLDER type path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
+     * List path parts under a parent with traversal.  This is a generic endpoint for traversing the path hierarchy. It returns the navigable, container-like nodes of the tree: FOLDER, WORKFLOW_DEFINITION, and WORKFLOW_RUN path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
      * List Path Parts Handler
      */
     async listPathPartsRaw(requestParameters: ListPathPartsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedResponsePathPartResponse>> {
@@ -874,7 +874,7 @@ export class PathPartsApi extends runtime.BaseAPI implements PathPartsApiInterfa
     }
 
     /**
-     * List path parts (folders) under a parent with traversal.  This is a generic endpoint for traversing the folder hierarchy. It returns only FOLDER type path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
+     * List path parts under a parent with traversal.  This is a generic endpoint for traversing the path hierarchy. It returns the navigable, container-like nodes of the tree: FOLDER, WORKFLOW_DEFINITION, and WORKFLOW_RUN path parts.  - If parent_path_id is not provided, lists contents of the root folder. - max_depth controls how deep to traverse (1 = direct children only). - sort_order controls the ordering: LOGICAL (linked-list), NAME, UPDATED_AT, CREATED_AT.  For listing folder contents that includes documents with enriched metadata, use GET /folders/{folder_id}/contents instead.
      * List Path Parts Handler
      */
     async listPathParts(requestParameters: ListPathPartsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponsePathPartResponse> {

package/src/apis/WorkflowDefinitionsApi.ts

@@ -17,7 +17,6 @@ import * as runtime from '../runtime';
 import type {
   CreateWorkflowDefinitionRequest,
   HTTPValidationError,
-  InvokeWorkflowRequest,
   PaginatedResponseWorkflowDefinitionResponse,
   PaginatedResponseWorkflowRunResponse,
   UpdateWorkflowDefinitionRequest,
@@ -29,8 +28,6 @@ import {
     CreateWorkflowDefinitionRequestToJSON,
     HTTPValidationErrorFromJSON,
     HTTPValidationErrorToJSON,
-    InvokeWorkflowRequestFromJSON,
-    InvokeWorkflowRequestToJSON,
     PaginatedResponseWorkflowDefinitionResponseFromJSON,
     PaginatedResponseWorkflowDefinitionResponseToJSON,
     PaginatedResponseWorkflowRunResponseFromJSON,
@@ -49,21 +46,23 @@ export interface CreateWorkflowDefinitionOperationRequest {
     ksUat?: string | null;
 }
 
-export interface DeleteWorkflowDefinitionRequest {
+export interface CreateWorkflowRunRequest {
     definitionId: string;
     authorization?: string | null;
     ksUat?: string | null;
+    files?: Array<Blob>;
+    inputScope?: string | null;
+    idempotencyKey?: string | null;
 }
 
-export interface GetWorkflowDefinitionRequest {
+export interface DeleteWorkflowDefinitionRequest {
     definitionId: string;
     authorization?: string | null;
     ksUat?: string | null;
 }
 
-export interface InvokeWorkflowOperationRequest {
+export interface GetWorkflowDefinitionRequest {
     definitionId: string;
-    invokeWorkflowRequest: InvokeWorkflowRequest;
     authorization?: string | null;
     ksUat?: string | null;
 }
@@ -125,45 +124,52 @@ export interface WorkflowDefinitionsApiInterface {
     createWorkflowDefinition(requestParameters: CreateWorkflowDefinitionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowDefinitionResponse>;
 
     /**
-     * Creates request options for deleteWorkflowDefinition without sending the request
+     * Creates request options for createWorkflowRun without sending the request
      * @param {string} definitionId 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
+     * @param {Array<Blob>} [files] Files to ingest under the run\\\&#39;s &#x60;&#x60;inputs/&#x60;&#x60; folder. Each filename may include POSIX-style &#x60;&#x60;/&#x60;&#x60; separators to reconstruct a folder structure under &#x60;&#x60;inputs/&#x60;&#x60;.
+     * @param {string} [inputScope] JSON array of &#x60;&#x60;DOCUMENT&#x60;&#x60; or &#x60;&#x60;FOLDER&#x60;&#x60; path_part UUIDs referenced from the existing knowledge base. Combined with &#x60;&#x60;files&#x60;&#x60; in a single request to form the run\\\&#39;s input scope.
+     * @param {string} [idempotencyKey] Optional key to prevent duplicate runs from retries.
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    deleteWorkflowDefinitionRequestOpts(requestParameters: DeleteWorkflowDefinitionRequest): Promise<runtime.RequestOpts>;
+    createWorkflowRunRequestOpts(requestParameters: CreateWorkflowRunRequest): Promise<runtime.RequestOpts>;
 
     /**
-     * 
-     * @summary Delete Workflow Definition Handler
+     * Trigger a workflow run from uploaded files and/or KB references.  The merged endpoint accepts both kinds of input in one multipart request. Each uploaded file is ingested under ``runs/<id>/inputs/`` (S3 + DB rows only; no Temporal pipeline). Each ``input_scope`` entry is resolved per its part_type: a DOCUMENT is pinned to its active ``DOCUMENT_VERSION``; a FOLDER is pinned by reference only and read live by the runner. A request that supplies neither is rejected.
+     * @summary Create Workflow Run Handler
      * @param {string} definitionId 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
+     * @param {Array<Blob>} [files] Files to ingest under the run\\\&#39;s &#x60;&#x60;inputs/&#x60;&#x60; folder. Each filename may include POSIX-style &#x60;&#x60;/&#x60;&#x60; separators to reconstruct a folder structure under &#x60;&#x60;inputs/&#x60;&#x60;.
+     * @param {string} [inputScope] JSON array of &#x60;&#x60;DOCUMENT&#x60;&#x60; or &#x60;&#x60;FOLDER&#x60;&#x60; path_part UUIDs referenced from the existing knowledge base. Combined with &#x60;&#x60;files&#x60;&#x60; in a single request to form the run\\\&#39;s input scope.
+     * @param {string} [idempotencyKey] Optional key to prevent duplicate runs from retries.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    deleteWorkflowDefinitionRaw(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    createWorkflowRunRaw(requestParameters: CreateWorkflowRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowRunResponse>>;
 
     /**
-     * Delete Workflow Definition Handler
+     * Trigger a workflow run from uploaded files and/or KB references.  The merged endpoint accepts both kinds of input in one multipart request. Each uploaded file is ingested under ``runs/<id>/inputs/`` (S3 + DB rows only; no Temporal pipeline). Each ``input_scope`` entry is resolved per its part_type: a DOCUMENT is pinned to its active ``DOCUMENT_VERSION``; a FOLDER is pinned by reference only and read live by the runner. A request that supplies neither is rejected.
+     * Create Workflow Run Handler
      */
-    deleteWorkflowDefinition(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    createWorkflowRun(requestParameters: CreateWorkflowRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowRunResponse>;
 
     /**
-     * Creates request options for getWorkflowDefinition without sending the request
+     * Creates request options for deleteWorkflowDefinition without sending the request
      * @param {string} definitionId 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    getWorkflowDefinitionRequestOpts(requestParameters: GetWorkflowDefinitionRequest): Promise<runtime.RequestOpts>;
+    deleteWorkflowDefinitionRequestOpts(requestParameters: DeleteWorkflowDefinitionRequest): Promise<runtime.RequestOpts>;
 
     /**
      * 
-     * @summary Get Workflow Definition Handler
+     * @summary Delete Workflow Definition Handler
      * @param {string} definitionId 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
@@ -171,42 +177,39 @@ export interface WorkflowDefinitionsApiInterface {
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    getWorkflowDefinitionRaw(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowDefinitionResponse>>;
+    deleteWorkflowDefinitionRaw(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
 
     /**
-     * Get Workflow Definition Handler
+     * Delete Workflow Definition Handler
      */
-    getWorkflowDefinition(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowDefinitionResponse>;
+    deleteWorkflowDefinition(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 
     /**
-     * Creates request options for invokeWorkflow without sending the request
+     * Creates request options for getWorkflowDefinition without sending the request
      * @param {string} definitionId 
-     * @param {InvokeWorkflowRequest} invokeWorkflowRequest 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    invokeWorkflowRequestOpts(requestParameters: InvokeWorkflowOperationRequest): Promise<runtime.RequestOpts>;
+    getWorkflowDefinitionRequestOpts(requestParameters: GetWorkflowDefinitionRequest): Promise<runtime.RequestOpts>;
 
     /**
-     * Trigger a workflow run.  All business logic lives in ``WorkflowInvocationService``. This handler only orchestrates the two phases:  1. **Phase 1 (in-session):** validate, build snapshot, persist run row,    mint JWT. Wrapped in a single DB session so the run insert and the    idempotency-race resolution share a transaction. 2. **Phase 2 (out-of-session):** dispatch HTTP call to the SELF_HOSTED    runner. Best-effort — the run is already persisted, so failures here    transition the run to ``FAILED`` rather than rejecting the request.
-     * @summary Invoke Workflow Handler
+     * 
+     * @summary Get Workflow Definition Handler
      * @param {string} definitionId 
-     * @param {InvokeWorkflowRequest} invokeWorkflowRequest 
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof WorkflowDefinitionsApiInterface
      */
-    invokeWorkflowRaw(requestParameters: InvokeWorkflowOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowRunResponse>>;
+    getWorkflowDefinitionRaw(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowDefinitionResponse>>;
 
     /**
-     * Trigger a workflow run.  All business logic lives in ``WorkflowInvocationService``. This handler only orchestrates the two phases:  1. **Phase 1 (in-session):** validate, build snapshot, persist run row,    mint JWT. Wrapped in a single DB session so the run insert and the    idempotency-race resolution share a transaction. 2. **Phase 2 (out-of-session):** dispatch HTTP call to the SELF_HOSTED    runner. Best-effort — the run is already persisted, so failures here    transition the run to ``FAILED`` rather than rejecting the request.
-     * Invoke Workflow Handler
+     * Get Workflow Definition Handler
      */
-    invokeWorkflow(requestParameters: InvokeWorkflowOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowRunResponse>;
+    getWorkflowDefinition(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowDefinitionResponse>;
 
     /**
      * Creates request options for listWorkflowDefinitions without sending the request
@@ -356,13 +359,13 @@ export class WorkflowDefinitionsApi extends runtime.BaseAPI implements WorkflowD
     }
 
     /**
-     * Creates request options for deleteWorkflowDefinition without sending the request
+     * Creates request options for createWorkflowRun without sending the request
      */
-    async deleteWorkflowDefinitionRequestOpts(requestParameters: DeleteWorkflowDefinitionRequest): Promise<runtime.RequestOpts> {
+    async createWorkflowRunRequestOpts(requestParameters: CreateWorkflowRunRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['definitionId'] == null) {
             throw new runtime.RequiredError(
                 'definitionId',
-                'Required parameter "definitionId" was null or undefined when calling deleteWorkflowDefinition().'
+                'Required parameter "definitionId" was null or undefined when calling createWorkflowRun().'
             );
         }
 
@@ -374,43 +377,77 @@ export class WorkflowDefinitionsApi extends runtime.BaseAPI implements WorkflowD
             headerParameters['authorization'] = String(requestParameters['authorization']);
         }
 
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        // use FormData to transmit files using content-type "multipart/form-data"
+        useForm = canConsumeForm;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['files'] != null) {
+            requestParameters['files'].forEach((element) => {
+                formParams.append('files', element as any);
+            })
+        }
 
-        let urlPath = `/v1/workflow-definitions/{definition_id}`;
+        if (requestParameters['inputScope'] != null) {
+            formParams.append('input_scope', requestParameters['inputScope'] as any);
+        }
+
+        if (requestParameters['idempotencyKey'] != null) {
+            formParams.append('idempotency_key', requestParameters['idempotencyKey'] as any);
+        }
+
+
+        let urlPath = `/v1/workflow-definitions/{definition_id}/runs`;
         urlPath = urlPath.replace(`{${"definition_id"}}`, encodeURIComponent(String(requestParameters['definitionId'])));
 
         return {
             path: urlPath,
-            method: 'DELETE',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: formParams,
         };
     }
 
     /**
-     * Delete Workflow Definition Handler
+     * Trigger a workflow run from uploaded files and/or KB references.  The merged endpoint accepts both kinds of input in one multipart request. Each uploaded file is ingested under ``runs/<id>/inputs/`` (S3 + DB rows only; no Temporal pipeline). Each ``input_scope`` entry is resolved per its part_type: a DOCUMENT is pinned to its active ``DOCUMENT_VERSION``; a FOLDER is pinned by reference only and read live by the runner. A request that supplies neither is rejected.
+     * Create Workflow Run Handler
      */
-    async deleteWorkflowDefinitionRaw(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        const requestOptions = await this.deleteWorkflowDefinitionRequestOpts(requestParameters);
+    async createWorkflowRunRaw(requestParameters: CreateWorkflowRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowRunResponse>> {
+        const requestOptions = await this.createWorkflowRunRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => WorkflowRunResponseFromJSON(jsonValue));
     }
 
     /**
-     * Delete Workflow Definition Handler
+     * Trigger a workflow run from uploaded files and/or KB references.  The merged endpoint accepts both kinds of input in one multipart request. Each uploaded file is ingested under ``runs/<id>/inputs/`` (S3 + DB rows only; no Temporal pipeline). Each ``input_scope`` entry is resolved per its part_type: a DOCUMENT is pinned to its active ``DOCUMENT_VERSION``; a FOLDER is pinned by reference only and read live by the runner. A request that supplies neither is rejected.
+     * Create Workflow Run Handler
      */
-    async deleteWorkflowDefinition(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.deleteWorkflowDefinitionRaw(requestParameters, initOverrides);
+    async createWorkflowRun(requestParameters: CreateWorkflowRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowRunResponse> {
+        const response = await this.createWorkflowRunRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Creates request options for getWorkflowDefinition without sending the request
+     * Creates request options for deleteWorkflowDefinition without sending the request
      */
-    async getWorkflowDefinitionRequestOpts(requestParameters: GetWorkflowDefinitionRequest): Promise<runtime.RequestOpts> {
+    async deleteWorkflowDefinitionRequestOpts(requestParameters: DeleteWorkflowDefinitionRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['definitionId'] == null) {
             throw new runtime.RequiredError(
                 'definitionId',
-                'Required parameter "definitionId" was null or undefined when calling getWorkflowDefinition().'
+                'Required parameter "definitionId" was null or undefined when calling deleteWorkflowDefinition().'
             );
         }
 
@@ -428,45 +465,37 @@ export class WorkflowDefinitionsApi extends runtime.BaseAPI implements WorkflowD
 
         return {
             path: urlPath,
-            method: 'GET',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         };
     }
 
     /**
-     * Get Workflow Definition Handler
+     * Delete Workflow Definition Handler
      */
-    async getWorkflowDefinitionRaw(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowDefinitionResponse>> {
-        const requestOptions = await this.getWorkflowDefinitionRequestOpts(requestParameters);
+    async deleteWorkflowDefinitionRaw(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteWorkflowDefinitionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => WorkflowDefinitionResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get Workflow Definition Handler
+     * Delete Workflow Definition Handler
      */
-    async getWorkflowDefinition(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowDefinitionResponse> {
-        const response = await this.getWorkflowDefinitionRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteWorkflowDefinition(requestParameters: DeleteWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteWorkflowDefinitionRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Creates request options for invokeWorkflow without sending the request
+     * Creates request options for getWorkflowDefinition without sending the request
      */
-    async invokeWorkflowRequestOpts(requestParameters: InvokeWorkflowOperationRequest): Promise<runtime.RequestOpts> {
+    async getWorkflowDefinitionRequestOpts(requestParameters: GetWorkflowDefinitionRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['definitionId'] == null) {
             throw new runtime.RequiredError(
                 'definitionId',
-                'Required parameter "definitionId" was null or undefined when calling invokeWorkflow().'
-            );
-        }
-
-        if (requestParameters['invokeWorkflowRequest'] == null) {
-            throw new runtime.RequiredError(
-                'invokeWorkflowRequest',
-                'Required parameter "invokeWorkflowRequest" was null or undefined when calling invokeWorkflow().'
+                'Required parameter "definitionId" was null or undefined when calling getWorkflowDefinition().'
             );
         }
 
@@ -474,42 +503,37 @@ export class WorkflowDefinitionsApi extends runtime.BaseAPI implements WorkflowD
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (requestParameters['authorization'] != null) {
             headerParameters['authorization'] = String(requestParameters['authorization']);
         }
 
 
-        let urlPath = `/v1/workflow-definitions/{definition_id}/invoke`;
+        let urlPath = `/v1/workflow-definitions/{definition_id}`;
         urlPath = urlPath.replace(`{${"definition_id"}}`, encodeURIComponent(String(requestParameters['definitionId'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: InvokeWorkflowRequestToJSON(requestParameters['invokeWorkflowRequest']),
         };
     }
 
     /**
-     * Trigger a workflow run.  All business logic lives in ``WorkflowInvocationService``. This handler only orchestrates the two phases:  1. **Phase 1 (in-session):** validate, build snapshot, persist run row,    mint JWT. Wrapped in a single DB session so the run insert and the    idempotency-race resolution share a transaction. 2. **Phase 2 (out-of-session):** dispatch HTTP call to the SELF_HOSTED    runner. Best-effort — the run is already persisted, so failures here    transition the run to ``FAILED`` rather than rejecting the request.
-     * Invoke Workflow Handler
+     * Get Workflow Definition Handler
      */
-    async invokeWorkflowRaw(requestParameters: InvokeWorkflowOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowRunResponse>> {
-        const requestOptions = await this.invokeWorkflowRequestOpts(requestParameters);
+    async getWorkflowDefinitionRaw(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowDefinitionResponse>> {
+        const requestOptions = await this.getWorkflowDefinitionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => WorkflowRunResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => WorkflowDefinitionResponseFromJSON(jsonValue));
     }
 
     /**
-     * Trigger a workflow run.  All business logic lives in ``WorkflowInvocationService``. This handler only orchestrates the two phases:  1. **Phase 1 (in-session):** validate, build snapshot, persist run row,    mint JWT. Wrapped in a single DB session so the run insert and the    idempotency-race resolution share a transaction. 2. **Phase 2 (out-of-session):** dispatch HTTP call to the SELF_HOSTED    runner. Best-effort — the run is already persisted, so failures here    transition the run to ``FAILED`` rather than rejecting the request.
-     * Invoke Workflow Handler
+     * Get Workflow Definition Handler
      */
-    async invokeWorkflow(requestParameters: InvokeWorkflowOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowRunResponse> {
-        const response = await this.invokeWorkflowRaw(requestParameters, initOverrides);
+    async getWorkflowDefinition(requestParameters: GetWorkflowDefinitionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowDefinitionResponse> {
+        const response = await this.getWorkflowDefinitionRaw(requestParameters, initOverrides);
         return await response.value();
     }
 

package/src/apis/WorkflowMemoryApi.ts

@@ -18,8 +18,8 @@ import type {
   AppendMemoryChunkRequest,
   EditMemoryChunkRequest,
   HTTPValidationError,
-  ListMemoryChunksResponse,
   MemoryChunkResponse,
+  PaginatedResponseMemoryChunkResponse,
 } from '../models/index';
 import {
     AppendMemoryChunkRequestFromJSON,
@@ -28,10 +28,10 @@ import {
     EditMemoryChunkRequestToJSON,
     HTTPValidationErrorFromJSON,
     HTTPValidationErrorToJSON,
-    ListMemoryChunksResponseFromJSON,
-    ListMemoryChunksResponseToJSON,
     MemoryChunkResponseFromJSON,
     MemoryChunkResponseToJSON,
+    PaginatedResponseMemoryChunkResponseFromJSON,
+    PaginatedResponseMemoryChunkResponseToJSON,
 } from '../models/index';
 
 export interface AppendWorkflowMemoryChunkRequest {
@@ -65,6 +65,8 @@ export interface GetWorkflowMemoryChunkRequest {
 
 export interface ListWorkflowMemoryChunksRequest {
     definitionId: string;
+    limit?: number;
+    offset?: number;
     authorization?: string | null;
     ksUat?: string | null;
 }
@@ -88,7 +90,7 @@ export interface WorkflowMemoryApiInterface {
     appendWorkflowMemoryChunkRequestOpts(requestParameters: AppendWorkflowMemoryChunkRequest): Promise<runtime.RequestOpts>;
 
     /**
-     * Append a new memory chunk.  Exposed for external agents (e.g. self-hosted runners) that need to capture learnings without touching the DB directly. The new chunk\'s ``chunk_id`` is server-assigned. Each call snapshots a new DocumentVersion, just like edit/forget.
+     * 
      * @summary Append Workflow Memory Chunk Handler
      * @param {string} definitionId 
      * @param {AppendMemoryChunkRequest} appendMemoryChunkRequest 
@@ -101,7 +103,6 @@ export interface WorkflowMemoryApiInterface {
     appendWorkflowMemoryChunkRaw(requestParameters: AppendWorkflowMemoryChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MemoryChunkResponse>>;
 
     /**
-     * Append a new memory chunk.  Exposed for external agents (e.g. self-hosted runners) that need to capture learnings without touching the DB directly. The new chunk\'s ``chunk_id`` is server-assigned. Each call snapshots a new DocumentVersion, just like edit/forget.
      * Append Workflow Memory Chunk Handler
      */
     appendWorkflowMemoryChunk(requestParameters: AppendWorkflowMemoryChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MemoryChunkResponse>;
@@ -198,6 +199,8 @@ export interface WorkflowMemoryApiInterface {
     /**
      * Creates request options for listWorkflowMemoryChunks without sending the request
      * @param {string} definitionId 
+     * @param {number} [limit] Number of items per page
+     * @param {number} [offset] Number of items to skip
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
      * @throws {RequiredError}
@@ -209,18 +212,20 @@ export interface WorkflowMemoryApiInterface {
      * 
      * @summary List Workflow Memory Chunks Handler
      * @param {string} definitionId 
+     * @param {number} [limit] Number of items per page
+     * @param {number} [offset] Number of items to skip
      * @param {string} [authorization] 
      * @param {string} [ksUat] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof WorkflowMemoryApiInterface
      */
-    listWorkflowMemoryChunksRaw(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListMemoryChunksResponse>>;
+    listWorkflowMemoryChunksRaw(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedResponseMemoryChunkResponse>>;
 
     /**
      * List Workflow Memory Chunks Handler
      */
-    listWorkflowMemoryChunks(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListMemoryChunksResponse>;
+    listWorkflowMemoryChunks(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponseMemoryChunkResponse>;
 
 }
 
@@ -271,7 +276,6 @@ export class WorkflowMemoryApi extends runtime.BaseAPI implements WorkflowMemory
     }
 
     /**
-     * Append a new memory chunk.  Exposed for external agents (e.g. self-hosted runners) that need to capture learnings without touching the DB directly. The new chunk\'s ``chunk_id`` is server-assigned. Each call snapshots a new DocumentVersion, just like edit/forget.
      * Append Workflow Memory Chunk Handler
      */
     async appendWorkflowMemoryChunkRaw(requestParameters: AppendWorkflowMemoryChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MemoryChunkResponse>> {
@@ -282,7 +286,6 @@ export class WorkflowMemoryApi extends runtime.BaseAPI implements WorkflowMemory
     }
 
     /**
-     * Append a new memory chunk.  Exposed for external agents (e.g. self-hosted runners) that need to capture learnings without touching the DB directly. The new chunk\'s ``chunk_id`` is server-assigned. Each call snapshots a new DocumentVersion, just like edit/forget.
      * Append Workflow Memory Chunk Handler
      */
     async appendWorkflowMemoryChunk(requestParameters: AppendWorkflowMemoryChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MemoryChunkResponse> {
@@ -483,6 +486,14 @@ export class WorkflowMemoryApi extends runtime.BaseAPI implements WorkflowMemory
 
         const queryParameters: any = {};
 
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (requestParameters['authorization'] != null) {
@@ -504,17 +515,17 @@ export class WorkflowMemoryApi extends runtime.BaseAPI implements WorkflowMemory
     /**
      * List Workflow Memory Chunks Handler
      */
-    async listWorkflowMemoryChunksRaw(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListMemoryChunksResponse>> {
+    async listWorkflowMemoryChunksRaw(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedResponseMemoryChunkResponse>> {
         const requestOptions = await this.listWorkflowMemoryChunksRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ListMemoryChunksResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedResponseMemoryChunkResponseFromJSON(jsonValue));
     }
 
     /**
      * List Workflow Memory Chunks Handler
      */
-    async listWorkflowMemoryChunks(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListMemoryChunksResponse> {
+    async listWorkflowMemoryChunks(requestParameters: ListWorkflowMemoryChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedResponseMemoryChunkResponse> {
         const response = await this.listWorkflowMemoryChunksRaw(requestParameters, initOverrides);
         return await response.value();
     }