@gleanwork/api-client 0.17.1 → 0.17.3

package/src/models/components/chatmessagefragment.ts

@@ -25,6 +25,18 @@ import {
   QuerySuggestion$Outbound,
   QuerySuggestion$outboundSchema,
 } from "./querysuggestion.js";
+import {
+  ServerToolRequest,
+  ServerToolRequest$inboundSchema,
+  ServerToolRequest$Outbound,
+  ServerToolRequest$outboundSchema,
+} from "./servertoolrequest.js";
+import {
+  ServerToolResponse,
+  ServerToolResponse$inboundSchema,
+  ServerToolResponse$Outbound,
+  ServerToolResponse$outboundSchema,
+} from "./servertoolresponse.js";
 import {
   StructuredResult,
   StructuredResult$inboundSchema,
@@ -61,6 +73,25 @@ export type ChatMessageFragment = {
    * Information about the source for a ChatMessage.
    */
   citation?: ChatMessageCitation | undefined;
+  serverToolRequest?: ServerToolRequest | undefined;
+  /**
+   * Response to a server tool request. The applicable fields depend on requestType:
+   *
+   * @remarks
+   *
+   * For EXECUTION requests:
+   * - isGranted: whether tool execution is approved
+   * - reason: optional explanation
+   *
+   * For AUTHENTICATION_SUGGESTION requests:
+   * - isGranted: whether auth completed successfully (true=connected, false=skipped)
+   * - authContext: contains serverId or actionPackId for identifying the authenticated entity
+   * - reason: optional explanation for skip
+   *
+   * For VOTE_SUGGESTION requests:
+   * - voted: whether the user voted for this tool
+   */
+  serverToolResponse?: ServerToolResponse | undefined;
 };
 
 /** @internal */
@@ -76,6 +107,8 @@ export const ChatMessageFragment$inboundSchema: z.ZodType<
   file: ChatFile$inboundSchema.optional(),
   action: ToolInfo$inboundSchema.optional(),
   citation: ChatMessageCitation$inboundSchema.optional(),
+  serverToolRequest: ServerToolRequest$inboundSchema.optional(),
+  serverToolResponse: ServerToolResponse$inboundSchema.optional(),
 });
 /** @internal */
 export type ChatMessageFragment$Outbound = {
@@ -86,6 +119,8 @@ export type ChatMessageFragment$Outbound = {
   file?: ChatFile$Outbound | undefined;
   action?: ToolInfo$Outbound | undefined;
   citation?: ChatMessageCitation$Outbound | undefined;
+  serverToolRequest?: ServerToolRequest$Outbound | undefined;
+  serverToolResponse?: ServerToolResponse$Outbound | undefined;
 };
 
 /** @internal */
@@ -101,6 +136,8 @@ export const ChatMessageFragment$outboundSchema: z.ZodType<
   file: ChatFile$outboundSchema.optional(),
   action: ToolInfo$outboundSchema.optional(),
   citation: ChatMessageCitation$outboundSchema.optional(),
+  serverToolRequest: ServerToolRequest$outboundSchema.optional(),
+  serverToolResponse: ServerToolResponse$outboundSchema.optional(),
 });
 
 export function chatMessageFragmentToJSON(

package/src/models/components/feedentry.ts

@@ -122,6 +122,7 @@ export const JustificationType = {
   DemoCard: "DEMO_CARD",
   OooPlanner: "OOO_PLANNER",
   OooCatchUp: "OOO_CATCH_UP",
+  AdminHealthCenter: "ADMIN_HEALTH_CENTER",
 } as const;
 /**
  * Type of the justification.

package/src/models/components/feedrequest.ts

@@ -60,6 +60,7 @@ export const FeedRequestCategory = {
   DemoCard: "DEMO_CARD",
   OooPlanner: "OOO_PLANNER",
   OooCatchUp: "OOO_CATCH_UP",
+  AdminHealthCenter: "ADMIN_HEALTH_CENTER",
 } as const;
 export type FeedRequestCategory = ClosedEnum<typeof FeedRequestCategory>;
 

package/src/models/components/feedresult.ts

@@ -58,6 +58,7 @@ export const FeedResultCategory = {
   DemoCard: "DEMO_CARD",
   OooPlanner: "OOO_PLANNER",
   OooCatchUp: "OOO_CATCH_UP",
+  AdminHealthCenter: "ADMIN_HEALTH_CENTER",
 } as const;
 /**
  * Category of the result, one of the requested categories in incoming request.

package/src/models/components/index.ts

@@ -6,6 +6,7 @@
 export * from "./actionauthtype.js";
 export * from "./actionpackauthstatus.js";
 export * from "./actionpackauthstatusresponse.js";
+export * from "./actionpreview.js";
 export * from "./actionsummary.js";
 export * from "./activity.js";
 export * from "./activityevent.js";
@@ -38,8 +39,11 @@ export * from "./answerresult.js";
 export * from "./appresult.js";
 export * from "./assistantinsightsresponse.js";
 export * from "./authconfig.js";
+export * from "./authcontext.js";
 export * from "./authorizeactionpackrequest.js";
 export * from "./authorizeactionpackresponse.js";
+export * from "./authorizetoolserverrequest.js";
+export * from "./authorizetoolserverresponse.js";
 export * from "./authstatus.js";
 export * from "./authtoken.js";
 export * from "./autocompleterequest.js";
@@ -412,6 +416,8 @@ export * from "./seenfeedbackinfo.js";
 export * from "./sensitivecontentoptions.js";
 export * from "./sensitiveexpression.js";
 export * from "./sensitiveinfotype.js";
+export * from "./servertoolrequest.js";
+export * from "./servertoolresponse.js";
 export * from "./sessioninfo.js";
 export * from "./share.js";
 export * from "./sharingoptions.js";
@@ -450,6 +456,8 @@ export * from "./toolparameter.js";
 export * from "./toolscallparameter.js";
 export * from "./toolscallrequest.js";
 export * from "./toolscallresponse.js";
+export * from "./toolserverauthstatus.js";
+export * from "./toolserverauthstatusresponse.js";
 export * from "./toolsets.js";
 export * from "./toolslistresponse.js";
 export * from "./ugctype.js";

package/src/models/components/listentitiesrequest.ts

@@ -43,7 +43,7 @@ export type ListEntitiesRequestIncludeField = ClosedEnum<
 /**
  * The type of request being made.
  */
-export const RequestType = {
+export const ListEntitiesRequestRequestType = {
   /**
    * Used by default for all requests and satisfies all standard use cases for list requests. Limited to 10000 entities.
    */
@@ -56,7 +56,9 @@ export const RequestType = {
 /**
  * The type of request being made.
  */
-export type RequestType = ClosedEnum<typeof RequestType>;
+export type ListEntitiesRequestRequestType = ClosedEnum<
+  typeof ListEntitiesRequestRequestType
+>;
 
 export type ListEntitiesRequest = {
   filter?: Array<FacetFilter> | undefined;
@@ -92,7 +94,7 @@ export type ListEntitiesRequest = {
   /**
    * The type of request being made.
    */
-  requestType?: RequestType | undefined;
+  requestType?: ListEntitiesRequestRequestType | undefined;
 };
 
 /** @internal */
@@ -106,8 +108,9 @@ export const ListEntitiesRequestIncludeField$outboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(ListEntitiesRequestIncludeField);
 
 /** @internal */
-export const RequestType$outboundSchema: z.ZodNativeEnum<typeof RequestType> = z
-  .nativeEnum(RequestType);
+export const ListEntitiesRequestRequestType$outboundSchema: z.ZodNativeEnum<
+  typeof ListEntitiesRequestRequestType
+> = z.nativeEnum(ListEntitiesRequestRequestType);
 
 /** @internal */
 export type ListEntitiesRequest$Outbound = {
@@ -139,7 +142,9 @@ export const ListEntitiesRequest$outboundSchema: z.ZodType<
   pageSize: z.number().int().optional(),
   cursor: z.string().optional(),
   source: z.string().optional(),
-  requestType: RequestType$outboundSchema.default("STANDARD"),
+  requestType: ListEntitiesRequestRequestType$outboundSchema.default(
+    "STANDARD",
+  ),
 });
 
 export function listEntitiesRequestToJSON(

package/src/models/components/servertoolrequest.ts

@@ -0,0 +1,138 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cac47cd90cd3
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ActionPreview,
+  ActionPreview$inboundSchema,
+  ActionPreview$Outbound,
+  ActionPreview$outboundSchema,
+} from "./actionpreview.js";
+
+/**
+ * The type of request made to the user.
+ */
+export const ServerToolRequestRequestType = {
+  /**
+   * Request for approving execution of the tool.
+   */
+  Execution: "EXECUTION",
+  /**
+   * Request for authenticating to a tool, provided as a (tool) suggestion.
+   */
+  AuthenticationSuggestion: "AUTHENTICATION_SUGGESTION",
+  /**
+   * Suggestion to vote for enabling an available-but-not-enabled tool.
+   */
+  VoteSuggestion: "VOTE_SUGGESTION",
+} as const;
+/**
+ * The type of request made to the user.
+ */
+export type ServerToolRequestRequestType = OpenEnum<
+  typeof ServerToolRequestRequestType
+>;
+
+export type ServerToolRequest = {
+  /**
+   * The type of request made to the user.
+   */
+  requestType: ServerToolRequestRequestType;
+  /**
+   * Unique identifier for this request.
+   */
+  requestId: string;
+  /**
+   * Human-readable display name for the tool.
+   */
+  toolDisplayName?: string | undefined;
+  /**
+   * Unique identifier of the tool server. Use with GET /tool-servers/{serverId}/auth
+   *
+   * @remarks
+   * to resolve display information and authentication status.
+   */
+  serverId?: string | undefined;
+  /**
+   * Custom call-to-action (CTA) verb for the approval button (e.g., "Create", "Update", "Send").
+   */
+  toolCta?: string | undefined;
+  /**
+   * Preview information for an action being executed.
+   */
+  actionPreview?: ActionPreview | undefined;
+};
+
+/** @internal */
+export const ServerToolRequestRequestType$inboundSchema: z.ZodType<
+  ServerToolRequestRequestType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ServerToolRequestRequestType);
+/** @internal */
+export const ServerToolRequestRequestType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ServerToolRequestRequestType
+> = openEnums.outboundSchema(ServerToolRequestRequestType);
+
+/** @internal */
+export const ServerToolRequest$inboundSchema: z.ZodType<
+  ServerToolRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  requestType: ServerToolRequestRequestType$inboundSchema,
+  requestId: z.string(),
+  toolDisplayName: z.string().optional(),
+  serverId: z.string().optional(),
+  toolCta: z.string().optional(),
+  actionPreview: ActionPreview$inboundSchema.optional(),
+});
+/** @internal */
+export type ServerToolRequest$Outbound = {
+  requestType: string;
+  requestId: string;
+  toolDisplayName?: string | undefined;
+  serverId?: string | undefined;
+  toolCta?: string | undefined;
+  actionPreview?: ActionPreview$Outbound | undefined;
+};
+
+/** @internal */
+export const ServerToolRequest$outboundSchema: z.ZodType<
+  ServerToolRequest$Outbound,
+  z.ZodTypeDef,
+  ServerToolRequest
+> = z.object({
+  requestType: ServerToolRequestRequestType$outboundSchema,
+  requestId: z.string(),
+  toolDisplayName: z.string().optional(),
+  serverId: z.string().optional(),
+  toolCta: z.string().optional(),
+  actionPreview: ActionPreview$outboundSchema.optional(),
+});
+
+export function serverToolRequestToJSON(
+  serverToolRequest: ServerToolRequest,
+): string {
+  return JSON.stringify(
+    ServerToolRequest$outboundSchema.parse(serverToolRequest),
+  );
+}
+export function serverToolRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ServerToolRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ServerToolRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ServerToolRequest' from JSON`,
+  );
+}

