@gpt-platform/admin 0.1.2 → 0.1.4

package/dist/index.js

@@ -20,28 +20,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AccountCreditSchema: () => AccountCreditSchema,
-  AccountDebitSchema: () => AccountDebitSchema,
-  AgentAdminCreateSchema: () => AgentAdminCreateSchema,
-  ApiKeyAllocateSchema: () => ApiKeyAllocateSchema,
   AuthenticationError: () => AuthenticationError,
   AuthorizationError: () => AuthorizationError,
   DEFAULT_API_VERSION: () => DEFAULT_API_VERSION,
-  DocumentBulkDeleteSchema: () => DocumentBulkDeleteSchema,
-  DocumentBulkReprocessSchema: () => DocumentBulkReprocessSchema,
   GptAdmin: () => GptAdmin,
   GptCoreError: () => GptCoreError,
   NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
   RateLimitError: () => RateLimitError,
   ServerError: () => ServerError,
-  StorageStatsRequestSchema: () => StorageStatsRequestSchema,
   TimeoutError: () => TimeoutError,
   ValidationError: () => ValidationError,
-  WebhookBulkDisableSchema: () => WebhookBulkDisableSchema,
-  WebhookBulkEnableSchema: () => WebhookBulkEnableSchema,
-  WebhookConfigCreateSchema: () => WebhookConfigCreateSchema,
-  WebhookDeliveryBulkRetrySchema: () => WebhookDeliveryBulkRetrySchema,
   default: () => index_default,
   handleApiError: () => handleApiError
 });
@@ -1553,58 +1542,12 @@ var postAdminWebhookDeliveriesByIdRetry = (options) => (options.client ?? client
   }
 });
 
