@gpt-platform/admin 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1504,58 +1504,12 @@ var postAdminWebhookDeliveriesByIdRetry = (options) => (options.client ?? client
   }
 });
 
-// src/schemas/requests.ts
-import { z } from "zod";
-var StorageStatsRequestSchema = z.object({
-  workspace_id: z.string().optional()
-});
-var WebhookConfigCreateSchema = z.object({
-  url: z.string().url(),
-  events: z.array(z.string()).min(1),
-  secret: z.string().optional(),
-  enabled: z.boolean().default(true)
-});
-var WebhookBulkEnableSchema = z.object({
-  config_ids: z.array(z.string()).min(1).max(100)
-});
-var WebhookBulkDisableSchema = z.object({
-  config_ids: z.array(z.string()).min(1).max(100)
-});
-var WebhookDeliveryBulkRetrySchema = z.object({
-  delivery_ids: z.array(z.string()).min(1).max(100)
-});
-var AgentAdminCreateSchema = z.object({
-  name: z.string().min(1).max(255),
-  prompt_template: z.string().min(1),
-  system_wide: z.boolean().default(false)
-});
-var AccountCreditSchema = z.object({
-  amount: z.number().positive(),
-  description: z.string().optional()
-});
-var AccountDebitSchema = z.object({
-  amount: z.number().positive(),
-  description: z.string().optional()
-});
-var ApiKeyAllocateSchema = z.object({
-  rate_limit: z.number().int().positive().optional(),
-  expires_at: z.string().datetime().optional()
-});
-var DocumentBulkDeleteSchema = z.object({
-  document_ids: z.array(z.string()).min(1).max(100)
-});
-var DocumentBulkReprocessSchema = z.object({
-  document_ids: z.array(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,
@@ -1563,37 +1517,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
@@ -1605,47 +1553,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
       );
     }
@@ -1655,7 +1591,6 @@ function createApiKeysNamespace(rb) {
 // src/namespaces/documents.ts
 function createDocumentsNamespace(rb) {
   return {
-    /** List extraction documents */
     list: async (options) => {
       return rb.execute(
         getAdminExtractionDocuments,
@@ -1663,7 +1598,6 @@ function createDocumentsNamespace(rb) {
         options
       );
     },
-    /** Get a document by ID */
     get: async (id, options) => {
       return rb.execute(
         getAdminExtractionDocumentsById,
@@ -1671,181 +1605,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,
@@ -1853,7 +1655,6 @@ function createStorageNamespace(rb) {
           options
         );
       },
-      /** Get bucket statistics */
       stats: async (id, options) => {
         return rb.execute(
           getAdminBucketsByIdStats,
@@ -1861,7 +1662,6 @@ function createStorageNamespace(rb) {
           options
         );
       },
-      /** List objects in a bucket */
       objects: async (id, options) => {
         return rb.execute(
           getAdminBucketsByIdObjects,
@@ -1877,12 +1677,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,
           {
@@ -1894,8 +1692,7 @@ function createWebhooksNamespace(rb) {
                   url,
                   events,
                   application_id: applicationId,
-                  secret,
-                  enabled
+                  secret
                 }
               }
             }
@@ -1903,7 +1700,6 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Get a webhook config by ID */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookConfigsById,
@@ -1911,24 +1707,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,
@@ -1936,17 +1724,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,
@@ -1954,7 +1740,6 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Get a webhook delivery by ID */
       get: async (id, options) => {
         return rb.execute(
           getAdminWebhookDeliveriesById,
@@ -1962,11 +1747,10 @@ function createWebhooksNamespace(rb) {
           options
         );
       },
-      /** Retry a webhook delivery */
       retry: async (id, options) => {
         return rb.execute(
           postAdminWebhookDeliveriesByIdRetry,
-          { path: { id } },
+          { path: { id }, body: {} },
           options
         );
       }
@@ -1996,28 +1780,17 @@ var GptAdmin = class extends BaseClient {
 // src/index.ts
 var index_default = GptAdmin;
 export {
-  AccountCreditSchema,
-  AccountDebitSchema,
-  AgentAdminCreateSchema,
-  ApiKeyAllocateSchema,
   AuthenticationError,
   AuthorizationError,
   DEFAULT_API_VERSION,
-  DocumentBulkDeleteSchema,
-  DocumentBulkReprocessSchema,
   GptAdmin,
   GptCoreError,
   NetworkError,
   NotFoundError,
   RateLimitError,
   ServerError,
-  StorageStatsRequestSchema,
   TimeoutError,
   ValidationError,
-  WebhookBulkDisableSchema,
-  WebhookBulkEnableSchema,
-  WebhookConfigCreateSchema,
-  WebhookDeliveryBulkRetrySchema,
   index_default as default,
   handleApiError
 };