@ideascol/agents-generator-sdk 0.6.1 → 0.7.2

package/dist/bin/cli.js

@@ -5,39 +5,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -598,7 +619,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-bb6ddeb47d40a0cdae440044ad1b8b6f517b01c8",
+    VERSION: "main-8acda2a920b73ea6f20e54f68ace024752e2d8ff",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -842,6 +863,106 @@ var init_request = __esm(() => {
   init_CancelablePromise();
 });
 
+// src/lib/clients/agents-generator/services/AdminAgentFoldersService.ts
+class AdminAgentFoldersService {
+  static createAgentFolder(requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agent-folders",
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentFolders(skip, limit = 100, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agent-folders",
+      query: {
+        skip,
+        limit,
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentFolder(folderId, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateAgentFolder(folderId, requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteAgentFolder(folderId, workspaceId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static assignAgentToFolder(agentId, requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agent-folders/assign/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AdminAgentFoldersService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/AdminAgentsService.ts
 class AdminAgentsService {
   static createAgent(requestBody, workspaceId) {
@@ -919,6 +1040,51 @@ class AdminAgentsService {
       }
     });
   }
+  static publishAgent(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/publish",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static discardDraft(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/discard-draft",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentDiff(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}/diff",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
   static getWorkspaceConversationsTotal(workspaceId) {
     return request(OpenAPI, {
       method: "GET",
@@ -1155,6 +1321,18 @@ class AdminConversationsService {
       }
     });
   }
+  static getResearchStatus(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/{conversation_id}/research-status",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
 }
 var init_AdminConversationsService = __esm(() => {
   init_OpenAPI();
@@ -1551,122 +1729,162 @@ var init_AdminMcpServersService = __esm(() => {
   init_request();
 });
 
-// src/lib/clients/agents-generator/services/AdminWorkspacesService.ts
-class AdminWorkspacesService {
-  static createWorkspace(requestBody) {
+// src/lib/clients/agents-generator/services/AdminTokenUsageService.ts
+class AdminTokenUsageService {
+  static getAgentTokenUsage(agentId, startDate, endDate, skip, limit = 100) {
     return request(OpenAPI, {
-      method: "POST",
-      url: "/workspaces",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/token-usage/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
+      },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static getWorkspaces(skip, limit = 100) {
+  static getAgentTokenUsageSummary(agentId, startDate, endDate) {
     return request(OpenAPI, {
       method: "GET",
-      url: "/workspaces",
+      url: "/token-usage/agents/{agent_id}/summary",
+      path: {
+        agent_id: agentId
+      },
       query: {
-        skip,
-        limit
+        start_date: startDate,
+        end_date: endDate
       },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static getDefaultWorkspace() {
+  static getConversationTokenUsage(conversationId, skip, limit = 100) {
     return request(OpenAPI, {
       method: "GET",
-      url: "/workspaces/default"
+      url: "/token-usage/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      query: {
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
     });
   }
-  static getWorkspace(workspaceId) {
+  static getConversationTokenUsageSummary(conversationId) {
     return request(OpenAPI, {
       method: "GET",
-      url: "/workspaces/{workspace_id}",
+      url: "/token-usage/conversations/{conversation_id}/summary",
       path: {
-        workspace_id: workspaceId
+        conversation_id: conversationId
       },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static updateWorkspace(workspaceId, requestBody) {
+  static getMyTokenUsage(workspaceId, startDate, endDate, skip, limit = 100) {
     return request(OpenAPI, {
-      method: "PUT",
-      url: "/workspaces/{workspace_id}",
-      path: {
-        workspace_id: workspaceId
+      method: "GET",
+      url: "/token-usage/users/me",
+      query: {
+        workspace_id: workspaceId,
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static deleteWorkspace(workspaceId) {
+  static getMyTokenUsageSummary(workspaceId, startDate, endDate) {
     return request(OpenAPI, {
-      method: "DELETE",
-      url: "/workspaces/{workspace_id}",
-      path: {
-        workspace_id: workspaceId
+      method: "GET",
+      url: "/token-usage/users/me/summary",
+      query: {
+        workspace_id: workspaceId,
+        start_date: startDate,
+        end_date: endDate
       },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static addWorkspaceCollaborator(workspaceId, requestBody) {
+  static getWorkspaceTokenUsage(workspaceId, startDate, endDate, skip, limit = 100) {
     return request(OpenAPI, {
-      method: "POST",
-      url: "/workspaces/{workspace_id}/collaborators",
+      method: "GET",
+      url: "/token-usage/workspaces/{workspace_id}",
       path: {
         workspace_id: workspaceId
       },
-      body: requestBody,
-      mediaType: "application/json",
+      query: {
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
+      },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static getWorkspaceCollaborators(workspaceId) {
+  static getWorkspaceTokenUsageSummary(workspaceId, startDate, endDate) {
     return request(OpenAPI, {
       method: "GET",
-      url: "/workspaces/{workspace_id}/collaborators",
+      url: "/token-usage/workspaces/{workspace_id}/summary",
       path: {
         workspace_id: workspaceId
       },
+      query: {
+        start_date: startDate,
+        end_date: endDate
+      },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static getWorkspaceCollaborator(workspaceId, collaboratorId) {
+}
+var init_AdminTokenUsageService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AdminWebhookConfigsService.ts
+class AdminWebhookConfigsService {
+  static createWebhookConfig(requestBody, workspaceId) {
     return request(OpenAPI, {
-      method: "GET",
-      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
-      path: {
-        workspace_id: workspaceId,
-        collaborator_id: collaboratorId
+      method: "POST",
+      url: "/webhook-configs",
+      query: {
+        workspace_id: workspaceId
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static updateWorkspaceCollaborator(workspaceId, collaboratorId, requestBody) {
+  static updateWebhookConfig(configId, requestBody) {
     return request(OpenAPI, {
       method: "PUT",
-      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
+      url: "/webhook-configs/{config_id}",
       path: {
-        workspace_id: workspaceId,
-        collaborator_id: collaboratorId
+        config_id: configId
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1675,40 +1893,30 @@ class AdminWorkspacesService {
       }
     });
   }
-  static deleteWorkspaceCollaborator(workspaceId, collaboratorId) {
+  static deleteWebhookConfig(configId) {
     return request(OpenAPI, {
       method: "DELETE",
-      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
+      url: "/webhook-configs/{config_id}",
       path: {
-        workspace_id: workspaceId,
-        collaborator_id: collaboratorId
+        config_id: configId
       },
       errors: {
         422: `Validation Error`
       }
     });
   }
-  static getMyCollaborativeWorkspaces() {
-    return request(OpenAPI, {
-      method: "GET",
-      url: "/workspaces/{workspace_id}/collaborators/me/workspaces"
-    });
-  }
 }
-var init_AdminWorkspacesService = __esm(() => {
+var init_AdminWebhookConfigsService = __esm(() => {
   init_OpenAPI();
   init_request();
 });
 
-// src/lib/clients/agents-generator/services/AgentService.ts
-class AgentService {
-  static createAgent(requestBody, workspaceId) {
+// src/lib/clients/agents-generator/services/AdminWorkspacesService.ts
+class AdminWorkspacesService {
+  static createWorkspace(requestBody) {
     return request(OpenAPI, {
       method: "POST",
-      url: "/agents",
-      query: {
-        workspace_id: workspaceId
-      },
+      url: "/workspaces",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1716,10 +1924,162 @@ class AgentService {
       }
     });
   }
-  static getAgents(skip, limit = 100, workspaceId) {
+  static getWorkspaces(skip, limit = 100) {
     return request(OpenAPI, {
       method: "GET",
-      url: "/agents",
+      url: "/workspaces",
+      query: {
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getDefaultWorkspace() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workspaces/default"
+    });
+  }
+  static getWorkspace(workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workspaces/{workspace_id}",
+      path: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateWorkspace(workspaceId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/workspaces/{workspace_id}",
+      path: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteWorkspace(workspaceId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/workspaces/{workspace_id}",
+      path: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static addWorkspaceCollaborator(workspaceId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/workspaces/{workspace_id}/collaborators",
+      path: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getWorkspaceCollaborators(workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workspaces/{workspace_id}/collaborators",
+      path: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getWorkspaceCollaborator(workspaceId, collaboratorId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
+      path: {
+        workspace_id: workspaceId,
+        collaborator_id: collaboratorId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateWorkspaceCollaborator(workspaceId, collaboratorId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
+      path: {
+        workspace_id: workspaceId,
+        collaborator_id: collaboratorId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteWorkspaceCollaborator(workspaceId, collaboratorId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/workspaces/{workspace_id}/collaborators/{collaborator_id}",
+      path: {
+        workspace_id: workspaceId,
+        collaborator_id: collaboratorId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getMyCollaborativeWorkspaces() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/workspaces/{workspace_id}/collaborators/me/workspaces"
+    });
+  }
+}
+var init_AdminWorkspacesService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/AgentService.ts
+class AgentService {
+  static createAgent(requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents",
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgents(skip, limit = 100, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents",
       query: {
         skip,
         limit,
@@ -1777,6 +2137,51 @@ class AgentService {
       }
     });
   }
+  static publishAgent(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/publish",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static discardDraft(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agents/{agent_id}/discard-draft",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentDiff(agentId, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agents/{agent_id}/diff",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
   static getWorkspaceConversationsTotal(workspaceId) {
     return request(OpenAPI, {
       method: "GET",
@@ -1871,6 +2276,106 @@ var init_AgentService = __esm(() => {
   init_request();
 });
 
+// src/lib/clients/agents-generator/services/AgentFoldersService.ts
+class AgentFoldersService {
+  static createAgentFolder(requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/agent-folders",
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentFolders(skip, limit = 100, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agent-folders",
+      query: {
+        skip,
+        limit,
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentFolder(folderId, workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateAgentFolder(folderId, requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteAgentFolder(folderId, workspaceId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/agent-folders/{folder_id}",
+      path: {
+        folder_id: folderId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static assignAgentToFolder(agentId, requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/agent-folders/assign/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_AgentFoldersService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/ConversationsService.ts
 class ConversationsService {
   static createConversation(requestBody) {
@@ -1938,7 +2443,7 @@ class ConversationsService {
       }
     });
   }
-  static addMessage(conversationId, requestBody, accept) {
+  static addMessage(conversationId, requestBody, useDraft = false, accept) {
     return request(OpenAPI, {
       method: "POST",
       url: "/conversations/{conversation_id}/messages",
@@ -1948,6 +2453,9 @@ class ConversationsService {
       headers: {
         accept
       },
+      query: {
+        use_draft: useDraft
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1957,6 +2465,18 @@ class ConversationsService {
       }
     });
   }
+  static getResearchStatus(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/{conversation_id}/research-status",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
 }
 var init_ConversationsService = __esm(() => {
   init_OpenAPI();
@@ -2495,7 +3015,7 @@ class PublicConversationsService {
       }
     });
   }
-  static addMessage(conversationId, requestBody, accept) {
+  static addMessage(conversationId, requestBody, useDraft = false, accept) {
     return request(OpenAPI, {
       method: "POST",
       url: "/conversations/{conversation_id}/messages",
@@ -2505,6 +3025,9 @@ class PublicConversationsService {
       headers: {
         accept
       },
+      query: {
+        use_draft: useDraft
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2514,6 +3037,18 @@ class PublicConversationsService {
       }
     });
   }
+  static getResearchStatus(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/conversations/{conversation_id}/research-status",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
 }
 var init_PublicConversationsService = __esm(() => {
   init_OpenAPI();
@@ -2559,6 +3094,246 @@ var init_SchemaGeneratorService = __esm(() => {
   init_request();
 });
 
+// src/lib/clients/agents-generator/services/TokenUsageService.ts
+class TokenUsageService {
+  static getAgentTokenUsage(agentId, startDate, endDate, skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/agents/{agent_id}",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getAgentTokenUsageSummary(agentId, startDate, endDate) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/agents/{agent_id}/summary",
+      path: {
+        agent_id: agentId
+      },
+      query: {
+        start_date: startDate,
+        end_date: endDate
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getConversationTokenUsage(conversationId, skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/conversations/{conversation_id}",
+      path: {
+        conversation_id: conversationId
+      },
+      query: {
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getConversationTokenUsageSummary(conversationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/conversations/{conversation_id}/summary",
+      path: {
+        conversation_id: conversationId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getMyTokenUsage(workspaceId, startDate, endDate, skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/users/me",
+      query: {
+        workspace_id: workspaceId,
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getMyTokenUsageSummary(workspaceId, startDate, endDate) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/users/me/summary",
+      query: {
+        workspace_id: workspaceId,
+        start_date: startDate,
+        end_date: endDate
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getWorkspaceTokenUsage(workspaceId, startDate, endDate, skip, limit = 100) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/workspaces/{workspace_id}",
+      path: {
+        workspace_id: workspaceId
+      },
+      query: {
+        start_date: startDate,
+        end_date: endDate,
+        skip,
+        limit
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getWorkspaceTokenUsageSummary(workspaceId, startDate, endDate) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/token-usage/workspaces/{workspace_id}/summary",
+      path: {
+        workspace_id: workspaceId
+      },
+      query: {
+        start_date: startDate,
+        end_date: endDate
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_TokenUsageService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/WebhookConfigsService.ts
+class WebhookConfigsService {
+  static createWebhookConfig(requestBody, workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/webhook-configs",
+      query: {
+        workspace_id: workspaceId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static listWebhookConfigs(workspaceId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/webhook-configs",
+      query: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static listWebhookEvents(workspaceId, limit = 50, offset) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/webhook-configs/events",
+      query: {
+        workspace_id: workspaceId,
+        limit,
+        offset
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static getWebhookConfig(configId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/webhook-configs/{config_id}",
+      path: {
+        config_id: configId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static updateWebhookConfig(configId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/webhook-configs/{config_id}",
+      path: {
+        config_id: configId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+  static deleteWebhookConfig(configId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/webhook-configs/{config_id}",
+      path: {
+        config_id: configId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_WebhookConfigsService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
+// src/lib/clients/agents-generator/services/WebhooksService.ts
+class WebhooksService {
+  static receiveOpenaiWebhookWebhooksOpenaiWorkspaceIdPost(workspaceId) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/webhooks/openai/{workspace_id}",
+      path: {
+        workspace_id: workspaceId
+      },
+      errors: {
+        422: `Validation Error`
+      }
+    });
+  }
+}
+var init_WebhooksService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/WorkspaceCollaboratorsService.ts
 class WorkspaceCollaboratorsService {
   static addWorkspaceCollaborator(workspaceId, requestBody) {
@@ -2722,14 +3497,18 @@ var init_agents_generator = __esm(() => {
   init_CancelablePromise();
   init_OpenAPI();
   init_CollaboratorRole();
+  init_AdminAgentFoldersService();
   init_AdminAgentsService();
   init_AdminApiKeysService();
   init_AdminConversationsService();
   init_AdminCredentialsService();
   init_AdminFileLibraryService();
   init_AdminMcpServersService();
+  init_AdminTokenUsageService();
+  init_AdminWebhookConfigsService();
   init_AdminWorkspacesService();
   init_AgentService();
+  init_AgentFoldersService();
   init_ConversationsService();
   init_CredentialsService();
   init_FileLibraryService();
@@ -2740,6 +3519,9 @@ var init_agents_generator = __esm(() => {
   init_PublicConversationsService();
   init_RootService();
   init_SchemaGeneratorService();
+  init_TokenUsageService();
+  init_WebhookConfigsService();
+  init_WebhooksService();
   init_WorkspaceCollaboratorsService();
   init_WorkspacesService();
 });
@@ -2785,7 +3567,8 @@ class AgentClient {
       collaborators: WorkspaceCollaboratorsService,
       apiKeys: AdminApiKeysService,
       presence: PresenceService,
-      schema: SchemaGeneratorService
+      schema: SchemaGeneratorService,
+      tokenUsage: TokenUsageService
     };
     this.public = {
       agents: PublicAgentsService,