@meetkai/mka1 0.55.27 → 0.55.30

package/src/models/operations/listorgbudgetenforcements.ts

@@ -0,0 +1,214 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const ListOrgBudgetEnforcementsOnCheckFailure = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+export type ListOrgBudgetEnforcementsOnCheckFailure = ClosedEnum<
+  typeof ListOrgBudgetEnforcementsOnCheckFailure
+>;
+
+export const ListOrgBudgetEnforcementsClusterDefault = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+export type ListOrgBudgetEnforcementsClusterDefault = ClosedEnum<
+  typeof ListOrgBudgetEnforcementsClusterDefault
+>;
+
+/**
+ * What the spend gate does for this organization when the budget check is unavailable
+ */
+export const ListOrgBudgetEnforcementsEffective = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+/**
+ * What the spend gate does for this organization when the budget check is unavailable
+ */
+export type ListOrgBudgetEnforcementsEffective = ClosedEnum<
+  typeof ListOrgBudgetEnforcementsEffective
+>;
+
+export type ListOrgBudgetEnforcementsData = {
+  orgId: string;
+  /**
+   * The organization's own setting; null inherits the cluster default
+   */
+  onCheckFailure: ListOrgBudgetEnforcementsOnCheckFailure | null;
+  clusterDefault: ListOrgBudgetEnforcementsClusterDefault;
+  /**
+   * What the spend gate does for this organization when the budget check is unavailable
+   */
+  effective: ListOrgBudgetEnforcementsEffective;
+};
+
+/**
+ * OK
+ */
+export type ListOrgBudgetEnforcementsResponseBody = {
+  object: "list";
+  data: Array<ListOrgBudgetEnforcementsData>;
+  /**
+   * True when more organizations hold an override than the list returns
+   */
+  hasMore: boolean;
+};
+
+/** @internal */
+export const ListOrgBudgetEnforcementsOnCheckFailure$inboundSchema:
+  z.ZodNativeEnum<typeof ListOrgBudgetEnforcementsOnCheckFailure> = z
+    .nativeEnum(ListOrgBudgetEnforcementsOnCheckFailure);
+/** @internal */
+export const ListOrgBudgetEnforcementsOnCheckFailure$outboundSchema:
+  z.ZodNativeEnum<typeof ListOrgBudgetEnforcementsOnCheckFailure> =
+    ListOrgBudgetEnforcementsOnCheckFailure$inboundSchema;
+
+/** @internal */
+export const ListOrgBudgetEnforcementsClusterDefault$inboundSchema:
+  z.ZodNativeEnum<typeof ListOrgBudgetEnforcementsClusterDefault> = z
+    .nativeEnum(ListOrgBudgetEnforcementsClusterDefault);
+/** @internal */
+export const ListOrgBudgetEnforcementsClusterDefault$outboundSchema:
+  z.ZodNativeEnum<typeof ListOrgBudgetEnforcementsClusterDefault> =
+    ListOrgBudgetEnforcementsClusterDefault$inboundSchema;
+
+/** @internal */
+export const ListOrgBudgetEnforcementsEffective$inboundSchema: z.ZodNativeEnum<
+  typeof ListOrgBudgetEnforcementsEffective
+> = z.nativeEnum(ListOrgBudgetEnforcementsEffective);
+/** @internal */
+export const ListOrgBudgetEnforcementsEffective$outboundSchema: z.ZodNativeEnum<
+  typeof ListOrgBudgetEnforcementsEffective
+> = ListOrgBudgetEnforcementsEffective$inboundSchema;
+
+/** @internal */
+export const ListOrgBudgetEnforcementsData$inboundSchema: z.ZodType<
+  ListOrgBudgetEnforcementsData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+  on_check_failure: z.nullable(
+    ListOrgBudgetEnforcementsOnCheckFailure$inboundSchema,
+  ),
+  cluster_default: ListOrgBudgetEnforcementsClusterDefault$inboundSchema,
+  effective: ListOrgBudgetEnforcementsEffective$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+    "on_check_failure": "onCheckFailure",
+    "cluster_default": "clusterDefault",
+  });
+});
+/** @internal */
+export type ListOrgBudgetEnforcementsData$Outbound = {
+  org_id: string;
+  on_check_failure: string | null;
+  cluster_default: string;
+  effective: string;
+};
+
+/** @internal */
+export const ListOrgBudgetEnforcementsData$outboundSchema: z.ZodType<
+  ListOrgBudgetEnforcementsData$Outbound,
+  z.ZodTypeDef,
+  ListOrgBudgetEnforcementsData
+> = z.object({
+  orgId: z.string(),
+  onCheckFailure: z.nullable(
+    ListOrgBudgetEnforcementsOnCheckFailure$outboundSchema,
+  ),
+  clusterDefault: ListOrgBudgetEnforcementsClusterDefault$outboundSchema,
+  effective: ListOrgBudgetEnforcementsEffective$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+    onCheckFailure: "on_check_failure",
+    clusterDefault: "cluster_default",
+  });
+});
+
+export function listOrgBudgetEnforcementsDataToJSON(
+  listOrgBudgetEnforcementsData: ListOrgBudgetEnforcementsData,
+): string {
+  return JSON.stringify(
+    ListOrgBudgetEnforcementsData$outboundSchema.parse(
+      listOrgBudgetEnforcementsData,
+    ),
+  );
+}
+export function listOrgBudgetEnforcementsDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrgBudgetEnforcementsData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListOrgBudgetEnforcementsData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrgBudgetEnforcementsData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListOrgBudgetEnforcementsResponseBody$inboundSchema: z.ZodType<
+  ListOrgBudgetEnforcementsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.literal("list"),
+  data: z.array(z.lazy(() => ListOrgBudgetEnforcementsData$inboundSchema)),
+  has_more: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+  });
+});
+/** @internal */
+export type ListOrgBudgetEnforcementsResponseBody$Outbound = {
+  object: "list";
+  data: Array<ListOrgBudgetEnforcementsData$Outbound>;
+  has_more: boolean;
+};
+
+/** @internal */
+export const ListOrgBudgetEnforcementsResponseBody$outboundSchema: z.ZodType<
+  ListOrgBudgetEnforcementsResponseBody$Outbound,
+  z.ZodTypeDef,
+  ListOrgBudgetEnforcementsResponseBody
+> = z.object({
+  object: z.literal("list"),
+  data: z.array(z.lazy(() => ListOrgBudgetEnforcementsData$outboundSchema)),
+  hasMore: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    hasMore: "has_more",
+  });
+});
+
+export function listOrgBudgetEnforcementsResponseBodyToJSON(
+  listOrgBudgetEnforcementsResponseBody: ListOrgBudgetEnforcementsResponseBody,
+): string {
+  return JSON.stringify(
+    ListOrgBudgetEnforcementsResponseBody$outboundSchema.parse(
+      listOrgBudgetEnforcementsResponseBody,
+    ),
+  );
+}
+export function listOrgBudgetEnforcementsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrgBudgetEnforcementsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListOrgBudgetEnforcementsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrgBudgetEnforcementsResponseBody' from JSON`,
+  );
+}

