@gpt-platform/client 0.8.2 → 0.8.4

package/dist/index.js

@@ -1333,7 +1333,7 @@ function buildUserAgent(sdkVersion, appInfo) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.8.2";
+var SDK_VERSION = "0.8.4";
 var DEFAULT_API_VERSION = "2026-03-11";
 
 // src/base-client.ts
@@ -1604,6 +1604,36 @@ var BaseClient = class {
   clearToken() {
     this.config = { ...this.config, token: void 0 };
   }
+  /**
+   * Switch the workspace context for all subsequent requests.
+   *
+   * Sets the `workspace_id` query parameter appended to every request.
+   * Use this after creating a new workspace or switching workspace context
+   * without constructing a new client instance.
+   *
+   * @param workspaceId - The workspace UUID to scope requests to, or
+   *   `undefined` to clear workspace scoping.
+   *
+   * @example
+   * ```typescript
+   * const org = await sdk.platform.tenants.createOrg({ name: 'Acme' });
+   * const workspaces = await sdk.platform.workspaces.mine();
+   * const ws = workspaces.find(w => w.tenant_id === org.id);
+   *
+   * sdk.setWorkspaceId(ws.id);
+   * // All subsequent calls are scoped to the new workspace
+   * await sdk.scheduling.events.create({ ... });
+   * ```
+   */
+  setWorkspaceId(workspaceId) {
+    this.config = { ...this.config, workspaceId };
+  }
+  /**
+   * Get the current workspace ID, if set.
+   */
+  getWorkspaceId() {
+    return this.config.workspaceId;
+  }
 };
 
 // src/namespaces/audit.ts
@@ -3882,6 +3912,11 @@ var postVoiceSessions = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getInvitations = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/invitations",
+  ...options
+});
 var postInvitations = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/invitations",
@@ -4637,6 +4672,15 @@ var getEmailInclusionsEmailByOutboundEmailId = (options) => (options.client ?? c
   url: "/email/inclusions/email/{outbound_email_id}",
   ...options
 });
+var patchTenantsByIdReactivate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/tenants/{id}/reactivate",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getWorkspacesByWorkspaceIdExtractionExportsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/workspaces/{workspace_id}/extraction/exports/{id}",
@@ -4739,6 +4783,15 @@ var postConnectorsFullscriptCheckPatient = (options) => (options.client ?? clien
     ...options.headers
   }
 });
+var patchTenantsByIdDeactivate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/tenants/{id}/deactivate",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var getSchedulingEventTypes = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/scheduling/event-types",
@@ -6057,11 +6110,6 @@ var patchBrandIdentitiesByIdUnsetDefault = (options) => (options.client ?? clien
     ...options.headers
   }
 });
-var deleteTenantsById = (options) => (options.client ?? client).delete({
-  security: [{ scheme: "bearer", type: "http" }],
-  url: "/tenants/{id}",
-  ...options
-});
 var getTenantsById = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/tenants/{id}",
@@ -6408,6 +6456,11 @@ var postWatcherEvents = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getAgentsBySlugBySlug = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/agents/by-slug/{slug}",
+  ...options
+});
 var getFeatureDefinitionsByApplicationByApplicationId = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/feature-definitions/by-application/{application_id}",
@@ -6913,6 +6966,15 @@ var postAgentsByIdExport = (options) => (options.client ?? client).post({
   url: "/agents/{id}/export",
   ...options
 });
+var postUsersAuthRegisterViaInvitation = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/users/auth/register-via-invitation",
+  ...options,
+  headers: {
+    "Content-Type": "application/vnd.api+json",
+    ...options.headers
+  }
+});
 var postEmailInboundAddresses = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/email/inbound-addresses",
@@ -7203,6 +7265,26 @@ function createAgentsNamespace(rb) {
     get: async (id, options) => {
       return rb.execute(getAgentsById, { path: { id } }, options);
     },
+    /**
+     * Look up an agent by its system_slug. Use this for ISV-provisioned agents
+     * where the slug is a stable identifier that survives database resets.
+     *
+     * @param slug - The system_slug of the agent (e.g., "chartless-session-prep-briefing").
+     * @param options - Optional request options.
+     * @returns The Agent record.
+     *
+     * @example
+     * ```ts
+     * const agent = await client.agents.getBySlug("chartless-session-prep-briefing");
+     * ```
+     */
+    getBySlug: async (slug, options) => {
+      return rb.execute(
+        getAgentsBySlugBySlug,
+        { path: { slug } },
+        options
+      );
+    },
     /**
      * Creates a new agent with a blank initial version (v1).
      *
@@ -10203,6 +10285,31 @@ function createBillingNamespace(rb) {
         );
         return result.data ?? result;
       }
+    },
+    /**
+     * Get capacity estimates for a plan's monthly credits.
+     *
+     * Returns how many of each ISV-defined feature the plan supports per month.
+     * No Bearer token required — uses application key only.
+     *
+     * @param planSlug - The plan slug to calculate capacity for.
+     * @param options - Optional request-level overrides.
+     * @returns Plan details and capacity breakdown per composite operation.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.billing.capacityCalculator("pro-plan");
+     * console.log(`Plan: ${result.plan.name}`);
+     * for (const item of result.capacity) {
+     *   console.log(`${item.display_name}: ~${item.estimated_monthly_count}/month`);
+     * }
+     * ```
+     */
+    capacityCalculator: async (planSlug, options) => {
+      return rb.rawGet(
+        `/billing/capacity-calculator?plan_slug=${encodeURIComponent(planSlug)}`,
+        options
+      );
     }
   };
 }
