mongodb-mcp-server 2.1.0 → 3.0.0-prerelease.2

package/dist/cjs/tools/tool.d.ts

@@ -1,643 +0,0 @@
-import { z, type ZodRawShape } from "zod";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { CallToolResult, RequestId, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
-import type { Session } from "../common/session.js";
-import type { AnyConnectionState } from "../common/connectionManager.js";
-import type { Telemetry } from "../telemetry/telemetry.js";
-import type { ConnectionMetadata, TelemetryToolMetadata } from "../telemetry/types.js";
-import type { UserConfig } from "../common/config/userConfig.js";
-import type { Server } from "../server.js";
-import type { Elicitation } from "../elicitation.js";
-import type { PreviewFeature } from "../common/schemas.js";
-import type { UIRegistry } from "../ui/registry/index.js";
-import type { Metrics, DefaultMetrics } from "@mongodb-js/mcp-metrics";
-export type ToolArgs<T extends ZodRawShape> = {
-    [K in keyof T]: z.infer<T[K]>;
-};
-export type ToolOutput<T extends ZodRawShape> = {
-    [K in keyof T]?: z.infer<T[K]>;
-};
-type ServerRequestHandlerExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
-/**
- * The subset of the SDK's request handler context that tools rely on, picked
- * from `RequestHandlerExtra` so the field types always match the SDK's.
- *
- * `signal` is always present. The remaining fields are populated by the MCP
- * SDK when the tool is invoked by the server, but may be absent when `invoke`
- * is called manually; `requestInfo` is additionally only available when
- * running atop StreamableHttpTransport.
- */
-export type ToolExecutionContext = Pick<ServerRequestHandlerExtra, "signal"> & Partial<Pick<ServerRequestHandlerExtra, "_meta" | "requestId" | "requestInfo" | "sendNotification">> & {
-    /**
-     * Total time spent waiting for the user to answer elicitation requests
-     * raised while handling this call. Accumulated by
-     * `ToolBase.requestConfirmation` and subtracted from the tool execution
-     * duration metric, so that the user's think-time is not reported as
-     * time the tool spent working.
-     */
-    elicitationDurationMs?: number;
-};
-export type ToolResult<OutputSchema extends ZodRawShape | undefined = undefined> = OutputSchema extends ZodRawShape ? StructuredToolResult<OutputSchema> : {
-    content: CallToolResult["content"];
-    isError?: boolean;
-};
-type StructuredToolResult<OutputSchema extends ZodRawShape> = {
-    content: CallToolResult["content"];
-    isError?: boolean;
-    structuredContent: z.infer<z.ZodObject<OutputSchema>>;
-};
-/**
- * The type of operation the tool performs. This is used when evaluating if a tool is allowed to run based on
- * the config's `disabledTools` and `readOnly` settings.
- * - `metadata` is used for tools that read but do not access potentially user-generated
- *   data, such as listing databases, collections, or indexes, or inferring collection schema.
- * - `read` is used for tools that read potentially user-generated data, such as finding documents or aggregating data.
- *   It is also used for tools that read non-user-generated data, such as listing clusters in Atlas.
- * - `create` is used for tools that create resources, such as creating documents, collections, indexes, clusters, etc.
- * - `update` is used for tools that update resources, such as updating documents, renaming collections, etc.
- * - `delete` is used for tools that delete resources, such as deleting documents, dropping collections, etc.
- * - `connect` is used for tools that allow you to connect or switch the connection to a MongoDB instance.
- */
-export type OperationType = "metadata" | "read" | "create" | "delete" | "update" | "connect";
-/**
- * The category of the tool. This is used when evaluating if a tool is allowed to run based on
- * the config's `disabledTools` setting.
- * - `mongodb` is used for tools that interact with a MongoDB instance, such as finding documents,
- *   aggregating data, listing databases/collections/indexes, creating indexes, etc.
- * - `atlas` is used for tools that interact with MongoDB Atlas, such as listing clusters, creating clusters, etc.
- * - `atlas-local` is used for tools that interact with local Atlas deployments.
- * - `assistant` is used for tools that interact with the Assistant, such as searching the public knowledge base.
- */
-export type ToolCategory = "mongodb" | "atlas" | "atlas-local" | "assistant";
-/**
- * Parameters passed to the constructor of all tools that extends `ToolBase`.
- *
- * The MongoDB MCP Server automatically injects these parameters when
- * constructing tools and registering to the MCP Server.
- *
- * See `Server.registerTools` method in `src/server.ts` for further reference.
- */
-export type ToolConstructorParams<TUserConfig extends UserConfig = UserConfig, TContext = unknown, TMetrics extends DefaultMetrics = DefaultMetrics> = {
-    /**
-     * The unique name of this tool (injected from the static
-     * `toolName` property on the Tool class).
-     */
-    name: string;
-    /**
-     * The category that the tool belongs to (injected from the static
-     * `category` property on the Tool class).
-     */
-    category: ToolCategory;
-    /**
-     * The type of operation the tool performs (injected from the static
-     * `operationType` property on the Tool class).
-     */
-    operationType: OperationType;
-    /**
-     * An instance of Session class providing access to MongoDB connections,
-     * loggers, etc.
-     *
-     * See `src/common/session.ts` for further reference.
-     */
-    session: Session;
-    /**
-     * The configuration object that MCP session was started with.
-     *
-     * See `src/common/config/userConfig.ts` for further reference.
-     */
-    config: TUserConfig;
-    /**
-     * The telemetry service for tracking tool usage.
-     *
-     * See `src/telemetry/telemetry.ts` for further reference.
-     */
-    telemetry: Telemetry;
-    /**
-     * The elicitation service for requesting user confirmation.
-     *
-     * See `src/elicitation.ts` for further reference.
-     */
-    elicitation: Elicitation;
-    /**
-     * The metrics service for tracking tool usage.
-     *
-     * See `src/common/metrics/index.ts` for further reference.
-     */
-    metrics: Metrics<TMetrics>;
-    uiRegistry?: UIRegistry;
-    /**
-     * Optional custom context object that will be available to tools.
-     *
-     * Library consumers can provide custom context data that will be
-     * available during tool execution. This is useful for passing shared
-     * services used by multiple tools.
-     *
-     * @example
-     * ```typescript
-     * const runner = new StreamableHttpRunner({
-     *   userConfig: { ... },
-     *   toolContext: {
-     *     tenantId: "my-tenant",
-     *     userId: "user-123",
-     *   },
-     * });
-     * ```
-     */
-    context?: TContext;
-};
-/**
- * The type that all tool classes must conform to when implementing custom tools
- * for the MongoDB MCP Server.
- *
- * This type enforces that tool classes have static properties `toolName`, `category`,
- * and `operationType` which are injected during instantiation of tool classes.
- *
- * @example
- * ```typescript
- * import { StreamableHttpRunner, UserConfigSchema } from "mongodb-mcp-server"
- * import { ToolBase, type ToolClass, type ToolCategory, type OperationType } from "mongodb-mcp-server/tools";
- * import { z } from "zod";
- *
- * class MyCustomTool extends ToolBase {
- *   // Required static properties for ToolClass conformance
- *   static toolName = "my-custom-tool";
- *   static category: ToolCategory = "mongodb";
- *   static operationType: OperationType = "read";
- *
- *   // Required abstract properties
- *   public description = "My custom tool description";
- *   public argsShape = {
- *     query: z.string().describe("The query parameter"),
- *   };
- *
- *   // Required abstract method: implement the tool's logic
- *   protected async execute(args) {
- *     // Tool implementation
- *     return {
- *       content: [{ type: "text", text: "Result" }],
- *     };
- *   }
- *
- *   // Required abstract method: provide telemetry metadata
- *   protected resolveTelemetryMetadata() {
- *     return {}; // Return empty object if no custom telemetry needed
- *   }
- * }
- *
- * const runner = new StreamableHttpRunner({
- *   userConfig: UserConfigSchema.parse({}),
- *   // This will work only if the class correctly conforms to ToolClass type, which in our case it does.
- *   tools: [MyCustomTool],
- * });
- * ```
- */
-export type ToolClass<TUserConfig extends UserConfig = UserConfig, TContext = unknown, TMetrics extends DefaultMetrics = DefaultMetrics> = {
-    /** Constructor signature for the tool class */
-    new (params: ToolConstructorParams<TUserConfig, TContext, TMetrics>): ToolBase<TUserConfig, TContext, TMetrics>;
-    /**
-     * The unique name of this tool.
-     *
-     * Must be unique across all tools in the server.
-     */
-    toolName: string;
-    /** The category that the tool belongs to */
-    category: ToolCategory;
-    /** The type of operation the tool performs */
-    operationType: OperationType;
-};
-/**
- * Abstract base class for implementing MCP tools in the MongoDB MCP Server.
- *
- * All tools (both internal and custom) must extend this class to ensure a
- * consistent interface and proper integration with the server.
- *
- * ## Creating a Custom Tool
- *
- * To create a custom tool, you must:
- * 1. Extend the `ToolBase` class
- * 2. Define static properties: `toolName`, `category`, and `operationType`
- * 3. Implement required abstract members: `description`, `argsShape`,
- *    `execute()`, `resolveTelemetryMetadata()`
- *
- * @example Basic Custom Tool
- * ```typescript
- * import { StreamableHttpRunner, UserConfigSchema } from "mongodb-mcp-server"
- * import { ToolBase, type ToolClass, type ToolCategory, type OperationType } from "mongodb-mcp-server/tools";
- * import { z } from "zod";
- *
- * class MyCustomTool extends ToolBase {
- *   // Required static properties for ToolClass conformance
- *   static toolName = "my-custom-tool";
- *   static category: ToolCategory = "mongodb";
- *   static operationType: OperationType = "read";
- *
- *   // Required abstract properties
- *   public description = "My custom tool description";
- *   public argsShape = {
- *     query: z.string().describe("The query parameter"),
- *   };
- *
- *   // Required abstract method: implement the tool's logic
- *   protected async execute(args) {
- *     // Tool implementation
- *     return {
- *       content: [{ type: "text", text: "Result" }],
- *     };
- *   }
- *
- *   // Required abstract method: provide telemetry metadata
- *   protected resolveTelemetryMetadata() {
- *     return {}; // Return empty object if no custom telemetry needed
- *   }
- * }
- *
- * const runner = new StreamableHttpRunner({
- *   userConfig: UserConfigSchema.parse({}),
- *   // This will work only if the class correctly conforms to ToolClass type, which in our case it does.
- *   tools: [MyCustomTool],
- * });
- * ```
- *
- * ## Protected Members Available to Subclasses
- *
- * - `session` - Access to MongoDB connection, logger, and other session
- *   resources
- * - `config` - Server configuration (`UserConfig`)
- * - `telemetry` - Telemetry service for tracking usage
- * - `elicitation` - Service for requesting user confirmations
- *
- * ## Instance Properties Set by Constructor
- *
- * The following properties are automatically set when the tool is instantiated
- * by the server (derived from the static properties):
- * - `name` - The tool's unique name (from static `toolName`)
- * - `category` - The tool's category (from static `category`)
- * - `operationType` - The tool's operation type (from static `operationType`)
- *
- * ## Optional Overrideable Methods
- *
- * - `getConfirmationMessage()` - Customize the confirmation prompt for tools
- *   requiring user approval
- * - `handleError()` - Customize error handling behavior
- *
- * @see {@link ToolClass} for the type that tool classes must conform to
- * @see {@link ToolConstructorParams} for the parameters passed to the
- * constructor
- */
-export declare abstract class ToolBase<TUserConfig extends UserConfig = UserConfig, TContext = unknown, TMetrics extends DefaultMetrics = DefaultMetrics> {
-    /**
-     * The unique name of this tool.
-     *
-     * Must be unique across all tools in the server.
-     */
-    readonly name: string;
-    /**
-     * The category of this tool.
-     *
-     * @see {@link ToolCategory} for the available tool categories.
-     */
-    readonly category: ToolCategory;
-    /**
-     * The type of operation this tool performs.
-     *
-     * Automatically set from the static `operationType` property during
-     * construction.
-     *
-     * @see {@link OperationType} for the available tool operations.
-     */
-    readonly operationType: OperationType;
-    /**
-     * Human-readable description of what the tool does.
-     *
-     * This is shown to the MCP client and helps the LLM understand when to use
-     * this tool.
-     */
-    abstract description: string;
-    /**
-     * Zod schema defining the tool's arguments.
-     *
-     * Use an empty object `{}` if the tool takes no arguments.
-     *
-     * @example
-     * ```typescript
-     * public argsShape = {
-     *   query: z.string().describe("The search query"),
-     *   limit: z.number().optional().describe("Maximum results to return"),
-     * };
-     * ```
-     */
-    abstract argsShape: ZodRawShape;
-    /**
-     * Optional Zod schema defining the tool's structured output.
-     *
-     * This schema is registered with the MCP server and used to validate
-     * `structuredContent` in the tool's response.
-     *
-     * @example
-     * ```typescript
-     * protected outputSchema = {
-     *   items: z.array(z.object({ name: z.string(), count: z.number() })),
-     *   totalCount: z.number(),
-     * };
-     *
-     * protected async execute(): Promise<CallToolResult> {
-     *   const items = await this.fetchItems();
-     *   return {
-     *     content: [{ type: "text", text: `Found ${items.length} items` }],
-     *     structuredContent: { items, totalCount: items.length },
-     *   };
-     * }
-     * ```
-     */
-    outputSchema?: ZodRawShape;
-    /**
-     * Normalizes the raw arguments of a tool call before they are validated against `argsShape`.
-     *
-     * Override this to keep accepting arguments that are no longer part of the tool's schema,
-     * such as a renamed argument. Arguments that are not mapped to a key of `argsShape` are
-     * rejected by the schema validation that follows.
-     *
-     * @example
-     * ```typescript
-     * public override normalizeRawArgs(args: Record<string, unknown>): Record<string, unknown> {
-     *   const { limit, ...rest } = args;
-     *   return limit === undefined ? args : { ...rest, maxResults: limit };
-     * }
-     * ```
-     */
-    normalizeRawArgs(args: Record<string, unknown>): Record<string, unknown>;
-    private registeredTool;
-    get annotations(): ToolAnnotations;
-    /**
-     * Returns tool-specific metadata that will be included in the tool's `_meta` field.
-     *
-     * This getter computes metadata based on the current configuration, including
-     * transport-specific constraints like request payload size limits.
-     *
-     * The metadata includes:
-     * - `com.mongodb/transport`: The transport protocol in use ("stdio" or "http")
-     * - `com.mongodb/maxRequestPayloadBytes`: Maximum request payload size for the current transport
-     *
-     * Subclasses can override this to add custom metadata. When overriding,
-     * call `super.toolMeta` and spread its result to preserve base metadata.
-     *
-     * @example
-     * ```typescript
-     * protected override get toolMeta(): Record<string, unknown> {
-     *   return {
-     *     ...super.toolMeta,
-     *     "com.mongodb/customField": "value",
-     *   };
-     * }
-     * ```
-     */
-    protected get toolMeta(): Record<string, unknown>;
-    /**
-     * A function that is registered as the tool execution callback and is
-     * called with the expected arguments.
-     *
-     * This is the core implementation of your tool's functionality. It receives
-     * validated arguments (validated against `argsShape`) and must return a
-     * result conforming to the MCP protocol.
-     *
-     * @param args - The validated arguments passed to the tool
-     * @param context - The execution context containing signal and optional request info
-     * @returns A promise resolving to the tool execution result
-     *
-     * @example
-     * ```typescript
-     * protected async execute(args: { query: string }, context): Promise<CallToolResult> {
-     *   const results = await this.session.db.collection('items').find({
-     *     name: { $regex: args.query, $options: 'i' }
-     *   }).toArray();
-     *
-     *   return {
-     *     content: [{
-     *       type: "text",
-     *       text: JSON.stringify(results),
-     *     }],
-     *   };
-     * }
-     * ```
-     */
-    protected abstract execute(args: ToolArgs<typeof this.argsShape>, context: ToolExecutionContext): Promise<CallToolResult>;
-    /** This is used internally by the server to invoke the tool. It can also be run manually to call the tool directly. */
-    invoke(args: ToolArgs<typeof this.argsShape>, context: ToolExecutionContext): Promise<CallToolResult>;
-    /**
-     * Get the confirmation message shown to users when this tool requires
-     * explicit approval.
-     *
-     * Override this method to provide a more specific and helpful confirmation
-     * message based on the tool's arguments.
-     *
-     * @param args - The tool arguments
-     * @returns The confirmation message to display to the user
-     *
-     * @example
-     * ```typescript
-     * protected getConfirmationMessage(args: { database: string }): string {
-     *   return `You are about to delete the database "${args.database}". This action cannot be undone. Proceed?`;
-     * }
-     * ```
-     */
-    protected getConfirmationMessage(args: ToolArgs<typeof this.argsShape>): string;
-    /** Checks if the tool requires elicitation */
-    requiresConfirmation(): boolean;
-    /**
-     * Asks the user to confirm an operation, resolving to `true` when they
-     * accept and `false` when they decline.
-     *
-     * This is automatically called by `invoke` for confirmationRequired tools.
-     * Other tools can call it at any point of their execution, which matters when
-     * the decision depends on the arguments or needs to happen after some preliminary work.
-     *
-     * Resolves to `true` without prompting when the client does not support
-     * elicitation, matching how confirmation-required tools behave there.
-     *
-     * @param message - The message to display to the user.
-     * @param context - The tool execution context, used to relate the
-     * confirmation request to the in-flight tool call and to record how long the
-     * user took to answer.
-     */
-    protected requestConfirmation(message: string, context: ToolExecutionContext): Promise<boolean>;
-    /**
-     * Resolves the request id that elicitation requests should be related to.
-     *
-     * Relating the elicitation to the in-flight tool call routes it over that
-     * call's own SSE stream, which also works for deployments that don't
-     * support standalone GET streams. In JSON response mode the in-flight POST
-     * cannot carry server->client messages at all, so the elicitation must
-     * keep using the standalone stream.
-     */
-    protected elicitationRelatedRequestId(context: ToolExecutionContext): RequestId | undefined;
-    /**
-     * Access to the session instance. Provides access to MongoDB connections,
-     * loggers, connection manager, and other session-level resources.
-     */
-    protected readonly session: Session;
-    /**
-     * Access to the server configuration. Contains all user configuration
-     * settings including connection strings, feature flags, and operational
-     * limits.
-     */
-    protected readonly config: TUserConfig;
-    /**
-     * Access to the telemetry service. Use this to emit custom telemetry events
-     * if needed.
-     */
-    protected readonly telemetry: Telemetry;
-    /**
-     * Access to the elicitation service. Use this to request user confirmations
-     * or inputs during tool execution.
-     */
-    protected readonly elicitation: Elicitation;
-    /**
-     * Access to the metrics service. Use this to emit custom metrics events
-     * if needed.
-     */
-    protected readonly metrics: Metrics<TMetrics>;
-    private readonly uiRegistry?;
-    /**
-     * Optional custom context object provided during tool construction.
-     *
-     * Library consumers can use this for passing shared services used by multiple tools.
-     *
-     * @example
-     * ```typescript
-     * class MyTool extends ToolBase {
-     *   protected async execute(args, { authService }) {
-     *     // Access custom context
-     *     const user = await authService.getUser();
-     *     // ...
-     *   }
-     * }
-     * ```
-     */
-    protected readonly context?: TContext;
-    constructor({ name, category, operationType, session, config, telemetry, elicitation, metrics, uiRegistry, context, }: ToolConstructorParams<TUserConfig, TContext, TMetrics>);
-    /**
-     * Schemas are session-invariant, so they are built once per concrete tool
-     * class and config variant, then shared across every session. Both caches
-     * are keyed by the concrete constructor; the input cache is additionally
-     * keyed by `schemaVariantKey()` to separate config-dependent variants.
-     */
-    private static readonly sharedInputSchemas;
-    private static readonly sharedOutputSchemas;
-    /**
-     * Identifies config-dependent variations of a tool's `argsShape`. Tools that
-     * vary their shape by config override this so each variant is cached and
-     * shared separately. The default reports no variation.
-     */
-    protected schemaVariantKey(): string;
-    /**
-     * Returns the shared strict input schema for this tool's config variant,
-     * building it once. Also redirects this instance's `argsShape` to the shared
-     * shape so its own per-instance graph becomes collectible.
-     */
-    private resolveSharedInputSchema;
-    /**
-     * Points a class-field schema property at the shared shape so the instance's
-     * own graph becomes collectible. Getter-based tools recompute their shape
-     * transiently and hold nothing to release, so they are left untouched.
-     */
-    private redirectToSharedShape;
-    /**
-     * Returns the shared output schema for this tool, building it once. Output
-     * schemas do not vary by config. Redirects this instance's `outputSchema` to
-     * the shared shape so its own per-instance graph becomes collectible.
-     */
-    private resolveSharedOutputSchema;
-    register(server: Server<TUserConfig, TContext, TMetrics>): boolean;
-    isEnabled(): boolean;
-    disable(): void;
-    enable(): void;
-    protected verifyAllowed(): boolean;
-    /**
-     * Handle errors that occur during tool execution.
-     *
-     * Override this method to provide custom error handling logic. The default
-     * implementation returns a simple error message.
-     *
-     * @param error - The error that was thrown
-     * @param args - The arguments that were passed to the tool
-     * @returns A CallToolResult with error information
-     *
-     * @example
-     * ```typescript
-     * protected handleError(error: unknown, args: { query: string }): CallToolResult {
-     *   if (error instanceof MongoError && error.code === 11000) {
-     *     return {
-     *       content: [{
-     *         type: "text",
-     *         text: `Duplicate key error for query: ${args.query}`,
-     *       }],
-     *       isError: true,
-     *     };
-     *   }
-     *   // Fall back to default error handling
-     *   return super.handleError(error, args);
-     * }
-     * ```
-     */
-    protected handleError(error: unknown, args: z.infer<z.ZodObject<typeof this.argsShape>>): Promise<CallToolResult> | CallToolResult;
-    /**
-     * Resolve telemetry metadata for this tool execution.
-     *
-     * This method is called after every tool execution to collect metadata for
-     * telemetry events. Return an object with custom properties you want to
-     * track, or an empty object if no custom telemetry is needed.
-     *
-     * @param result - The result of the tool execution
-     * @param args - The arguments and context passed to the tool
-     * @returns An object containing telemetry metadata
-     *
-     * @example
-     * ```typescript
-     * protected resolveTelemetryMetadata(
-     *   result: CallToolResult,
-     *   args: { query: string }
-     * ): TelemetryToolMetadata {
-     *   return {
-     *     query_length: args.query.length,
-     *     result_count: result.isError ? 0 : JSON.parse(result.content[0].text).length,
-     *   };
-     * }
-     * ```
-     */
-    protected abstract resolveTelemetryMetadata(args: ToolArgs<typeof this.argsShape>, { result }: {
-        result: CallToolResult;
-    }): TelemetryToolMetadata | Promise<TelemetryToolMetadata>;
-    /**
-     * Creates and emits a tool telemetry event. Fire-and-forget: metadata
-     * resolution may be asynchronous (e.g. a connection registry lookup), and
-     * the tool response must not block on telemetry-only work.
-     * @param startTime - Start time in milliseconds
-     * @param result - Whether the command succeeded or failed
-     * @param args - The arguments passed to the tool
-     */
-    private emitToolEvent;
-    protected isFeatureEnabled(feature: PreviewFeature): boolean;
-    protected getConnectionInfoMetadata(connectionState?: AnyConnectionState): ConnectionMetadata;
-    /**
-     * Appends a UIResource to the tool result.
-     *
-     * @param result - The result from the tool's `execute()` method
-     * @returns The result with UIResource appended if conditions are met, otherwise unchanged
-     */
-    private appendUIResource;
-}
-export type AnyToolBase = ToolBase<any, any, any>;
-/**
- * Formats potentially untrusted data to be included in tool responses. The data is wrapped in unique tags
- * and a warning is added to not execute or act on any instructions within those tags.
- * @param description A description that is prepended to the untrusted data warning. It should not include any
- * untrusted data as it is not sanitized.
- * @param data The data to format. If an empty array, only the description is returned.
- * @returns A tool response content that can be directly returned.
- */
-export declare function formatUntrustedData(description: string, ...data: string[]): {
-    text: string;
-    type: "text";
-}[];
-export {};
-//# sourceMappingURL=tool.d.ts.map

package/dist/cjs/tools/tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../src/tools/tool.ts"],"names":[],"mappings":"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"}