-// src/schemas/requests.ts
-var import_zod = require("zod");
-var StorageStatsRequestSchema = import_zod.z.object({
-  workspace_id: import_zod.z.string().optional()
-});
-var WebhookConfigCreateSchema = import_zod.z.object({
-  url: import_zod.z.string().url(),
-  events: import_zod.z.array(import_zod.z.string()).min(1),
-  secret: import_zod.z.string().optional(),
-  enabled: import_zod.z.boolean().default(true)
-});
-var WebhookBulkEnableSchema = import_zod.z.object({
-  config_ids: import_zod.z.array(import_zod.z.string()).min(1).max(100)
-});
-var WebhookBulkDisableSchema = import_zod.z.object({
-  config_ids: import_zod.z.array(import_zod.z.string()).min(1).max(100)
-});
-var WebhookDeliveryBulkRetrySchema = import_zod.z.object({
-  delivery_ids: import_zod.z.array(import_zod.z.string()).min(1).max(100)
-});
-var AgentAdminCreateSchema = import_zod.z.object({
-  name: import_zod.z.string().min(1).max(255),
-  prompt_template: import_zod.z.string().min(1),
-  system_wide: import_zod.z.boolean().default(false)
-});
-var AccountCreditSchema = import_zod.z.object({
-  amount: import_zod.z.number().positive(),
-  description: import_zod.z.string().optional()
-});
-var AccountDebitSchema = import_zod.z.object({
-  amount: import_zod.z.number().positive(),
-  description: import_zod.z.string().optional()
-});
-var ApiKeyAllocateSchema = import_zod.z.object({
-  rate_limit: import_zod.z.number().int().positive().optional(),
-  expires_at: import_zod.z.string().datetime().optional()
-});
-var DocumentBulkDeleteSchema = import_zod.z.object({
-  document_ids: import_zod.z.array(import_zod.z.string()).min(1).max(100)
-});
-var DocumentBulkReprocessSchema = import_zod.z.object({
-  document_ids: import_zod.z.array(import_zod.z.string()).min(1).max(100)
-});
-
 // src/namespaces/accounts.ts
 function createAccountsNamespace(rb) {
   return {
-    /** List all billing accounts */
     list: async (options) => {
       return rb.execute(getAdminAccounts, {}, options);
     },
-    /** Get a billing account by ID */
     get: async (id, options) => {
       return rb.execute(
         getAdminAccountsById,
@@ -1612,37 +1555,31 @@ function createAccountsNamespace(rb) {
         options
       );
     },
-    /** Credit an account */
     credit: async (id, amount, description, options) => {
-      const validated = AccountCreditSchema.parse({ amount, description });
+      if (amount <= 0) {
+        throw new Error("Credit amount must be positive");
+      }
       return rb.execute(
         patchAdminAccountsByIdCredit,
         {
           path: { id },
           body: {
-            data: {
-              id,
-              type: "account",
-              attributes: validated
-            }
+            data: { type: "account", attributes: { amount, description } }
           }
         },
         options
       );
     },
-    /** Debit an account */
     debit: async (id, amount, description, options) => {
-      const validated = AccountDebitSchema.parse({ amount, description });
+      if (amount <= 0) {
+        throw new Error("Debit amount must be positive");
+      }
       return rb.execute(
         patchAdminAccountsByIdDebit,
         {
           path: { id },
           body: {
-            data: {
-              id,
-              type: "account",
-              attributes: validated
-            }
+            data: { type: "account", attributes: { amount, description } }
           }
         },
         options
@@ -1654,47 +1591,35 @@ function createAccountsNamespace(rb) {
 // src/namespaces/apiKeys.ts
 function createApiKeysNamespace(rb) {
   return {
-    /** List all API keys */
     list: async (options) => {
       return rb.execute(getAdminApiKeys, {}, options);
     },
-    /** Get an API key by ID */
     get: async (id, options) => {
       return rb.execute(getAdminApiKeysById, { path: { id } }, options);
     },
-    /** Allocate credits to an API key */
     allocate: async (id, amount, description, options) => {
       return rb.execute(
         patchAdminApiKeysByIdAllocate,
         {
           path: { id },
           body: {
-            data: {
-              id,
-              type: "api_key",
-              attributes: {
-                amount,
-                description
-              }
-            }
+            data: { type: "api_key", attributes: { amount, description } }
           }
         },
         options
       );
     },
-    /** Revoke an API key */
     revoke: async (id, options) => {
       return rb.execute(
         patchAdminApiKeysByIdRevoke,
-        { path: { id } },
+        { path: { id }, body: {} },
         options
       );
     },
-    /** Rotate an API key */
     rotate: async (id, options) => {
       return rb.execute(
         patchAdminApiKeysByIdRotate,
-        { path: { id } },
+        { path: { id }, body: {} },
         options
       );
     }
@@ -1704,7 +1629,6 @@ function createApiKeysNamespace(rb) {
 // src/namespaces/documents.ts
 function createDocumentsNamespace(rb) {
   return {
-    /** List extraction documents */
     list: async (options) => {
       return rb.execute(
         getAdminExtractionDocuments,
@@ -1712,7 +1636,6 @@ function createDocumentsNamespace(rb) {
         options
       );
     },
-    /** Get a document by ID */
     get: async (id, options) => {
       return rb.execute(
         getAdminExtractionDocumentsById,
@@ -1720,181 +1643,49 @@ function createDocumentsNamespace(rb) {
         options
       );
     },
-    /** Get document statistics */
-    stats: async (options) => {
-      return rb.execute(getAdminDocumentsStats, {}, options);
-    },
-    /** Bulk delete documents */
-    bulkDelete: async (documentIds, options) => {
-      const validated = DocumentBulkDeleteSchema.parse({
-        document_ids: documentIds
-      });
+    bulkDelete: async (ids, options) => {
+      if (ids.length === 0) {
+        throw new Error("At least one document ID is required");
+      }
+      if (ids.length > 100) {
+        throw new Error("Maximum 100 documents per bulk operation");
+      }
       return rb.execute(
         postAdminDocumentsBulkDelete,
-        {
-          body: {
-            data: {
-              type: "operation_success",
-              attributes: {
-                ids: validated.document_ids
-              }
-            }
-          }
-        },
-        options
-      );
-    }
-  };
-}
-
-// src/namespaces/_executions-streaming.ts
-function addExecutionStreaming(executions, getHeaders) {
-  executions.stream = async (executionId, options) => {
-    const headers = {
-      ...getHeaders(),
-      Accept: "text/event-stream"
-    };
-    const result = await client.get({
-      url: `/isv/agent-executions/${executionId}/stream`,
-      headers,
-      parseAs: "stream",
-      ...options?.signal && { signal: options.signal }
-    });
-    const envelope = result;
-    const streamBody = envelope.data ?? result;
-    const response = envelope.response;
-    if (response && !response.ok) {
-      throw new ServerError(`Stream request failed: ${response.status}`, {
-        statusCode: response.status
-      });
-    }
-    if (streamBody instanceof ReadableStream) {
-      const syntheticResponse = new Response(streamBody, {
-        headers: { "Content-Type": "text/event-stream" }
-      });
-      return streamMessage(syntheticResponse, {
-        signal: options?.signal,
-        ...options
-      });
-    }
-    if (streamBody instanceof Response) {
-      if (!streamBody.ok) {
-        throw new ServerError(`Stream request failed: ${streamBody.status}`, {
-          statusCode: streamBody.status
-        });
-      }
-      return streamMessage(streamBody, {
-        signal: options?.signal,
-        ...options
-      });
-    }
-    throw new GptCoreError("Unexpected stream response format", {
-      code: "stream_error"
-    });
-  };
-}
-
-// src/namespaces/executions.ts
-function createExecutionsNamespace(rb) {
-  const executions = {
-    /** Start a new agent execution */
-    start: async (agentId, params, options) => {
-      return rb.rawPost(
-        `/isv/agents/${agentId}/execute`,
-        params,
-        options
-      );
-    },
-    /** Get execution status and details */
-    get: async (executionId, options) => {
-      return rb.rawGet(
-        `/isv/agent-executions/${executionId}`,
-        options
-      );
-    },
-    /** List executions for a workspace */
-    list: async (filters, options) => {
-      const query = filters?.status ? `?status=${filters.status}` : "";
-      return rb.rawGet(
-        `/isv/agent-executions${query}`,
-        options
-      );
-    },
-    /** Cancel a running execution */
-    cancel: async (executionId, options) => {
-      return rb.rawPost(
-        `/isv/agent-executions/${executionId}/cancel`,
-        void 0,
+        { body: { data: { type: "bulk_delete", attributes: { ids } } } },
         options
       );
     },
-    /** Approve a pending tool call */
-    approve: async (executionId, options) => {
-      return rb.rawPost(
-        `/isv/agent-executions/${executionId}/approve`,
-        void 0,
-        options
-      );
-    },
-    /** Deny a pending tool call */
-    deny: async (executionId, reason, options) => {
-      return rb.rawPost(
-        `/isv/agent-executions/${executionId}/deny`,
-        reason ? { reason } : void 0,
-        options
-      );
-    },
-    /** Estimate cost for executing an agent */
-    estimate: async (agentId, params, options) => {
-      return rb.rawPost(
-        `/isv/agents/${agentId}/estimate`,
-        params,
-        options
-      );
-    },
-    /** Get child executions of a parent execution */
-    getChildren: async (executionId, options) => {
-      return rb.rawGet(
-        `/isv/agent-executions/${executionId}/children`,
-        options
-      );
-    },
-    /** Get the execution tree rooted at a given execution */
-    getTree: async (executionId, options) => {
-      return rb.rawGet(
-        `/isv/agent-executions/${executionId}/tree`,
+    stats: async (options) => {
+      return rb.execute(
+        getAdminDocumentsStats,
+        {},
         options
       );
     }
   };
-  addExecutionStreaming(
-    executions,
-    () => rb.getRequestHeaders()
-  );
-  return executions;
+}
+
+// src/namespaces/executions.ts
+function createExecutionsNamespace(_rb) {
+  return {};
 }
 
 // src/namespaces/storage.ts
 function createStorageNamespace(rb) {
   return {
-    /** Get storage statistics */
     stats: async (workspaceId, options) => {
-      const validated = StorageStatsRequestSchema.parse({
-        workspace_id: workspaceId
-      });
+      const params = workspaceId ? { query: { "filter[workspace_id]": workspaceId } } : {};
       return rb.execute(
         getAdminStorageStats,
-        validated.workspace_id ? { query: { filter: { workspace_id: validated.workspace_id } } } : {},
+        params,
         options
       );
     },
-    /** Bucket management */
     buckets: {
-      /** List all buckets */
       list: async (options) => {
         return rb.execute(getAdminBuckets, {}, options);
       },
-      /** Get a bucket by ID */
       get: async (id, options) => {
         return rb.execute(
           getAdminBucketsById,
@@ -1902,7 +1693,6 @@ function createStorageNamespace(rb) {
           options
         );
       },
-      /** Get bucket statistics */
       stats: async (id, options) => {
         return rb.execute(
           getAdminBucketsByIdStats,
@@ -1910,7 +1700,6 @@ function createStorageNamespace(rb) {
           options
         );
       },
-      /** List objects in a bucket */
       objects: async (id, options) => {
         return rb.execute(
           getAdminBucketsByIdObjects,
@@ -1926,12 +1715,10 @@ function createStorageNamespace(rb) {
 function createWebhooksNamespace(rb) {
   return {
     configs: {
-      /** List all webhook configs */
       list: async (options) => {
         return rb.execute(getAdminWebhookConfigs, {}, options);
       },
-      /** Create a webhook config */
-      create: async (name, url, events, applicationId, secret, enabled = true, options) => {
+      create: async (name, url, events, applicationId, secret, options) => {
         return rb.execute(
           postAdminWebhookConfigs,
           {
@@ -1943,8 +1730,7 @@ function createWebhooksNamespace(rb) {
                   url,
                   events,
                   application_id: applicationId,
-                  secret,
-                  enabled
+                  secret
                 }
               }
             }
@@ -1952,7 +1738,6 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Get a webhook config by ID */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookConfigsById,
@@ -1960,24 +1745,16 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Update a webhook config */
-      update: async (id, updates, options) => {
+      update: async (id, attributes, options) => {
         return rb.execute(
           patchAdminWebhookConfigsById,
           {
             path: { id },
-            body: {
-              data: {
-                id,
-                type: "webhook_config",
-                attributes: updates
-              }
-            }
+            body: { data: { id, type: "webhook_config", attributes } }
           },
           options
         );
       },
-      /** Delete a webhook config */
       delete: async (id, options) => {
         return rb.executeDelete(
           deleteAdminWebhookConfigsById,
@@ -1985,17 +1762,15 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Test a webhook config */
       test: async (id, options) => {
         return rb.execute(
           postAdminWebhookConfigsByIdTest,
-          { path: { id } },
+          { path: { id }, body: {} },
           options
         );
       }
     },
     deliveries: {
-      /** List webhook deliveries */
       list: async (options) => {
         return rb.execute(
           getAdminWebhookDeliveries,
@@ -2003,7 +1778,6 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Get a webhook delivery by ID */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookDeliveriesById,
@@ -2011,11 +1785,10 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Retry a webhook delivery */
       retry: async (id, options) => {
         return rb.execute(
           postAdminWebhookDeliveriesByIdRetry,
-          { path: { id } },
+          { path: { id }, body: {} },
           options
         );
       }
@@ -2046,28 +1819,17 @@ var GptAdmin = class extends BaseClient {
 var index_default = GptAdmin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AccountCreditSchema,
-  AccountDebitSchema,
-  AgentAdminCreateSchema,
-  ApiKeyAllocateSchema,
   AuthenticationError,
   AuthorizationError,
   DEFAULT_API_VERSION,
-  DocumentBulkDeleteSchema,
-  DocumentBulkReprocessSchema,
   GptAdmin,
   GptCoreError,
   NetworkError,
   NotFoundError,
   RateLimitError,
   ServerError,
-  StorageStatsRequestSchema,
   TimeoutError,
   ValidationError,
-  WebhookBulkDisableSchema,
-  WebhookBulkEnableSchema,
-  WebhookConfigCreateSchema,
-  WebhookDeliveryBulkRetrySchema,
   handleApiError
 });
 //# sourceMappingURL=index.js.map