package/src/models/components/servertoolresponse.ts

@@ -0,0 +1,188 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9d3c25ee1ce8
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AuthContext,
+  AuthContext$inboundSchema,
+  AuthContext$Outbound,
+  AuthContext$outboundSchema,
+} from "./authcontext.js";
+
+/**
+ * The type of request made to the user.
+ */
+export const ServerToolResponseRequestType = {
+  /**
+   * Request for approving execution of the tool.
+   */
+  Execution: "EXECUTION",
+  /**
+   * Request for authenticating to a tool, provided as a (tool) suggestion.
+   */
+  AuthenticationSuggestion: "AUTHENTICATION_SUGGESTION",
+  /**
+   * Suggestion to vote for enabling an available-but-not-enabled tool.
+   */
+  VoteSuggestion: "VOTE_SUGGESTION",
+} as const;
+/**
+ * The type of request made to the user.
+ */
+export type ServerToolResponseRequestType = OpenEnum<
+  typeof ServerToolResponseRequestType
+>;
+
+/**
+ * Scope of the approval grant. Only applicable when isGranted is true and requestType is EXECUTION.
+ *
+ * @remarks
+ */
+export const GrantScope = {
+  /**
+   * Approve only the current tool request. Future tool execution requests still require approval.
+   */
+  CurrentRequest: "CURRENT_REQUEST",
+  /**
+   * Approve the current tool request and auto-approve all future same tool requests in this chat session.
+   */
+  CurrentSession: "CURRENT_SESSION",
+  /**
+   * Approve the current tool request and auto-approve all future same tool requests across all chat sessions.
+   */
+  Always: "ALWAYS",
+} as const;
+/**
+ * Scope of the approval grant. Only applicable when isGranted is true and requestType is EXECUTION.
+ *
+ * @remarks
+ */
+export type GrantScope = OpenEnum<typeof GrantScope>;
+
+/**
+ * Response to a server tool request. The applicable fields depend on requestType:
+ *
+ * @remarks
+ *
+ * For EXECUTION requests:
+ * - isGranted: whether tool execution is approved
+ * - reason: optional explanation
+ *
+ * For AUTHENTICATION_SUGGESTION requests:
+ * - isGranted: whether auth completed successfully (true=connected, false=skipped)
+ * - authContext: contains serverId or actionPackId for identifying the authenticated entity
+ * - reason: optional explanation for skip
+ *
+ * For VOTE_SUGGESTION requests:
+ * - voted: whether the user voted for this tool
+ */
+export type ServerToolResponse = {
+  /**
+   * The type of request made to the user.
+   */
+  requestType: ServerToolResponseRequestType;
+  /**
+   * Unique identifier for this request.
+   */
+  requestId: string;
+  /**
+   * Whether tool request is granted (indicates approval for execution, or completion for auth).
+   */
+  isGranted?: boolean | undefined;
+  /**
+   * Scope of the approval grant. Only applicable when isGranted is true and requestType is EXECUTION.
+   *
+   * @remarks
+   */
+  grantScope?: GrantScope | undefined;
+  /**
+   * Context for authentication responses, containing identifiers for the entity being authenticated.
+   *
+   * @remarks
+   */
+  authContext?: AuthContext | undefined;
+};
+
+/** @internal */
+export const ServerToolResponseRequestType$inboundSchema: z.ZodType<
+  ServerToolResponseRequestType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ServerToolResponseRequestType);
+/** @internal */
+export const ServerToolResponseRequestType$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  ServerToolResponseRequestType
+> = openEnums.outboundSchema(ServerToolResponseRequestType);
+
+/** @internal */
+export const GrantScope$inboundSchema: z.ZodType<
+  GrantScope,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(GrantScope);
+/** @internal */
+export const GrantScope$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  GrantScope
+> = openEnums.outboundSchema(GrantScope);
+
+/** @internal */
+export const ServerToolResponse$inboundSchema: z.ZodType<
+  ServerToolResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  requestType: ServerToolResponseRequestType$inboundSchema,
+  requestId: z.string(),
+  isGranted: z.boolean().optional(),
+  grantScope: GrantScope$inboundSchema.default("CURRENT_REQUEST"),
+  authContext: AuthContext$inboundSchema.optional(),
+});
+/** @internal */
+export type ServerToolResponse$Outbound = {
+  requestType: string;
+  requestId: string;
+  isGranted?: boolean | undefined;
+  grantScope: string;
+  authContext?: AuthContext$Outbound | undefined;
+};
+
+/** @internal */
+export const ServerToolResponse$outboundSchema: z.ZodType<
+  ServerToolResponse$Outbound,
+  z.ZodTypeDef,
+  ServerToolResponse
+> = z.object({
+  requestType: ServerToolResponseRequestType$outboundSchema,
+  requestId: z.string(),
+  isGranted: z.boolean().optional(),
+  grantScope: GrantScope$outboundSchema.default("CURRENT_REQUEST"),
+  authContext: AuthContext$outboundSchema.optional(),
+});
+
+export function serverToolResponseToJSON(
+  serverToolResponse: ServerToolResponse,
+): string {
+  return JSON.stringify(
+    ServerToolResponse$outboundSchema.parse(serverToolResponse),
+  );
+}
+export function serverToolResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ServerToolResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ServerToolResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ServerToolResponse' from JSON`,
+  );
+}