package/src/models/operations/reimportopenapitoolset.ts

@@ -0,0 +1,80 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ReimportOpenApiToolSetRequest = {
+  toolSetId: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  importOpenApiToolSetRequest: components.ImportOpenApiToolSetRequest;
+};
+
+/** @internal */
+export const ReimportOpenApiToolSetRequest$inboundSchema: z.ZodType<
+  ReimportOpenApiToolSetRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  tool_set_id: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+  ImportOpenApiToolSetRequest:
+    components.ImportOpenApiToolSetRequest$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "tool_set_id": "toolSetId",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "ImportOpenApiToolSetRequest": "importOpenApiToolSetRequest",
+  });
+});
+/** @internal */
+export type ReimportOpenApiToolSetRequest$Outbound = {
+  tool_set_id: string;
+  "X-On-Behalf-Of"?: string | undefined;
+  ImportOpenApiToolSetRequest: components.ImportOpenApiToolSetRequest$Outbound;
+};
+
+/** @internal */
+export const ReimportOpenApiToolSetRequest$outboundSchema: z.ZodType<
+  ReimportOpenApiToolSetRequest$Outbound,
+  z.ZodTypeDef,
+  ReimportOpenApiToolSetRequest
+> = z.object({
+  toolSetId: z.string(),
+  xOnBehalfOf: z.string().optional(),
+  importOpenApiToolSetRequest:
+    components.ImportOpenApiToolSetRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    toolSetId: "tool_set_id",
+    xOnBehalfOf: "X-On-Behalf-Of",
+    importOpenApiToolSetRequest: "ImportOpenApiToolSetRequest",
+  });
+});
+
+export function reimportOpenApiToolSetRequestToJSON(
+  reimportOpenApiToolSetRequest: ReimportOpenApiToolSetRequest,
+): string {
+  return JSON.stringify(
+    ReimportOpenApiToolSetRequest$outboundSchema.parse(
+      reimportOpenApiToolSetRequest,
+    ),
+  );
+}
+export function reimportOpenApiToolSetRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ReimportOpenApiToolSetRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReimportOpenApiToolSetRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReimportOpenApiToolSetRequest' from JSON`,
+  );
+}

package/src/models/operations/setorgbudgetenforcement.ts

