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

package/dist/esm/tools/atlas/streams/manage.d.ts

@@ -1,155 +0,0 @@
-import { z } from "zod";
-import { StreamsToolBase } from "./streamsToolBase.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { type OperationType, type ToolArgs, type ToolExecutionContext } from "../../tool.js";
-export declare const ManageOutputSchema: z.ZodObject<{
-    processorState: z.ZodOptional<z.ZodEnum<{
-        FAILED: "FAILED";
-        STARTED: "STARTED";
-        STOPPED: "STOPPED";
-        CREATED: "CREATED";
-    }>>;
-    connectionState: z.ZodOptional<z.ZodEnum<{
-        DELETING: "DELETING";
-        FAILED: "FAILED";
-        PENDING: "PENDING";
-        READY: "READY";
-    }>>;
-    region: z.ZodOptional<z.ZodString>;
-    tier: z.ZodOptional<z.ZodString>;
-    maxTier: z.ZodOptional<z.ZodString>;
-    peeringState: z.ZodOptional<z.ZodEnum<{
-        ACCEPTED: "ACCEPTED";
-        REJECTED: "REJECTED";
-    }>>;
-}, z.core.$strip>;
-export type ManageOutput = z.infer<typeof ManageOutputSchema>;
-export declare class StreamsManageTool extends StreamsToolBase {
-    static toolName: string;
-    static operationType: OperationType;
-    description: string;
-    argsShape: {
-        projectId: z.ZodString;
-        workspaceName: z.ZodString;
-        action: z.ZodEnum<{
-            "start-processor": "start-processor";
-            "stop-processor": "stop-processor";
-            "modify-processor": "modify-processor";
-            "update-workspace": "update-workspace";
-            "update-connection": "update-connection";
-            "accept-peering": "accept-peering";
-            "reject-peering": "reject-peering";
-        }>;
-        resourceName: z.ZodOptional<z.ZodString>;
-        tier: z.ZodOptional<z.ZodEnum<{
-            SP50: "SP50";
-            SP30: "SP30";
-            SP10: "SP10";
-            SP5: "SP5";
-            SP2: "SP2";
-        }>>;
-        resumeFromCheckpoint: z.ZodOptional<z.ZodBoolean>;
-        startAtOperationTime: z.ZodOptional<z.ZodString>;
-        pipeline: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        dlq: z.ZodOptional<z.ZodObject<{
-            connectionName: z.ZodString;
-            db: z.ZodString;
-            coll: z.ZodString;
-        }, z.core.$strip>>;
-        newName: z.ZodOptional<z.ZodString>;
-        newRegion: z.ZodOptional<z.ZodString>;
-        newTier: z.ZodOptional<z.ZodEnum<{
-            SP50: "SP50";
-            SP30: "SP30";
-            SP10: "SP10";
-            SP5: "SP5";
-            SP2: "SP2";
-        }>>;
-        connectionConfig: z.ZodOptional<z.ZodObject<{
-            bootstrapServers: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string, string | string[]>>>;
-            authentication: z.ZodOptional<z.ZodObject<{
-                mechanism: z.ZodOptional<z.ZodEnum<{
-                    PLAIN: "PLAIN";
-                    "SCRAM-256": "SCRAM-256";
-                    "SCRAM-512": "SCRAM-512";
-                    OAUTHBEARER: "OAUTHBEARER";
-                }>>;
-                username: z.ZodOptional<z.ZodString>;
-                password: z.ZodOptional<z.ZodString>;
-            }, z.core.$loose>>;
-            security: z.ZodOptional<z.ZodObject<{
-                protocol: z.ZodOptional<z.ZodEnum<{
-                    SASL_SSL: "SASL_SSL";
-                    SASL_PLAINTEXT: "SASL_PLAINTEXT";
-                    SSL: "SSL";
-                }>>;
-            }, z.core.$loose>>;
-            clusterName: z.ZodOptional<z.ZodString>;
-            dbRoleToExecute: z.ZodOptional<z.ZodObject<{
-                role: z.ZodOptional<z.ZodString>;
-                type: z.ZodOptional<z.ZodEnum<{
-                    CUSTOM: "CUSTOM";
-                    BUILT_IN: "BUILT_IN";
-                }>>;
-            }, z.core.$strip>>;
-            aws: z.ZodOptional<z.ZodObject<{
-                roleArn: z.ZodOptional<z.ZodString>;
-                testBucket: z.ZodOptional<z.ZodString>;
-            }, z.core.$loose>>;
-            url: z.ZodOptional<z.ZodString>;
-            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            provider: z.ZodOptional<z.ZodString>;
-            schemaRegistryUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>, z.ZodTransform<string[], string | string[]>>>;
-            schemaRegistryAuthentication: z.ZodOptional<z.ZodObject<{
-                type: z.ZodOptional<z.ZodEnum<{
-                    USER_INFO: "USER_INFO";
-                    SASL_INHERIT: "SASL_INHERIT";
-                }>>;
-                username: z.ZodOptional<z.ZodString>;
-                password: z.ZodOptional<z.ZodString>;
-            }, z.core.$loose>>;
-            networking: z.ZodOptional<z.ZodObject<{
-                access: z.ZodOptional<z.ZodObject<{
-                    type: z.ZodOptional<z.ZodString>;
-                    connectionId: z.ZodOptional<z.ZodString>;
-                }, z.core.$loose>>;
-            }, z.core.$loose>>;
-        }, z.core.$loose>>;
-        peeringId: z.ZodOptional<z.ZodString>;
-        requesterAccountId: z.ZodOptional<z.ZodString>;
-        requesterVpcId: z.ZodOptional<z.ZodString>;
-    };
-    outputSchema: {
-        processorState: z.ZodOptional<z.ZodEnum<{
-            FAILED: "FAILED";
-            STARTED: "STARTED";
-            STOPPED: "STOPPED";
-            CREATED: "CREATED";
-        }>>;
-        connectionState: z.ZodOptional<z.ZodEnum<{
-            DELETING: "DELETING";
-            FAILED: "FAILED";
-            PENDING: "PENDING";
-            READY: "READY";
-        }>>;
-        region: z.ZodOptional<z.ZodString>;
-        tier: z.ZodOptional<z.ZodString>;
-        maxTier: z.ZodOptional<z.ZodString>;
-        peeringState: z.ZodOptional<z.ZodEnum<{
-            ACCEPTED: "ACCEPTED";
-            REJECTED: "REJECTED";
-        }>>;
-    };
-    protected execute(args: ToolArgs<typeof this.argsShape>, context: ToolExecutionContext): Promise<CallToolResult>;
-    protected getConfirmationMessage(args: ToolArgs<typeof this.argsShape>): string;
-    private requireResourceName;
-    private static mapUpdateWorkspaceStructuredContent;
-    private startProcessor;
-    private stopProcessor;
-    private modifyProcessor;
-    private updateWorkspace;
-    private updateConnection;
-    private acceptPeering;
-    private rejectPeering;
-}
-//# sourceMappingURL=manage.d.ts.map