package/src/models/components/toolserverauthstatus.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 071ce1b5ce41
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * Authentication status for the calling user.
+ */
+export const ToolServerAuthStatus = {
+  AwaitingAuth: "AWAITING_AUTH",
+  Authorized: "AUTHORIZED",
+} as const;
+/**
+ * Authentication status for the calling user.
+ */
+export type ToolServerAuthStatus = OpenEnum<typeof ToolServerAuthStatus>;
+
+/** @internal */
+export const ToolServerAuthStatus$inboundSchema: z.ZodType<
+  ToolServerAuthStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ToolServerAuthStatus);

package/src/models/components/toolserverauthstatusresponse.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9b8d34bb7e2d
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ActionAuthType,
+  ActionAuthType$inboundSchema,
+} from "./actionauthtype.js";
+import {
+  ToolServerAuthStatus,
+  ToolServerAuthStatus$inboundSchema,
+} from "./toolserverauthstatus.js";
+
+export type ToolServerAuthStatusResponse = {
+  /**
+   * Human-readable name of the tool server.
+   */
+  displayName?: string | undefined;
+  /**
+   * Logo URL for the tool server.
+   */
+  logoUrl?: string | undefined;
+  /**
+   * Brief description of the tool server.
+   */
+  description?: string | undefined;
+  /**
+   * Authentication status for the calling user.
+   */
+  authStatus: ToolServerAuthStatus;
+  /**
+   * Authentication mechanism used by an action pack.
+   *
+   * @remarks
+   *   - `AUTH_USER_OAUTH`: Requires per-user OAuth consent to the third-party tool.
+   *   - `AUTH_ADMIN`: Uses a service-account / admin-owned credential. End users do not authorize individually.
+   *   - `AUTH_NONE`: Action pack requires no authentication.
+   */
+  authType: ActionAuthType;
+};
+
+/** @internal */
+export const ToolServerAuthStatusResponse$inboundSchema: z.ZodType<
+  ToolServerAuthStatusResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  displayName: z.string().optional(),
+  logoUrl: z.string().optional(),
+  description: z.string().optional(),
+  authStatus: ToolServerAuthStatus$inboundSchema,
+  authType: ActionAuthType$inboundSchema,
+});
+
+export function toolServerAuthStatusResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ToolServerAuthStatusResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ToolServerAuthStatusResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ToolServerAuthStatusResponse' from JSON`,
+  );
+}