@@ -0,0 +1,280 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const OnCheckFailure = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+export type OnCheckFailure = ClosedEnum<typeof OnCheckFailure>;
+
+export type SetOrgBudgetEnforcementRequestBody = {
+  onCheckFailure: OnCheckFailure | null;
+};
+
+export type SetOrgBudgetEnforcementRequest = {
+  orgId: string;
+  requestBody: SetOrgBudgetEnforcementRequestBody;
+};
+
+export const SetOrgBudgetEnforcementOnCheckFailure = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+export type SetOrgBudgetEnforcementOnCheckFailure = ClosedEnum<
+  typeof SetOrgBudgetEnforcementOnCheckFailure
+>;
+
+export const SetOrgBudgetEnforcementClusterDefault = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+export type SetOrgBudgetEnforcementClusterDefault = ClosedEnum<
+  typeof SetOrgBudgetEnforcementClusterDefault
+>;
+
+/**
+ * What the spend gate does for this organization when the budget check is unavailable
+ */
+export const SetOrgBudgetEnforcementEffective = {
+  Allow: "allow",
+  Block: "block",
+} as const;
+/**
+ * What the spend gate does for this organization when the budget check is unavailable
+ */
+export type SetOrgBudgetEnforcementEffective = ClosedEnum<
+  typeof SetOrgBudgetEnforcementEffective
+>;
+
+/**
+ * OK
+ */
+export type SetOrgBudgetEnforcementResponseBody = {
+  orgId: string;
+  /**
+   * The organization's own setting; null inherits the cluster default
+   */
+  onCheckFailure: SetOrgBudgetEnforcementOnCheckFailure | null;
+  clusterDefault: SetOrgBudgetEnforcementClusterDefault;
+  /**
+   * What the spend gate does for this organization when the budget check is unavailable
+   */
+  effective: SetOrgBudgetEnforcementEffective;
+};
+
+/** @internal */
+export const OnCheckFailure$inboundSchema: z.ZodNativeEnum<
+  typeof OnCheckFailure
+> = z.nativeEnum(OnCheckFailure);
+/** @internal */
+export const OnCheckFailure$outboundSchema: z.ZodNativeEnum<
+  typeof OnCheckFailure
+> = OnCheckFailure$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetEnforcementRequestBody$inboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  on_check_failure: z.nullable(OnCheckFailure$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "on_check_failure": "onCheckFailure",
+  });
+});
+/** @internal */
+export type SetOrgBudgetEnforcementRequestBody$Outbound = {
+  on_check_failure: string | null;
+};
+
+/** @internal */
+export const SetOrgBudgetEnforcementRequestBody$outboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementRequestBody$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetEnforcementRequestBody
+> = z.object({
+  onCheckFailure: z.nullable(OnCheckFailure$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    onCheckFailure: "on_check_failure",
+  });
+});
+
+export function setOrgBudgetEnforcementRequestBodyToJSON(
+  setOrgBudgetEnforcementRequestBody: SetOrgBudgetEnforcementRequestBody,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetEnforcementRequestBody$outboundSchema.parse(
+      setOrgBudgetEnforcementRequestBody,
+    ),
+  );
+}
+export function setOrgBudgetEnforcementRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetEnforcementRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SetOrgBudgetEnforcementRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetEnforcementRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetOrgBudgetEnforcementRequest$inboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+  RequestBody: z.lazy(() => SetOrgBudgetEnforcementRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type SetOrgBudgetEnforcementRequest$Outbound = {
+  org_id: string;
+  RequestBody: SetOrgBudgetEnforcementRequestBody$Outbound;
+};
+
+/** @internal */
+export const SetOrgBudgetEnforcementRequest$outboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementRequest$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetEnforcementRequest
+> = z.object({
+  orgId: z.string(),
+  requestBody: z.lazy(() => SetOrgBudgetEnforcementRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+    requestBody: "RequestBody",
+  });
+});
+
+export function setOrgBudgetEnforcementRequestToJSON(
+  setOrgBudgetEnforcementRequest: SetOrgBudgetEnforcementRequest,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetEnforcementRequest$outboundSchema.parse(
+      setOrgBudgetEnforcementRequest,
+    ),
+  );
+}
+export function setOrgBudgetEnforcementRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetEnforcementRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetOrgBudgetEnforcementRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetEnforcementRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetOrgBudgetEnforcementOnCheckFailure$inboundSchema:
+  z.ZodNativeEnum<typeof SetOrgBudgetEnforcementOnCheckFailure> = z.nativeEnum(
+    SetOrgBudgetEnforcementOnCheckFailure,
+  );
+/** @internal */
+export const SetOrgBudgetEnforcementOnCheckFailure$outboundSchema:
+  z.ZodNativeEnum<typeof SetOrgBudgetEnforcementOnCheckFailure> =
+    SetOrgBudgetEnforcementOnCheckFailure$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetEnforcementClusterDefault$inboundSchema:
+  z.ZodNativeEnum<typeof SetOrgBudgetEnforcementClusterDefault> = z.nativeEnum(
+    SetOrgBudgetEnforcementClusterDefault,
+  );
+/** @internal */
+export const SetOrgBudgetEnforcementClusterDefault$outboundSchema:
+  z.ZodNativeEnum<typeof SetOrgBudgetEnforcementClusterDefault> =
+    SetOrgBudgetEnforcementClusterDefault$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetEnforcementEffective$inboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetEnforcementEffective
+> = z.nativeEnum(SetOrgBudgetEnforcementEffective);
+/** @internal */
+export const SetOrgBudgetEnforcementEffective$outboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetEnforcementEffective
+> = SetOrgBudgetEnforcementEffective$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetEnforcementResponseBody$inboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+  on_check_failure: z.nullable(
+    SetOrgBudgetEnforcementOnCheckFailure$inboundSchema,
+  ),
+  cluster_default: SetOrgBudgetEnforcementClusterDefault$inboundSchema,
+  effective: SetOrgBudgetEnforcementEffective$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+    "on_check_failure": "onCheckFailure",
+    "cluster_default": "clusterDefault",
+  });
+});
+/** @internal */
+export type SetOrgBudgetEnforcementResponseBody$Outbound = {
+  org_id: string;
+  on_check_failure: string | null;
+  cluster_default: string;
+  effective: string;
+};
+
+/** @internal */
+export const SetOrgBudgetEnforcementResponseBody$outboundSchema: z.ZodType<
+  SetOrgBudgetEnforcementResponseBody$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetEnforcementResponseBody
+> = z.object({
+  orgId: z.string(),
+  onCheckFailure: z.nullable(
+    SetOrgBudgetEnforcementOnCheckFailure$outboundSchema,
+  ),
+  clusterDefault: SetOrgBudgetEnforcementClusterDefault$outboundSchema,
+  effective: SetOrgBudgetEnforcementEffective$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+    onCheckFailure: "on_check_failure",
+    clusterDefault: "cluster_default",
+  });
+});
+
+export function setOrgBudgetEnforcementResponseBodyToJSON(
+  setOrgBudgetEnforcementResponseBody: SetOrgBudgetEnforcementResponseBody,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetEnforcementResponseBody$outboundSchema.parse(
+      setOrgBudgetEnforcementResponseBody,
+    ),
+  );
+}
+export function setOrgBudgetEnforcementResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetEnforcementResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SetOrgBudgetEnforcementResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetEnforcementResponseBody' from JSON`,
+  );
+}

