@meetkai/mka1 0.54.92 → 0.54.94

package/src/sdk/agents.ts

@@ -3,16 +3,98 @@
  */
 
 import { agentsCreateAgent } from "../funcs/agentsCreateAgent.js";
+import { agentsCreateFunctionTool } from "../funcs/agentsCreateFunctionTool.js";
 import { agentsDeleteAgent } from "../funcs/agentsDeleteAgent.js";
+import { agentsDeleteFunctionTool } from "../funcs/agentsDeleteFunctionTool.js";
 import { agentsGetAgent } from "../funcs/agentsGetAgent.js";
+import { agentsGetFunctionTool } from "../funcs/agentsGetFunctionTool.js";
 import { agentsListAgents } from "../funcs/agentsListAgents.js";
+import { agentsListFunctionTools } from "../funcs/agentsListFunctionTools.js";
+import { agentsRestoreAgent } from "../funcs/agentsRestoreAgent.js";
 import { agentsUpdateAgent } from "../funcs/agentsUpdateAgent.js";
+import { agentsUpdateFunctionTool } from "../funcs/agentsUpdateFunctionTool.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class Agents extends ClientSDK {
+  /**
+   * List reusable function tools
+   */
+  async listFunctionTools(
+    request: operations.ListFunctionToolsRequest,
+    options?: RequestOptions,
+  ): Promise<components.FunctionToolList> {
+    return unwrapAsync(agentsListFunctionTools(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a reusable function tool
+   */
+  async createFunctionTool(
+    request: operations.CreateFunctionToolRequest,
+    options?: RequestOptions,
+  ): Promise<components.FunctionTool> {
+    return unwrapAsync(agentsCreateFunctionTool(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a reusable function tool
+   */
+  async getFunctionTool(
+    request: operations.GetFunctionToolRequest,
+    options?: RequestOptions,
+  ): Promise<components.FunctionTool> {
+    return unwrapAsync(agentsGetFunctionTool(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Replace a reusable function definition
+   *
+   * @remarks
+   * Updates apply to every attached agent on its next run. Existing run snapshots are immutable.
+   */
+  async updateFunctionTool(
+    request: operations.UpdateFunctionToolRequest,
+    options?: RequestOptions,
+  ): Promise<components.FunctionTool> {
+    return unwrapAsync(agentsUpdateFunctionTool(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a reusable function tool
+   *
+   * @remarks
+   * Attached agents fail until the unavailable reference is removed. Existing run snapshots remain usable.
+   */
+  async deleteFunctionTool(
+    request: operations.DeleteFunctionToolRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteFunctionToolResponseBody> {
+    return unwrapAsync(agentsDeleteFunctionTool(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * List agents
    */
@@ -70,7 +152,10 @@ export class Agents extends ClientSDK {
   }
 
   /**
-   * Delete an agent
+   * Soft-delete an agent
+   *
+   * @remarks
+   * Preserves configuration versions and run history for audit. The restore deadline is pinned using AGENT_RETENTION_DAYS at deletion.
    */
   async deleteAgent(
     request: operations.DeleteAgentRequest,
@@ -82,4 +167,21 @@ export class Agents extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Restore a soft-deleted agent
+   *
+   * @remarks
+   * Restores the original configuration and history before retention_expires_at. Requires write:agents in the original mutation tenancy. Schedules remain paused.
+   */
+  async restoreAgent(
+    request: operations.RestoreAgentRequest,
+    options?: RequestOptions,
+  ): Promise<components.Agent> {
+    return unwrapAsync(agentsRestoreAgent(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/auth.ts

@@ -11,6 +11,11 @@ import { ServiceAccounts } from "./serviceaccounts.js";
 import { Teams } from "./teams.js";
 
 export class Auth extends ClientSDK {
+  private _orgs?: Orgs;
+  get orgs(): Orgs {
+    return (this._orgs ??= new Orgs(this._options));
+  }
+
   private _teams?: Teams;
   get teams(): Teams {
     return (this._teams ??= new Teams(this._options));
@@ -26,11 +31,6 @@ export class Auth extends ClientSDK {
     return (this._serviceAccounts ??= new ServiceAccounts(this._options));
   }
 
-  private _orgs?: Orgs;
-  get orgs(): Orgs {
-    return (this._orgs ??= new Orgs(this._options));
-  }
-
   private _cluster?: Cluster;
   get cluster(): Cluster {
     return (this._cluster ??= new Cluster(this._options));

package/src/sdk/orgs.ts

@@ -5,15 +5,55 @@
 import { authOrgsGetById } from "../funcs/authOrgsGetById.js";
 import { authOrgsGetQuota } from "../funcs/authOrgsGetQuota.js";
 import { authOrgsGetRateLimit } from "../funcs/authOrgsGetRateLimit.js";
+import { authOrgsGetSsoPolicy } from "../funcs/authOrgsGetSsoPolicy.js";
 import { authOrgsUpdate } from "../funcs/authOrgsUpdate.js";
 import { authOrgsUpdateQuota } from "../funcs/authOrgsUpdateQuota.js";
 import { authOrgsUpdateRateLimit } from "../funcs/authOrgsUpdateRateLimit.js";
+import { authOrgsUpdateSsoPolicy } from "../funcs/authOrgsUpdateSsoPolicy.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class Orgs extends ClientSDK {
+  /**
+   * Read enterprise SSO role mapping policy
+   *
+   * @remarks
+   * Requires a live human browser session and current owner/admin membership in the connection's active customer organization. API keys are not accepted.
+   */
+  async getSsoPolicy(
+    security: operations.GetSsoPolicySecurity,
+    request: operations.GetSsoPolicyRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetSsoPolicyResponseBody> {
+    return unwrapAsync(authOrgsGetSsoPolicy(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update enterprise SSO role mapping policy
+   *
+   * @remarks
+   * Requires a live human browser session and current owner/admin membership. Enabling a connection requires verified domain ownership. Exact IdP group mappings grant member or admin on subsequent SSO logins; owners are preserved.
+   */
+  async updateSsoPolicy(
+    security: operations.UpdateSsoPolicySecurity,
+    request: operations.UpdateSsoPolicyRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateSsoPolicyResponseBody> {
+    return unwrapAsync(authOrgsUpdateSsoPolicy(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Get basic organization details
    *