package/src/models/operations/authorizetoolserver.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d7057ee40a5b
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+
+export type AuthorizeToolServerRequest = {
+  /**
+   * Unique identifier of the tool server.
+   */
+  serverId: string;
+  authorizeToolServerRequest: components.AuthorizeToolServerRequest;
+};
+
+/** @internal */
+export type AuthorizeToolServerRequest$Outbound = {
+  serverId: string;
+  AuthorizeToolServerRequest: components.AuthorizeToolServerRequest$Outbound;
+};
+
+/** @internal */
+export const AuthorizeToolServerRequest$outboundSchema: z.ZodType<
+  AuthorizeToolServerRequest$Outbound,
+  z.ZodTypeDef,
+  AuthorizeToolServerRequest
+> = z.object({
+  serverId: z.string(),
+  authorizeToolServerRequest:
+    components.AuthorizeToolServerRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    authorizeToolServerRequest: "AuthorizeToolServerRequest",
+  });
+});
+
+export function authorizeToolServerRequestToJSON(
+  authorizeToolServerRequest: AuthorizeToolServerRequest,
+): string {
+  return JSON.stringify(
+    AuthorizeToolServerRequest$outboundSchema.parse(authorizeToolServerRequest),
+  );
+}

package/src/models/operations/gettoolserverauthstatus.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b9399d9292cf
+ */
+
+import * as z from "zod/v3";
+
+export type GetToolServerAuthStatusRequest = {
+  /**
+   * Unique identifier of the tool server.
+   */
+  serverId: string;
+};
+
+/** @internal */
+export type GetToolServerAuthStatusRequest$Outbound = {
+  serverId: string;
+};
+
+/** @internal */
+export const GetToolServerAuthStatusRequest$outboundSchema: z.ZodType<
+  GetToolServerAuthStatusRequest$Outbound,
+  z.ZodTypeDef,
+  GetToolServerAuthStatusRequest
+> = z.object({
+  serverId: z.string(),
+});
+
+export function getToolServerAuthStatusRequestToJSON(
+  getToolServerAuthStatusRequest: GetToolServerAuthStatusRequest,
+): string {
+  return JSON.stringify(
+    GetToolServerAuthStatusRequest$outboundSchema.parse(
+      getToolServerAuthStatusRequest,
+    ),
+  );
+}