package/src/react-query/agentsDeleteOpenApiToolSet.ts

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { agentsDeleteOpenApiToolSet } from "../funcs/agentsDeleteOpenApiToolSet.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type AgentsDeleteOpenApiToolSetMutationVariables = {
+  request: operations.DeleteOpenApiToolSetRequest;
+  options?: RequestOptions;
+};
+
+export type AgentsDeleteOpenApiToolSetMutationData =
+  operations.DeleteOpenApiToolSetResponseBody;
+
+export type AgentsDeleteOpenApiToolSetMutationError =
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Delete an OpenAPI tool set
+ *
+ * @remarks
+ * Attached agents fail until the unavailable reference is removed. Existing run snapshots remain usable.
+ */
+export function useAgentsDeleteOpenApiToolSetMutation(
+  options?: MutationHookOptions<
+    AgentsDeleteOpenApiToolSetMutationData,
+    AgentsDeleteOpenApiToolSetMutationError,
+    AgentsDeleteOpenApiToolSetMutationVariables
+  >,
+): UseMutationResult<
+  AgentsDeleteOpenApiToolSetMutationData,
+  AgentsDeleteOpenApiToolSetMutationError,
+  AgentsDeleteOpenApiToolSetMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildAgentsDeleteOpenApiToolSetMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyAgentsDeleteOpenApiToolSet(): MutationKey {
+  return ["@meetkai/mka1", "Agents", "deleteOpenApiToolSet"];
+}
+
+export function buildAgentsDeleteOpenApiToolSetMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: AgentsDeleteOpenApiToolSetMutationVariables,
+  ) => Promise<AgentsDeleteOpenApiToolSetMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyAgentsDeleteOpenApiToolSet(),
+    mutationFn: function agentsDeleteOpenApiToolSetMutationFn({
+      request,
+      options,
+    }): Promise<AgentsDeleteOpenApiToolSetMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(agentsDeleteOpenApiToolSet(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}