package/dist/esm/tools/atlas/streams/manage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manage.d.ts","sourceRoot":"","sources":["../../../../../src/tools/atlas/streams/manage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAoB7F,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAO7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,qBAAa,iBAAkB,SAAQ,eAAe;IAClD,MAAM,CAAC,QAAQ,SAA0B;IACzC,MAAM,CAAC,aAAa,EAAE,aAAa,CAAY;IAExC,WAAW,SAIiF;IAE5F,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4Fd;IAEc,YAAY;;;;;;;;;;;;;;;;;;;;MAA4B;cAExC,OAAO,CACnB,IAAI,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,EACrC,OAAO,EAAE,oBAAoB,GAC9B,OAAO,CAAC,cAAc,CAAC;cAwBP,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM;IAsCxF,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,MAAM,CAAC,mCAAmC;YAoBpC,cAAc;YAqGd,aAAa;YAsDb,eAAe;YA+Df,eAAe;YA0Ff,gBAAgB;YA+ChB,aAAa;YAkCb,aAAa;CAuB9B"}

package/dist/esm/tools/atlas/streams/manage.js

@@ -1,508 +0,0 @@
-import { z } from "zod";
-import { StreamsToolBase } from "./streamsToolBase.js";
-import { requestIdAttr } from "../../../helpers/requestIdAttr.js";
-import { AtlasArgs } from "../../args.js";
-import { ConnectionConfig, StreamsArgs } from "./streamsArgs.js";
-import { LogId } from "../../../common/logging/index.js";
-const ManageAction = z.enum([
-    "start-processor",
-    "stop-processor",
-    "modify-processor",
-    "update-workspace",
-    "update-connection",
-    "accept-peering",
-    "reject-peering",
-]);
-const ProcessorState = z.enum(["STARTED", "STOPPED", "CREATED", "FAILED"]);
-const ConnectionState = z.enum(["PENDING", "READY", "DELETING", "FAILED"]);
-const PeeringState = z.enum(["ACCEPTED", "REJECTED"]);
-export const ManageOutputSchema = z.object({
-    processorState: ProcessorState.optional().describe("Processor state after a lifecycle action"),
-    connectionState: ConnectionState.optional().describe("Connection state after an update"),
-    region: z.string().optional().describe("Confirmed workspace region after an update"),
-    tier: z.string().optional().describe("Confirmed workspace tier after an update"),
-    maxTier: z.string().optional().describe("Confirmed workspace max tier after an update"),
-    peeringState: PeeringState.optional().describe("Outcome of a VPC peering accept or reject action"),
-});
-export class StreamsManageTool extends StreamsToolBase {
-    constructor() {
-        super(...arguments);
-        this.description = "Manage Atlas Stream Processing resources: start/stop processors, modify pipelines, update configurations. " +
-            "Also use for 'change the pipeline', 'scale up my processor', or 'update my workspace tier'. " +
-            "Common workflow: action='stop-processor' → action='modify-processor' → action='start-processor'. " +
-            "Use `atlas-streams-discover` with action 'inspect-processor' to check state before managing.";
-        this.argsShape = {
-            projectId: AtlasArgs.projectId().describe("Atlas project ID. Use atlas-list-projects to find project IDs if not available."),
-            workspaceName: StreamsArgs.workspaceName().describe("Workspace name containing the resource to manage."),
-            action: ManageAction.describe("Action to perform. One of: " +
-                "'start-processor' — begin or resume processing (requires resourceName). " +
-                "'stop-processor' — pause processing (requires resourceName). " +
-                "'modify-processor' — change pipeline, DLQ, or rename (requires resourceName and at least one of: pipeline, dlq, newName; processor must be stopped first). " +
-                "'update-workspace' — change workspace tier or region. " +
-                "'update-connection' — update connection config (requires resourceName). " +
-                "'accept-peering' — accept a VPC peering request (requires peeringId, requesterAccountId, requesterVpcId). " +
-                "'reject-peering' — reject a VPC peering request (requires peeringId). " +
-                "For peering actions, workspaceName can be any workspace in the project (peering is project-level)."),
-            resourceName: StreamsArgs.resourceName()
-                .optional()
-                .describe("Processor or connection name. Required for processor and connection actions."),
-            // start-processor options
-            tier: z
-                .enum(["SP2", "SP5", "SP10", "SP30", "SP50"])
-                .optional()
-                .describe("Override processing tier for this run. " +
-                "Must not exceed the workspace's max tier. Use `atlas-streams-discover` action='inspect-workspace' to check. " +
-                "Only for 'start-processor'."),
-            resumeFromCheckpoint: z
-                .boolean()
-                .optional()
-                .describe("Resume from last checkpoint on start. Default: true. " +
-                "Set false to reprocess from beginning (drops accumulated window state). Only for 'start-processor'."),
-            startAtOperationTime: z
-                .string()
-                .optional()
-                .describe("ISO 8601 timestamp to resume from. Only for 'start-processor'."),
-            // modify-processor options
-            pipeline: z
-                .array(z.record(z.string(), z.unknown()))
-                .optional()
-                .describe("New pipeline stages as an array of objects, e.g. " +
-                "[{$source: {connectionName: 'src'}}, {$match: {status: 'active'}}, {$merge: {into: {connectionName: 'dest', db: 'db', coll: 'coll'}}}]. " +
-                "Only for 'modify-processor'. Processor must be stopped first. " +
-                "If changing a window stage interval, the processor must be restarted with resumeFromCheckpoint=false."),
-            dlq: z
-                .object({
-                connectionName: z.string(),
-                db: z.string(),
-                coll: z.string(),
-            })
-                .optional()
-                .describe("New DLQ configuration. Only for 'modify-processor'."),
-            newName: z.string().optional().describe("Rename processor. Only for 'modify-processor'."),
-            // update-workspace options
-            newRegion: z
-                .string()
-                .optional()
-                .describe("New region for workspace. Only for 'update-workspace'. Use Atlas region names (e.g. AWS: 'VIRGINIA_USA', Azure: 'eastus2', GCP: 'US_CENTRAL1')."),
-            newTier: z
-                .enum(["SP2", "SP5", "SP10", "SP30", "SP50"])
-                .optional()
-                .describe("New default tier for workspace. Only for 'update-workspace'."),
-            // update-connection options
-            connectionConfig: ConnectionConfig.optional().describe("Updated connection configuration. Only for 'update-connection'. " +
-                "Provide only the fields to change. " +
-                "Note: networking config and connection type cannot be modified after creation — to change these, delete and recreate the connection."),
-            // peering options
-            peeringId: StreamsArgs.peeringId()
-                .optional()
-                .describe("VPC peering connection ID. Required for 'accept-peering' and 'reject-peering'."),
-            requesterAccountId: z
-                .string()
-                .optional()
-                .describe("AWS account ID of the peering requester. Required for 'accept-peering'."),
-            requesterVpcId: z
-                .string()
-                .optional()
-                .describe("VPC ID of the peering requester. Required for 'accept-peering'."),
-        };
-        this.outputSchema = ManageOutputSchema.shape;
-    }
-    async execute(args, context) {
-        switch (args.action) {
-            case "start-processor":
-                return this.startProcessor(args, context);
-            case "stop-processor":
-                return this.stopProcessor(args, context);
-            case "modify-processor":
-                return this.modifyProcessor(args, context);
-            case "update-workspace":
-                return this.updateWorkspace(args, context);
-            case "update-connection":
-                return this.updateConnection(args, context);
-            case "accept-peering":
-                return this.acceptPeering(args, context);
-            case "reject-peering":
-                return this.rejectPeering(args, context);
-            default:
-                return {
-                    content: [{ type: "text", text: `Unknown action: ${args.action}` }],
-                    isError: true,
-                };
-        }
-    }
-    getConfirmationMessage(args) {
-        switch (args.action) {
-            case "start-processor": {
-                const name = this.requireResourceName(args.resourceName, "start-processor");
-                const checkpointWarning = args.resumeFromCheckpoint === false
-                    ? ` WARNING: resumeFromCheckpoint is false — all accumulated window state will be permanently lost.`
-                    : "";
-                return (`You are about to start processor '${name}' in workspace '${args.workspaceName}'. ` +
-                    `Starting a processor will begin billing for stream processing usage based on the workspace tier.${checkpointWarning} Proceed?`);
-            }
-            case "stop-processor": {
-                const name = this.requireResourceName(args.resourceName, "stop-processor");
-                return `You are about to stop processor '${name}' in workspace '${args.workspaceName}'. In-flight data will complete processing. Proceed?`;
-            }
-            case "modify-processor": {
-                const name = this.requireResourceName(args.resourceName, "modify-processor");
-                return `You are about to modify processor '${name}' in workspace '${args.workspaceName}'. This may affect pipeline behavior. Proceed?`;
-            }
-            case "update-workspace":
-                return `You are about to update workspace '${args.workspaceName}'. Proceed?`;
-            case "update-connection": {
-                const name = this.requireResourceName(args.resourceName, "update-connection");
-                return `You are about to update connection '${name}' in workspace '${args.workspaceName}'. Proceed?`;
-            }
-            case "accept-peering": {
-                if (!args.peeringId)
-                    throw new Error("peeringId is required for 'accept-peering'.");
-                return `You are about to accept VPC peering connection '${args.peeringId}'. Proceed?`;
-            }
-            case "reject-peering": {
-                if (!args.peeringId)
-                    throw new Error("peeringId is required for 'reject-peering'.");
-                return `You are about to reject VPC peering connection '${args.peeringId}'. This cannot be undone. Proceed?`;
-            }
-        }
-    }
-    requireResourceName(resourceName, context) {
-        if (!resourceName) {
-            throw new Error(`resourceName is required for '${context}'.`);
-        }
-        return resourceName;
-    }
-    static mapUpdateWorkspaceStructuredContent(updated, options) {
-        const structuredContent = {};
-        if (options.includeRegion && updated.dataProcessRegion?.cloudProvider && updated.dataProcessRegion.region) {
-            structuredContent.region = `${updated.dataProcessRegion.cloudProvider}/${updated.dataProcessRegion.region}`;
-        }
-        if (options.includeTier && updated.streamConfig?.tier) {
-            structuredContent.tier = updated.streamConfig.tier;
-        }
-        if (options.includeTier && updated.streamConfig?.maxTierSize) {
-            structuredContent.maxTier = updated.streamConfig.maxTierSize;
-        }
-        return structuredContent;
-    }
-    async startProcessor(args, context) {
-        const name = this.requireResourceName(args.resourceName, "start-processor");
-        const processor = await this.apiClient.getStreamProcessor({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-        }, context);
-        if (processor?.state === "STARTED") {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Processor '${name}' is already running. Use action 'stop-processor' first if you want to restart it.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        if (args.tier) {
-            const tierOrder = ["SP2", "SP5", "SP10", "SP30", "SP50"];
-            try {
-                const ws = await this.apiClient.getStreamWorkspace({
-                    params: { path: { groupId: args.projectId, tenantName: args.workspaceName } },
-                }, context);
-                const maxTier = ws?.streamConfig?.maxTierSize;
-                if (maxTier && tierOrder.indexOf(args.tier) > tierOrder.indexOf(maxTier)) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Cannot start processor with tier '${args.tier}' — workspace '${args.workspaceName}' has a maximum tier of '${maxTier}'.\n\n` +
-                                    `Options:\n` +
-                                    `1. Use a tier ≤ ${maxTier}\n` +
-                                    `2. Raise the workspace max tier first with \`atlas-streams-manage\` action='update-workspace' newTier='${args.tier}'`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            catch {
-                // Soft check — proceed anyway if we can't fetch workspace
-            }
-        }
-        const hasStartOptions = args.tier !== undefined ||
-            args.resumeFromCheckpoint !== undefined ||
-            args.startAtOperationTime !== undefined;
-        if (hasStartOptions) {
-            const startBody = {};
-            if (args.tier !== undefined)
-                startBody.tier = args.tier;
-            if (args.resumeFromCheckpoint !== undefined)
-                startBody.resumeFromCheckpoint = args.resumeFromCheckpoint;
-            if (args.startAtOperationTime !== undefined)
-                startBody.startAtOperationTime = args.startAtOperationTime;
-            await this.apiClient.startStreamProcessorWith({
-                params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-                body: startBody,
-            }, context);
-        }
-        else {
-            await this.apiClient.startStreamProcessor({
-                params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-            }, context);
-        }
-        const checkpointNote = args.resumeFromCheckpoint === false
-            ? " Starting from the beginning (no checkpoint resume)."
-            : " Resuming from last checkpoint.";
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Processor '${name}' started in workspace '${args.workspaceName}'.${checkpointNote}\n\n` +
-                        `Note: Billing for stream processing usage is now active for this processor.\n\n` +
-                        `Use \`atlas-streams-discover\` with action 'diagnose-processor' to monitor health. ` +
-                        `Use \`atlas-streams-manage\` with action 'stop-processor' to stop billing.`,
-                },
-            ],
-            structuredContent: { processorState: "STARTED" },
-        };
-    }
-    async stopProcessor(args, context) {
-        const name = this.requireResourceName(args.resourceName, "stop-processor");
-        try {
-            const processor = await this.apiClient.getStreamProcessor({
-                params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-            }, context);
-            if (processor?.state === "STOPPED" || processor?.state === "CREATED") {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Processor '${name}' is not running (state: ${processor.state}). No action needed.`,
-                        },
-                    ],
-                    structuredContent: { processorState: processor.state },
-                };
-            }
-        }
-        catch (error) {
-            // Processor may be in error state — proceed with stop attempt
-            this.session.logger.debug({
-                id: LogId.streamsProcessorStateLookupFailure,
-                context: "streams-manage",
-                message: `Failed to get processor state before stop: ${error instanceof Error ? error.message : String(error)}`,
-                attributes: { ...requestIdAttr(context.requestInfo?.headers) },
-            });
-        }
-        await this.apiClient.stopStreamProcessor({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-        }, context);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Processor '${name}' stopped. State preserved for 45 days.\n\n` +
-                        `Use action 'modify-processor' to change its pipeline, or action 'start-processor' to resume.`,
-                },
-            ],
-            structuredContent: { processorState: "STOPPED" },
-        };
-    }
-    async modifyProcessor(args, context) {
-        const name = this.requireResourceName(args.resourceName, "modify-processor");
-        const processor = await this.apiClient.getStreamProcessor({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-        }, context);
-        if (processor?.state === "STARTED") {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Processor '${name}' must be stopped before modifying. Use action 'stop-processor' first.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        const body = {};
-        if (args.pipeline)
-            body.pipeline = args.pipeline;
-        if (args.newName)
-            body.name = args.newName;
-        if (args.dlq)
-            body.options = { dlq: args.dlq };
-        if (Object.keys(body).length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No modifications specified. Provide at least one of: pipeline, dlq, or newName.",
-                    },
-                ],
-                isError: true,
-            };
-        }
-        await this.apiClient.updateStreamProcessor({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, processorName: name } },
-            body: body,
-        }, context);
-        const changes = Object.keys(body).join(", ");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Processor '${name}' modified (changed: ${changes}).\n\n` +
-                        `Use action 'start-processor' to resume processing with the updated configuration.`,
-                },
-            ],
-            structuredContent: { processorState: "STOPPED" },
-        };
-    }
-    async updateWorkspace(args, context) {
-        const body = {};
-        if (args.newRegion) {
-            // The Atlas API requires cloudProvider alongside region in the update request body.
-            // Fetch the current workspace to get the existing cloudProvider.
-            const workspace = await this.apiClient.getStreamWorkspace({
-                params: { path: { groupId: args.projectId, tenantName: args.workspaceName } },
-            }, context);
-            const cloudProvider = workspace?.dataProcessRegion?.cloudProvider;
-            if (!cloudProvider) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Unable to update workspace region: the current workspace does not specify a cloud provider. " +
-                                "The Atlas API requires cloudProvider when updating region. Inspect the workspace in Atlas and try again.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            body.cloudProvider = cloudProvider;
-            body.region = args.newRegion;
-        }
-        if (args.newTier) {
-            body.streamConfig = { tier: args.newTier };
-        }
-        if (Object.keys(body).length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No updates specified. Provide at least one of: newRegion or newTier.",
-                    },
-                ],
-                isError: true,
-            };
-        }
-        const updated = await this.apiClient.updateStreamWorkspace({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName } },
-            body: body,
-        }, context);
-        const updatedRegion = updated?.dataProcessRegion?.region;
-        if (args.newRegion &&
-            updatedRegion !== undefined &&
-            updatedRegion !== null &&
-            updatedRegion !== args.newRegion) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Failed to update workspace region to '${args.newRegion}'. ` +
-                            `Current region is '${updatedRegion}'. ` +
-                            `Verify the region name is valid for the workspace's cloud provider.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Workspace '${args.workspaceName}' updated. Use \`atlas-streams-discover\` with action 'inspect-workspace' to verify changes.`,
-                },
-            ],
-            structuredContent: StreamsManageTool.mapUpdateWorkspaceStructuredContent(updated ?? {}, {
-                includeRegion: args.newRegion !== undefined,
-                includeTier: args.newTier !== undefined,
-            }),
-        };
-    }
-    async updateConnection(args, context) {
-        const name = this.requireResourceName(args.resourceName, "update-connection");
-        if (!args.connectionConfig) {
-            throw new Error("connectionConfig is required to update a connection.");
-        }
-        const connection = (await this.apiClient.getStreamConnection({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, connectionName: name } },
-        }, context));
-        const normalizedConfig = ConnectionConfig.parse(args.connectionConfig);
-        const updated = (await this.apiClient.updateStreamConnection({
-            params: { path: { groupId: args.projectId, tenantName: args.workspaceName, connectionName: name } },
-            body: {
-                ...normalizedConfig,
-                ...(connection.type !== undefined ? { type: connection.type } : {}),
-                name,
-            },
-        }, context));
-        const connectionState = updated?.state ?? connection.state;
-        const parsedConnectionState = ConnectionState.safeParse(connectionState);
-        const structuredContent = parsedConnectionState.success
-            ? { connectionState: parsedConnectionState.data }
-            : {};
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Connection '${name}' updated in workspace '${args.workspaceName}'.`,
-                },
-            ],
-            structuredContent,
-        };
-    }
-    async acceptPeering(args, context) {
-        if (!args.peeringId)
-            throw new Error("peeringId is required to accept a VPC peering connection.");
-        if (!args.requesterAccountId)
-            throw new Error("requesterAccountId is required to accept VPC peering.");
-        if (!args.requesterVpcId)
-            throw new Error("requesterVpcId is required to accept VPC peering.");
-        const peeringId = args.peeringId;
-        const requesterAccountId = args.requesterAccountId;
-        const requesterVpcId = args.requesterVpcId;
-        await this.apiClient.acceptVpcPeeringConnection({
-            params: { path: { groupId: args.projectId, id: peeringId } },
-            body: {
-                requesterAccountId,
-                requesterVpcId,
-            },
-        }, context);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `VPC peering connection '${args.peeringId}' accepted. It may take a few minutes to become active.`,
-                },
-            ],
-            structuredContent: { peeringState: "ACCEPTED" },
-        };
-    }
-    async rejectPeering(args, context) {
-        if (!args.peeringId)
-            throw new Error("peeringId is required to reject a VPC peering connection.");
-        await this.apiClient.rejectVpcPeeringConnection({
-            params: { path: { groupId: args.projectId, id: args.peeringId } },
-        }, context);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `VPC peering connection '${args.peeringId}' rejected.`,
-                },
-            ],
-            structuredContent: { peeringState: "REJECTED" },
-        };
-    }
-}
-StreamsManageTool.toolName = "atlas-streams-manage";
-StreamsManageTool.operationType = "update";
-//# sourceMappingURL=manage.js.map