@egain/egain-mcp-server 1.0.26 → 1.1.0

package/src/mcp-server/tools.ts

@@ -3,52 +3,59 @@
  */
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  ShapeOutput,
+  ZodRawShapeCompat,
+} from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import {
   CallToolResult,
   ServerNotification,
   ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
-import { objectOutputType, ZodRawShape, ZodTypeAny } from "zod";
+import * as z from "zod";
 import { EgainMcpCore } from "../core.js";
 import { ConsoleLogger } from "./console-logger.js";
-import { MCPScope } from "./scopes.js";
+import { MCPScope, mcpScopes } from "./scopes.js";
 import { isAsyncIterable, isBinaryData, valueToBase64 } from "./shared.js";
 
-export type ToolDefinition<Args extends undefined | ZodRawShape = undefined> =
-  Args extends ZodRawShape ? {
-      name: string;
-      description: string;
-      scopes?: MCPScope[];
-      args: Args;
-      annotations: {
-        destructiveHint: boolean;
-        idempotentHint: boolean;
-        openWorldHint: boolean;
-        readOnlyHint: boolean;
-      };
-      tool: (
-        client: EgainMcpCore,
-        args: objectOutputType<Args, ZodTypeAny>,
-        extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-      ) => CallToolResult | Promise<CallToolResult>;
-    }
-    : {
-      name: string;
-      description: string;
-      scopes?: MCPScope[];
-      args?: undefined;
-      annotations: {
-        destructiveHint: boolean;
-        idempotentHint: boolean;
-        openWorldHint: boolean;
-        readOnlyHint: boolean;
-      };
-      tool: (
-        client: EgainMcpCore,
-        extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-      ) => CallToolResult | Promise<CallToolResult>;
+export type ToolDefinition<
+  Args extends undefined | ZodRawShapeCompat = undefined,
+> = Args extends ZodRawShapeCompat ? {
+    name: string;
+    description: string;
+    scopes?: MCPScope[];
+    args: Args;
+    annotations: {
+      title: string;
+      destructiveHint: boolean;
+      idempotentHint: boolean;
+      openWorldHint: boolean;
+      readOnlyHint: boolean;
+    };
+    tool: (
+      client: EgainMcpCore,
+      args: ShapeOutput<Args>,
+      extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+    ) => CallToolResult | Promise<CallToolResult>;
+  }
+  : {
+    name: string;
+    description: string;
+    scopes?: MCPScope[];
+    args?: undefined;
+    annotations: {
+      title: string;
+      destructiveHint: boolean;
+      idempotentHint: boolean;
+      openWorldHint: boolean;
+      readOnlyHint: boolean;
     };
+    tool: (
+      client: EgainMcpCore,
+      extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+    ) => CallToolResult | Promise<CallToolResult>;
+  };
 
 // Optional function to assist with formatting tool results
 export async function formatResult(
@@ -87,7 +94,8 @@ export async function formatResult(
     };
   }
 
-  return { content };
+  const isError = response ? !response.ok : false;
+  return isError ? { content, isError } : { content };
 }
 
 async function consumeSSE(
@@ -112,8 +120,20 @@ export function createRegisterTool(
   getSDK: () => EgainMcpCore,
   allowedScopes: Set<MCPScope>,
   allowedTools?: Set<string>,
-): <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>) => void {
-  return <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>): void => {
+  dynamic?: boolean,
+): [
+  <A extends ZodRawShapeCompat | undefined>(tool: ToolDefinition<A>) => void,
+  Array<{ name: string; description: string }>,
+  Map<string, ToolDefinition<ZodRawShapeCompat | undefined>>,
+] {
+  const tools: Array<{ name: string; description: string }> = [];
+  const toolMap = new Map<
+    string,
+    ToolDefinition<ZodRawShapeCompat | undefined>
+  >();
+  const registerTool = <A extends ZodRawShapeCompat | undefined>(
+    tool: ToolDefinition<A>,
+  ): void => {
     if (allowedTools && !allowedTools.has(tool.name)) {
       return;
     }
@@ -130,27 +150,261 @@ export function createRegisterTool(
       return;
     }
 
+    toolMap.set(
+      tool.name,
+      tool as ToolDefinition<ZodRawShapeCompat | undefined>,
+    );
+
+    if (dynamic) {
+      logger.debug("Collected tool for dynamic mode", { name: tool.name });
+      tools.push({ name: tool.name, description: tool.description });
+      return;
+    }
+
     if (tool.args) {
-      server.tool(
+      server.registerTool(
         tool.name,
-        tool.description,
-        tool.args,
-        tool.annotations,
+        {
+          description: tool.description,
+          inputSchema: tool.args,
+          annotations: tool.annotations,
+        },
         async (args, ctx) => {
           return tool.tool(getSDK(), args, ctx);
         },
       );
     } else {
-      server.tool(
+      server.registerTool(
         tool.name,
-        tool.description,
-        tool.annotations,
-        async (_, ctx) => {
+        {
+          description: tool.description,
+          annotations: tool.annotations,
+        },
+        async (ctx) => {
           return tool.tool(getSDK(), ctx);
         },
       );
     }
 
     logger.debug("Registered tool", { name: tool.name });
+    tools.push({ name: tool.name, description: tool.description });
   };
+
+  return [registerTool, tools, toolMap];
+}
+
+function matchesSearchTerms(
+  terms: string[],
+  name: string,
+  def: ToolDefinition<ZodRawShapeCompat | undefined>,
+): boolean {
+  if (terms.length === 0) {
+    return true;
+  }
+
+  const nameLower = name.toLowerCase();
+  const descLower = def.description.toLowerCase();
+  const scopesLower = def.scopes?.flatMap((s: unknown) => {
+    return typeof s === "string" ? [s.toLowerCase()] : [];
+  }) || [];
+
+  return terms.some((term) =>
+    nameLower.includes(term)
+    || descLower.includes(term)
+    || scopesLower.some((s) => s.includes(term))
+  );
+}
+
+export function registerDynamicTools(
+  logger: ConsoleLogger,
+  server: McpServer,
+  getSDK: () => EgainMcpCore,
+  toolMap: Map<string, ToolDefinition<ZodRawShapeCompat | undefined>>,
+  allowedScopes: Set<MCPScope>,
+): void {
+  // 1. list_tools
+  server.registerTool("list_tools", {
+    description:
+      "List available tools. Optionally filter by search terms that match against tool name, description, and scopes.",
+    inputSchema: {
+      search_terms: z.array(z.string()).optional().describe(
+        [
+          "Filter the list of tools.",
+          "Each term is matched case-insensitively as a substring against tool name, description, and scopes.",
+          "Multiple terms are combined with a logical OR: a tool is included if ANY term matches ANY field.",
+          "If not provided, all tools are returned.",
+        ].join("\n"),
+      ),
+    },
+    annotations: {
+      title: "List Tools",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  }, async (args) => {
+    const terms = (args.search_terms ?? []).map((t) => t.toLowerCase());
+
+    const tools: Array<
+      { name: string; description: string; scopes?: MCPScope[] | undefined }
+    > = [];
+    for (const [name, def] of toolMap) {
+      if (!matchesSearchTerms(terms, name, def)) {
+        continue;
+      }
+
+      tools.push({
+        name: name,
+        description: def.description,
+        scopes: def.scopes,
+      });
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(tools, null, 2) }],
+    };
+  });
+  logger.debug("Registered dynamic meta-tool", { name: "list_tools" });
+
+  // 2. describe_tool
+  server.registerTool("describe_tool_input", {
+    description:
+      "Get the input schema for one or more tools. It is a good idea to call this tool first to understand how to successfully call execute_tool.",
+    inputSchema: {
+      tool_names: z.array(z.string()).describe(
+        "The names of the tools to describe",
+      ),
+    },
+    annotations: {
+      title: "Describe Tool",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  }, async (args) => {
+    const parts: string[] = [];
+    const unknown: string[] = [];
+
+    if (args.tool_names.length === 0) {
+      return { content: [{ type: "text", text: "No tool names provided." }] };
+    }
+
+    for (const toolName of args.tool_names) {
+      const def = toolMap.get(toolName);
+      if (!def) {
+        unknown.push(toolName);
+        continue;
+      }
+
+      let schemaText = `<input_schema tool="${toolName}">\n\n`;
+      if (def.args) {
+        const jsonSchema = z.toJSONSchema(z.object(def.args), {
+          target: "draft-2020-12",
+        });
+        schemaText += JSON.stringify(jsonSchema, null, 2);
+      } else {
+        schemaText += "This tool takes no input parameters.";
+      }
+      schemaText += `\n\n</input_schema>`;
+      parts.push(schemaText);
+    }
+
+    if (unknown.length > 0) {
+      parts.push(`Unknown tools: ${unknown.join(", ")}`);
+    }
+
+    return { content: [{ type: "text", text: parts.join("\n\n") }] };
+  });
+  logger.debug("Registered dynamic meta-tool", { name: "describe_tool" });
+
+  // 3. execute_tool
+  server.registerTool("execute_tool", {
+    description:
+      "Execute a tool by name with the provided input parameters. If executing a given tool for the first time, it is recommended to call describe_tool_input first to understand the expected input schema.",
+    inputSchema: {
+      tool_name: z.string().describe("The name of the tool to execute"),
+      input: z.record(z.string(), z.unknown()).optional().describe(
+        "Input parameters for the tool as a JSON object",
+      ),
+    },
+    annotations: {
+      title: "Execute Tool",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  }, async (args, ctx) => {
+    const def = toolMap.get(args.tool_name);
+    if (!def) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${args.tool_name}` }],
+        isError: true,
+      };
+    }
+
+    let validatedInput: Record<string, unknown> = {};
+    if (def.args) {
+      const vres = z.object(def.args).safeParse(args.input ?? {});
+      if (vres.success) {
+        validatedInput = vres.data;
+      } else {
+        const issues = z.prettifyError(vres.error);
+
+        return {
+          content: [{
+            type: "text",
+            text:
+              `Invalid input for tool ${args.tool_name}:\n<issues>\n${issues}\n</issues>`,
+          }],
+          isError: true,
+        };
+      }
+    }
+
+    try {
+      if (def.args) {
+        return await def.tool(getSDK(), validatedInput, ctx);
+      } else {
+        return await def.tool(getSDK(), ctx);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{
+          type: "text",
+          text: `Error executing tool ${args.tool_name}: ${message}`,
+        }],
+        isError: true,
+      };
+    }
+  });
+  logger.debug("Registered dynamic meta-tool", { name: "execute_tool" });
+
+  // 4. list_scopes (only when the server has scopes defined)
+  if (mcpScopes.length > 0) {
+    const scopes = allowedScopes.size > 0
+      ? [...allowedScopes].sort()
+      : [...mcpScopes];
+
+    server.registerTool("list_scopes", {
+      description: [
+        "List the scopes available on this server.",
+        "Scopes are categories that group related tools together.",
+        "They can be used as search terms when filtering the list of tools.",
+      ].join("\n"),
+      annotations: {
+        title: "List Scopes",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    }, async () => {
+      const lines = scopes.map((s) => `- ${s}`);
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+    logger.debug("Registered dynamic meta-tool", { name: "list_scopes" });
+  }
 }

package/src/models/acceptlanguage.ts

@@ -3,10 +3,27 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+export const AcceptLanguage = {
+  EnUS: "en-US",
+  ESES: "es-ES",
+  FRFR: "fr-FR",
+  ITIT: "it-IT",
+  DEDE: "de-DE",
+  NLNL: "nl-NL",
+  PtBR: "pt-BR",
+  PTPT: "pt-PT",
+  DaDK: "da-DK",
+  RURU: "ru-RU",
+  FrCA: "fr-CA",
+  ZhCN: "zh-CN",
+  JaJP: "ja-JP",
+  KoKR: "ko-KR",
+  SvSE: "sv-SE",
+} as const;
+export type AcceptLanguage = ClosedEnum<typeof AcceptLanguage>;
 
-/**
- * The language that describes the details of a resource. Resources available in different languages may differ from each other.<li>If <code>$lang</code> is not passed, then the portal's default language is used.</li><br><br>**Important**: When using this API via SDK or MCP, use the parameter name `Dollar_lang`, not `$lang` or `lang`.
- */
 export const AcceptLanguage$zodSchema = z.enum([
   "en-US",
   "es-ES",
@@ -23,8 +40,4 @@ export const AcceptLanguage$zodSchema = z.enum([
   "ja-JP",
   "ko-KR",
   "sv-SE",
-]).describe(
-  "The language that describes the details of a resource. Resources available in different languages may differ from each other.<li>If <code>$lang</code> is not passed, then the portal's default language is used.</li><br><br>**Important**: When using this API via SDK or MCP, use the parameter name `Dollar_lang`, not `$lang` or `lang`.",
-);
-
-export type AcceptLanguage = z.infer<typeof AcceptLanguage$zodSchema>;
+]);

package/src/models/accessibleportal.ts

@@ -14,14 +14,12 @@ export type AccessiblePortal = {
   shortURL?: Array<ShortURL> | undefined;
 };
 
-export const AccessiblePortal$zodSchema: z.ZodType<
-  AccessiblePortal,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  department: Department$zodSchema.optional(),
-  description: z.string().optional(),
-  id: z.string().optional(),
-  name: z.string().optional(),
-  shortURL: z.array(ShortURL$zodSchema).optional(),
-});
+export const AccessiblePortal$zodSchema: z.ZodType<AccessiblePortal> = z.object(
+  {
+    department: Department$zodSchema.optional(),
+    description: z.string().optional(),
+    id: z.string().optional(),
+    name: z.string().optional(),
+    shortURL: z.array(ShortURL$zodSchema).optional(),
+  },
+);

package/src/models/additionalsnippets.ts

@@ -3,10 +3,24 @@
  */
 
 import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
 
 /**
  * Format of the source document (HTML, DOCX, PPTX or PDF).
  */
+export const AdditionalSnippetsDocType = {
+  Html: "HTML",
+  Docx: "DOCX",
+  Pdf: "PDF",
+  Pptx: "PPTX",
+} as const;
+/**
+ * Format of the source document (HTML, DOCX, PPTX or PDF).
+ */
+export type AdditionalSnippetsDocType = ClosedEnum<
+  typeof AdditionalSnippetsDocType
+>;
+
 export const AdditionalSnippetsDocType$zodSchema = z.enum([
   "HTML",
   "DOCX",
@@ -14,10 +28,6 @@ export const AdditionalSnippetsDocType$zodSchema = z.enum([
   "PPTX",
 ]).describe("Format of the source document (HTML, DOCX, PPTX or PDF).");
 
-export type AdditionalSnippetsDocType = z.infer<
-  typeof AdditionalSnippetsDocType$zodSchema
->;
-
 export type AdditionalSnippets = {
   id: string;
   name: string;
@@ -29,17 +39,14 @@ export type AdditionalSnippets = {
   normalizedScore?: number | undefined;
 };
 
-export const AdditionalSnippets$zodSchema: z.ZodType<
-  AdditionalSnippets,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  docName: z.string().optional(),
-  docType: AdditionalSnippetsDocType$zodSchema,
-  id: z.string(),
-  keywordSnippet: z.string().optional(),
-  name: z.string(),
-  normalizedScore: z.number().optional(),
-  relevanceScore: z.number().optional(),
-  snippet: z.string(),
-});
+export const AdditionalSnippets$zodSchema: z.ZodType<AdditionalSnippets> = z
+  .object({
+    docName: z.string().optional(),
+    docType: AdditionalSnippetsDocType$zodSchema,
+    id: z.string(),
+    keywordSnippet: z.string().optional(),
+    name: z.string(),
+    normalizedScore: z.number().optional(),
+    relevanceScore: z.number().optional(),
+    snippet: z.string(),
+  });

package/src/models/aisearchop.ts

@@ -17,7 +17,7 @@ export type AiSearchRequest = {
   q: string;
   portalID: string;
   dollarFilterUserProfileID?: string | undefined;
-  Dollar_lang?: LanguageCodeParameter | undefined;
+  Dollar_lang: LanguageCodeParameter;
   dollarFilterTags?: { [k: string]: Array<string> } | undefined;
   dollarFilterTopicIds?: Array<string> | undefined;
   articleCustomAdditionalAttributes?: string | undefined;
@@ -25,37 +25,25 @@ export type AiSearchRequest = {
   Dollar_pagesize?: number | undefined;
 };
 
-export const AiSearchRequest$zodSchema: z.ZodType<
-  AiSearchRequest,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  Dollar_lang: LanguageCodeParameter$zodSchema.default("en-US"),
-  Dollar_pagenum: z.number().int().default(1).describe(
+export const AiSearchRequest$zodSchema: z.ZodType<AiSearchRequest> = z.object({
+  Dollar_lang: LanguageCodeParameter$zodSchema,
+  Dollar_pagenum: z.int().default(1).describe(
     "Pagination parameter that specifies the page number of results to be returned. Used in conjunction with $pagesize.",
   ),
-  Dollar_pagesize: z.number().int().default(20).describe(
+  Dollar_pagesize: z.int().default(20).describe(
     "Pagination parameter that specifies the number of results per page. Used in conjunction with $pagenum.",
   ),
   articleCustomAdditionalAttributes: z.string().describe(
     "One or more comma-separated names for article custom attributes defined by the user to be returned.",
   ).optional(),
-  dollarFilterTags: z.record(z.array(z.string())).describe(
-    "An object where each key is a **Category Tag ID** (numeric string),  \n"
-      + "and each value is an array of **Tag IDs** for that category.\n"
-      + " **Note**:\n"
-      + "  - The '$filter[tags]' query parameter JSON value should be url encoded.\n"
-      + "  - Some developer tools for invoking APIs may not url encode the '$filter[tags]' query parameter JSON value by default. Ensure that only url encoded values are used.\n"
-      + "  - Example of JSON value: {\"BASE-40845\":[\"BASE-40849\",\"BASE-40853\"]}\n"
-      + "  - Example of URL encoded value: %7B%22BASE-40845%22%3A%5B%22BASE-40849%22%2C%22BASE-40853%22%5D%7D\n"
-      + "",
+  dollarFilterTags: z.record(z.string(), z.array(z.string())).describe(
+    "An object where each key is a **Category Tag ID** (numeric string),  \nand each value is an array of **Tag IDs** for that category.\n **Note**:\n  - The '$filter[tags]' query parameter JSON value should be url encoded.\n  - Some developer tools for invoking APIs may not url encode the '$filter[tags]' query parameter JSON value by default. Ensure that only url encoded values are used.\n  - Example of JSON value: {\"BASE-40845\":[\"BASE-40849\",\"BASE-40853\"]}\n  - Example of URL encoded value: %7B%22BASE-40845%22%3A%5B%22BASE-40849%22%2C%22BASE-40853%22%5D%7D\n",
   ).optional(),
   dollarFilterTopicIds: z.array(z.string()).describe(
     "An array of topic IDs. It is used to restrict search results to specific topics.",
   ).optional(),
   dollarFilterUserProfileID: z.string().describe(
-    "The ID of the user profile. \n"
-      + "",
+    "The ID of the user profile. \n",
   ).optional(),
   portalID: z.string().describe(
     "The ID of the portal being accessed.<br><br>A portal ID is composed of a 2-4 letter prefix, followed by a dash and 4-15 digits.",
@@ -65,22 +53,11 @@ export const AiSearchRequest$zodSchema: z.ZodType<
   ),
 });
 
-export type AiSearchResponseResponse = {
-  ContentType: string;
-  StatusCode: number;
-  RawResponse: Response;
-  AISearchResponse?: AISearchResponse | undefined;
-  WSErrorCommon?: WSErrorCommon | undefined;
-};
+export type AiSearchResponseResponse = WSErrorCommon | AISearchResponse;
 
 export const AiSearchResponseResponse$zodSchema: z.ZodType<
-  AiSearchResponseResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  AISearchResponse: AISearchResponse$zodSchema.optional(),
-  ContentType: z.string(),
-  RawResponse: z.instanceof(Response),
-  StatusCode: z.number().int(),
-  WSErrorCommon: WSErrorCommon$zodSchema.optional(),
-});
+  AiSearchResponseResponse
+> = z.union([
+  WSErrorCommon$zodSchema,
+  AISearchResponse$zodSchema,
+]);

package/src/models/aisearchresponse.ts

@@ -19,11 +19,7 @@ export type SearchResults = {
   article?: Array<ArticleAISearchResult> | undefined;
 };
 
-export const SearchResults$zodSchema: z.ZodType<
-  SearchResults,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
+export const SearchResults$zodSchema: z.ZodType<SearchResults> = z.object({
   article: z.array(ArticleAISearchResult$zodSchema).optional(),
 }).describe("Top search results with relevance scores");
 
@@ -32,11 +28,9 @@ export type AISearchResponse = {
   paginationInfo?: AISPaginationInfo | undefined;
 };
 
-export const AISearchResponse$zodSchema: z.ZodType<
-  AISearchResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  paginationInfo: AISPaginationInfo$zodSchema.optional(),
-  searchResults: z.lazy(() => SearchResults$zodSchema),
-});
+export const AISearchResponse$zodSchema: z.ZodType<AISearchResponse> = z.object(
+  {
+    paginationInfo: AISPaginationInfo$zodSchema.optional(),
+    searchResults: z.lazy(() => SearchResults$zodSchema),
+  },
+);

package/src/models/aispaginationinfo.ts

@@ -12,13 +12,10 @@ export type AISPaginationInfo = {
   link?: Array<Link> | undefined;
 };
 
-export const AISPaginationInfo$zodSchema: z.ZodType<
-  AISPaginationInfo,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  count: z.number().int().default(1),
-  link: z.array(Link$zodSchema).optional(),
-  pagenum: z.number().int().default(1),
-  pagesize: z.number().int().default(20),
-});
+export const AISPaginationInfo$zodSchema: z.ZodType<AISPaginationInfo> = z
+  .object({
+    count: z.int().default(1),
+    link: z.array(Link$zodSchema).optional(),
+    pagenum: z.int().default(1),
+    pagesize: z.int().default(20),
+  });

package/src/models/aitopicbreadcrumb.ts

@@ -12,10 +12,7 @@ export type AITopicBreadcrumb = {
   topicSummary?: Array<AITopicSummary> | undefined;
 };
 
-export const AITopicBreadcrumb$zodSchema: z.ZodType<
-  AITopicBreadcrumb,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  topicSummary: z.array(AITopicSummary$zodSchema).optional(),
-}).describe("This schema contains one or more TopicSummary instances.");
+export const AITopicBreadcrumb$zodSchema: z.ZodType<AITopicBreadcrumb> = z
+  .object({
+    topicSummary: z.array(AITopicSummary$zodSchema).optional(),
+  }).describe("This schema contains one or more TopicSummary instances.");