@@ -11978,6 +12085,46 @@ function createClinicalNamespace(rb) {
         getClinicalPracticeResourcesCatalog,
         { query: params ?? {} },
         options
+      ),
+      /**
+       * List distinct practice resource categories in a workspace.
+       *
+       * Returns unique `resource_type` values with their active resource counts,
+       * sorted by count descending.
+       *
+       * @param params - Must include `workspace_id`
+       * @param options - Request options
+       * @returns Array of {@link PracticeResourceCategory} records
+       *
+       * @example
+       * ```typescript
+       * const categories = await client.clinical.practiceResources.listCategories({
+       *   workspace_id: "..."
+       * });
+       * // [{ category: "article", resource_count: 5 }, { category: "video", resource_count: 3 }]
+       * ```
+       */
+      listCategories: async (params, options) => rb.rawGet(
+        `/clinical/practice-resources/categories?workspace_id=${encodeURIComponent(params.workspace_id)}`,
+        options
+      ),
+      /**
+       * List distinct catalog practice resource categories.
+       *
+       * Returns unique `resource_type` values from application-level catalog resources.
+       * Application ID is resolved from the API key context.
+       *
+       * @param options - Request options
+       * @returns Array of {@link PracticeResourceCategory} records
+       *
+       * @example
+       * ```typescript
+       * const cats = await client.clinical.practiceResources.listCatalogCategories();
+       * ```
+       */
+      listCatalogCategories: async (options) => rb.rawGet(
+        `/clinical/practice-resources/categories/catalog`,
+        options
       )
     },
     /**
@@ -12081,6 +12228,24 @@ function createClinicalNamespace(rb) {
         getClinicalPracticeToolsCatalog,
         { query: params ?? {} },
         options
+      ),
+      /**
+       * List distinct catalog practice tool categories.
+       *
+       * Returns unique `tool_type` values from application-level catalog tools.
+       * Application ID is resolved from the API key context.
+       *
+       * @param options - Request options
+       * @returns Array of {@link PracticeToolCategory} records
+       *
+       * @example
+       * ```typescript
+       * const cats = await client.clinical.practiceTools.listCatalogCategories();
+       * ```
+       */
+      listCatalogCategories: async (options) => rb.rawGet(
+        `/clinical/practice-tools/categories/catalog`,
+        options
       )
     },
     /**
@@ -12360,6 +12525,24 @@ function createClinicalNamespace(rb) {
         getClinicalGoalTemplatesCatalog,
         { query: params ?? {} },
         options
+      ),
+      /**
+       * List distinct catalog goal template categories.
+       *
+       * Returns unique `category` values from application-level catalog templates.
+       * Application ID is resolved from the API key context.
+       *
+       * @param options - Request options
+       * @returns Array of {@link ClinicalGoalTemplateCategory} records
+       *
+       * @example
+       * ```typescript
+       * const cats = await client.clinical.goalTemplates.listCatalogCategories();
+       * ```
+       */
+      listCatalogCategories: async (options) => rb.rawGet(
+        `/clinical/goal-templates/categories/catalog`,
+        options
       )
     },
     /**
@@ -22283,6 +22466,15 @@ var ChangePasswordSchema = import_zod2.z.object({
   message: "Passwords do not match",
   path: ["password_confirmation"]
 });
+var RegisterViaInvitationSchema = import_zod2.z.object({
+  email: import_zod2.z.string().email(),
+  password: import_zod2.z.string().min(8),
+  password_confirmation: import_zod2.z.string().min(8),
+  invitation_token: import_zod2.z.string().min(1)
+}).refine((data) => data.password === data.password_confirmation, {
+  message: "Passwords do not match",
+  path: ["password_confirmation"]
+});
 function createIdentityNamespace(rb, baseUrl) {
   return {
     /**
@@ -22371,6 +22563,57 @@ function createIdentityNamespace(rb, baseUrl) {
         options
       );
     },
+    /**
+     * Register a new user via invitation — skips personal tenant creation.
+     *
+     * Creates the user account, accepts the invitation (creating tenant/workspace
+     * memberships), and returns the authenticated user with a session token.
+     * The email must match the invitation's recipient email.
+     *
+     * @param email - Must match the invitation recipient email
+     * @param password - Minimum 8 characters
+     * @param passwordConfirmation - Must match password
+     * @param invitationToken - Raw token from the invitation email link
+     * @param attrs - Optional extra attributes (first_name, last_name)
+     * @param options - Optional request options
+     * @returns The newly created `User` with session token
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const user = await client.identity.registerViaInvitation(
+     *   'invited@example.com', 'securepass', 'securepass', 'raw-token-from-email',
+     *   { first_name: 'Jane', last_name: 'Doe' },
+     * );
+     * console.log(user.token); // JWT session token
+     * ```
+     */
+    registerViaInvitation: async (email, password, passwordConfirmation, invitationToken, attrs, options) => {
+      RegisterViaInvitationSchema.parse({
+        email,
+        password,
+        password_confirmation: passwordConfirmation,
+        invitation_token: invitationToken
+      });
+      return rb.execute(
+        postUsersAuthRegisterViaInvitation,
+        {
+          body: {
+            data: {
+              type: "user",
+              attributes: {
+                email,
+                password,
+                password_confirmation: passwordConfirmation,
+                invitation_token: invitationToken,
+                ...attrs
+              }
+            }
+          }
+        },
+        options
+      );
+    },
     /** Get the currently authenticated user */
     me: async (options) => {
       return rb.execute(getUsersMe, {}, options);
@@ -23521,26 +23764,56 @@ function createPlatformNamespace(rb) {
         );
       },
       /**
-       * Delete a tenant and all associated data.
+       * Deactivate a tenant (hide from user's account).
        *
-       * Permanently removes the tenant, all their workspaces, documents, and
-       * billing records. This operation is irreversible. For a graceful
-       * off-boarding, prefer `schedulePurge` which allows data export before
-       * deletion.
+       * Sets `deactivated_at` on the tenant. The tenant and its workspaces
+       * disappear from `workspaces.mine()` and tenant listings. Billing and
+       * data are completely unaffected. Reversible via `reactivate()`.
        *
-       * @param id - The UUID of the tenant to delete.
+       * Only the tenant owner can deactivate.
+       *
+       * @param id - The UUID of the tenant to deactivate.
        * @param options - Optional request options.
-       * @returns `true` on successful deletion.
+       * @returns The updated tenant record.
        *
        * @example
        * ```typescript
-       * const client = new GptClient({ apiKey: 'sk_app_...' });
-       * await client.platform.tenants.delete('tenant_abc123');
+       * await client.platform.tenants.deactivate('tenant_abc123');
        * ```
        */
-      delete: async (id, options) => {
-        return rb.executeDelete(deleteTenantsById, { path: { id } }, options);
-      },
+      deactivate: async (id, options) => rb.execute(
+        patchTenantsByIdDeactivate,
+        {
+          path: { id },
+          body: { data: { type: "tenant", id, attributes: {} } }
+        },
+        options
+      ),
+      /**
+       * Reactivate a previously deactivated tenant.
+       *
+       * Clears `deactivated_at`, restoring the tenant and its workspaces
+       * to the user's account. Only works on deactivated tenants.
+       *
+       * Only the tenant owner can reactivate.
+       *
+       * @param id - The UUID of the tenant to reactivate.
+       * @param options - Optional request options.
+       * @returns The updated tenant record.
+       *
+       * @example
+       * ```typescript
+       * await client.platform.tenants.reactivate('tenant_abc123');
+       * ```
+       */
+      reactivate: async (id, options) => rb.execute(
+        patchTenantsByIdReactivate,
+        {
+          path: { id },
+          body: { data: { type: "tenant", id, attributes: {} } }
+        },
+        options
+      ),
       /**
        * Create a new tenant (ISV provisioning flow).
        *
@@ -23911,6 +24184,52 @@ function createPlatformNamespace(rb) {
           options
         );
       },
+      /**
+       * List invitations visible to the current actor.
+       *
+       * Returns invitations where the actor is the inviter, the tenant owner,
+       * or the recipient (matched by email). Use this to build admin views
+       * of pending/accepted invitations for a tenant or workspace.
+       *
+       * @param options - Optional page number, page size, and request options.
+       * @returns A page of `Invitation` records.
+       *
+       * @example
+       * ```typescript
+       * const client = new GptClient({ apiKey: 'sk_app_...' });
+       * const invites = await client.platform.invitations.list();
+       * ```
+       */
+      list: async (options) => {
+        return rb.execute(
+          getInvitations,
+          buildPageQuery(options?.page, options?.pageSize),
+          options
+        );
+      },
+      /**
+       * List all invitations visible to the current actor, auto-paginating.
+       *
+       * @param options - Optional request options.
+       * @returns All visible `Invitation` records as a flat array.
+       *
+       * @example
+       * ```typescript
+       * const client = new GptClient({ apiKey: 'sk_app_...' });
+       * const all = await client.platform.invitations.listAll();
+       * ```
+       */
+      listAll: async (options) => {
+        return paginateToArray(
+          rb.createPaginatedFetcher(
+            getInvitations,
+            (page, pageSize) => ({
+              query: { page: { number: page, size: pageSize } }
+            }),
+            options
+          )
+        );
+      },
       /**
        * Look up a pending invitation by its raw token.
        *