@himanshusinghs/mongodb-mcp-server 1.7.7 → 1.11.0-prerelease.2

package/dist/cjs/tools/atlas/streams/build.js

@@ -0,0 +1,671 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamsBuildTool = void 0;
+const zod_1 = require("zod");
+const streamsToolBase_js_1 = require("./streamsToolBase.js");
+const args_js_1 = require("../../args.js");
+const streamsArgs_js_1 = require("./streamsArgs.js");
+const BuildResource = zod_1.z.enum(["workspace", "connection", "processor", "privatelink"]);
+const ConnectionType = zod_1.z.enum([
+    "Kafka",
+    "Cluster",
+    "S3",
+    "Https",
+    "AWSKinesisDataStreams",
+    "AWSLambda",
+    "SchemaRegistry",
+    "Sample",
+]);
+const CloudProvider = zod_1.z.enum(["AWS", "AZURE", "GCP"]);
+const KAFKA_FIELDS = {
+    bootstrapServers: {
+        title: "Bootstrap Servers",
+        description: "Comma-separated broker addresses (e.g. 'broker1:9092,broker2:9092')",
+    },
+    mechanism: {
+        title: "Authentication Mechanism",
+        description: "SASL mechanism: 'PLAIN', 'SCRAM-256', or 'SCRAM-512'",
+    },
+    username: {
+        title: "Username",
+        description: "SASL username for Kafka authentication",
+    },
+    password: {
+        title: "Password",
+        description: "SASL password for Kafka authentication",
+    },
+    protocol: {
+        title: "Security Protocol",
+        description: "Security protocol: 'SASL_SSL', 'SASL_PLAINTEXT', or 'SSL'",
+    },
+};
+const CLUSTER_FIELDS = {
+    clusterName: {
+        title: "Cluster Name",
+        description: "Name of an Atlas cluster in this project (use `atlas-list-clusters` to see available clusters)",
+    },
+};
+const AWS_FIELDS = {
+    roleArn: {
+        title: "AWS IAM Role ARN",
+        description: "IAM role ARN registered in this Atlas project via Cloud Provider Access " +
+            "(e.g. 'arn:aws:iam::123456789:role/my-role'). " +
+            "Ask the user for this value — it can be found in: Atlas UI → Project Settings → Cloud Provider Access.",
+    },
+};
+const SCHEMA_REGISTRY_FIELDS = {
+    schemaRegistryUrl: {
+        title: "Schema Registry URL",
+        description: "Schema Registry endpoint URL (e.g. 'https://schema-registry.example.com')",
+    },
+    username: {
+        title: "Username",
+        description: "Username for Schema Registry authentication",
+    },
+    password: {
+        title: "Password",
+        description: "Password for Schema Registry authentication",
+    },
+};
+const HTTPS_FIELDS = {
+    url: {
+        title: "Endpoint URL",
+        description: "HTTPS endpoint URL (e.g. 'https://api.example.com/webhook')",
+    },
+};
+class StreamsBuildTool extends streamsToolBase_js_1.StreamsToolBase {
+    constructor() {
+        super(...arguments);
+        this.description = "Create Atlas Stream Processing resources. " +
+            "Use this tool for 'set up a Kafka pipeline', 'create a workspace', 'add a connection', or 'deploy a processor'. " +
+            "Use resource='workspace' to create a new workspace (specify cloud provider, region, and tier). " +
+            "Use resource='connection' to add a data source or sink to an existing workspace. " +
+            "Use resource='processor' to deploy a stream processor with a pipeline. " +
+            "Use resource='privatelink' to set up private networking. " +
+            "Typical workflow: create workspace → add connections → deploy processor.";
+        this.argsShape = {
+            projectId: args_js_1.AtlasArgs.projectId().describe("Atlas project ID. Use atlas-list-projects to find project IDs if not available."),
+            resource: BuildResource.describe("What to create. Start with 'workspace', then 'connection', then 'processor'. " +
+                "Use 'privatelink' only if connections need private networking."),
+            workspaceName: streamsArgs_js_1.StreamsArgs.workspaceName()
+                .optional()
+                .describe("Workspace name. Required for workspace, connection, and processor resources. " +
+                "Not required for privatelink (which is project-level). " +
+                "For 'workspace': the name to create. For others: the existing workspace to add to. " +
+                "Use `atlas-streams-discover` with action 'list-workspaces' to see existing workspaces."),
+            // Workspace fields
+            cloudProvider: CloudProvider.optional().describe("Cloud provider. Required when resource='workspace'."),
+            region: args_js_1.AtlasArgs.region()
+                .optional()
+                .describe("Cloud region. Required when resource='workspace'. " +
+                "Use Atlas region names: AWS examples: 'VIRGINIA_USA', 'OREGON_USA', 'DUBLIN_IRL'. " +
+                "Azure examples: 'eastus2', 'westeurope'. GCP examples: 'US_CENTRAL1', 'EUROPE_WEST1'."),
+            tier: zod_1.z
+                .enum(["SP2", "SP5", "SP10", "SP30", "SP50"])
+                .optional()
+                .describe("Processing tier. Default: SP10. Only for resource='workspace'."),
+            includeSampleData: zod_1.z
+                .boolean()
+                .optional()
+                .describe("Include the sample_stream_solar connection for testing. Default: true. Only for resource='workspace'."),
+            // Connection fields
+            connectionName: streamsArgs_js_1.StreamsArgs.connectionName()
+                .optional()
+                .describe("Connection name. Required when resource='connection'."),
+            connectionType: ConnectionType.optional().describe("Connection type. Required when resource='connection'. " +
+                "Kafka: needs bootstrapServers, authentication, security config. " +
+                "Cluster: needs clusterName and dbRoleToExecute. " +
+                "S3: needs aws.roleArn (must be registered via Atlas Cloud Provider Access). " +
+                "Https: needs url. " +
+                "AWSKinesisDataStreams: needs aws.roleArn (must be registered via Atlas Cloud Provider Access). " +
+                "AWSLambda: needs aws.roleArn (must be registered via Atlas Cloud Provider Access). " +
+                "SchemaRegistry: needs provider, schemaRegistryUrls, and authentication config. " +
+                "Sample: provides sample data for testing (no config needed)."),
+            connectionConfig: streamsArgs_js_1.ConnectionConfig.optional().describe("Type-specific connection configuration. Only for resource='connection'. " +
+                "Omit entirely for connectionType='Sample' (no config needed). " +
+                "You may pass a partial config — the tool uses elicitation to collect missing required fields directly from the user."),
+            // Processor fields
+            processorName: streamsArgs_js_1.StreamsArgs.processorName()
+                .optional()
+                .describe("Processor name. Required when resource='processor'."),
+            pipeline: zod_1.z
+                .array(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+                .optional()
+                .describe("Pipeline stages for the stream processor. Required when resource='processor'. " +
+                "Must start with a $source stage and end with a terminal stage ($merge, $emit, $https, or $externalFunction). " +
+                "Use $merge to write to Atlas cluster collections: {$merge: {into: {connectionName, db, coll}}}. " +
+                "Use $emit to write to Kafka or Kinesis sinks: {$emit: {connectionName, topic}}. $emit only works with Kafka/Kinesis connections — do NOT use $emit with Https connections. " +
+                "Use $https to POST data to an Https connection: {$https: {connectionName}}. " +
+                "Use $externalFunction for Lambda: {$externalFunction: {connectionName, functionName, execution: 'async', as: 'result'}}. Lambda does NOT use $emit — use $externalFunction with execution='async' as a terminal stage or execution='sync' for mid-pipeline enrichment. " +
+                "By default $https.onError is 'dlq', which requires a DLQ (see dlq parameter). Set {$https: {connectionName, onError: 'ignore'}} to skip DLQ. " +
+                "For Kafka $emit with Schema Registry: {$emit: {connectionName, topic, schemaRegistry: {connectionName: '<sr-connection>', valueSchema: {type: 'avro', schema: {<avro-schema>}, options: {subjectNameStrategy: 'TopicNameStrategy', autoRegisterSchemas: true}}}}}. " +
+                "Note: valueSchema.type must be lowercase 'avro'. valueSchema.schema (Avro schema definition) is always required even with autoRegisterSchemas. " +
+                "Kafka/Kinesis $source must include a 'topic'/'stream' field. " +
+                "$$NOW, $$ROOT, and $$CURRENT are not available in streaming context. " +
+                "Connections referenced in $source/$merge/$emit/$https must already exist in the workspace."),
+            dlq: zod_1.z
+                .object({
+                connectionName: zod_1.z.string().describe("Atlas connection name for DLQ output"),
+                db: zod_1.z.string().describe("Database name for DLQ collection"),
+                coll: zod_1.z.string().describe("Collection name for DLQ documents"),
+            })
+                .optional()
+                .describe("Dead letter queue configuration. Only for resource='processor'. " +
+                "Only include when the user explicitly requests a DLQ, or when the pipeline uses $https with default onError='dlq'. " +
+                "The DLQ connection must already exist in the workspace."),
+            autoStart: zod_1.z
+                .boolean()
+                .optional()
+                .describe("Start the processor immediately after creation. Default: false. Only for resource='processor'. " +
+                "Omit unless the user explicitly asks to start the processor right away."),
+            // PrivateLink fields
+            privateLinkConfig: streamsArgs_js_1.PrivateLinkConfig.optional().describe("PrivateLink configuration including provider and provider-specific fields. Required when resource='privatelink'."),
+        };
+    }
+    async execute(args) {
+        switch (args.resource) {
+            case "workspace":
+                return this.createWorkspace(args);
+            case "connection":
+                return this.createConnection(args);
+            case "processor":
+                return this.createProcessor(args);
+            case "privatelink":
+                return this.createPrivateLink(args);
+            default:
+                return {
+                    content: [{ type: "text", text: `Unknown resource type: ${args.resource}` }],
+                    isError: true,
+                };
+        }
+    }
+    requireWorkspaceName(args) {
+        if (!args.workspaceName) {
+            throw new Error("workspaceName is required for this resource type.");
+        }
+        return args.workspaceName;
+    }
+    async createWorkspace(args) {
+        const workspaceName = this.requireWorkspaceName(args);
+        if (!args.cloudProvider) {
+            throw new Error("cloudProvider is required when creating a workspace. Choose from: AWS, AZURE, GCP.");
+        }
+        if (!args.region) {
+            throw new Error("region is required when creating a workspace (e.g. 'VIRGINIA_USA', 'eastus2', 'US_CENTRAL1').");
+        }
+        const body = {
+            name: workspaceName,
+            dataProcessRegion: {
+                cloudProvider: args.cloudProvider,
+                region: args.region,
+            },
+            streamConfig: {
+                tier: args.tier ?? "SP10",
+            },
+        };
+        const useSample = args.includeSampleData !== false;
+        if (useSample) {
+            await this.apiClient.withStreamSampleConnections({
+                params: { path: { groupId: args.projectId } },
+                body: body,
+            });
+        }
+        else {
+            await this.apiClient.createStreamWorkspace({
+                params: { path: { groupId: args.projectId } },
+                body: body,
+            });
+        }
+        const sampleNote = useSample ? " Includes sample_stream_solar connection for testing." : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Workspace '${workspaceName}' created in ${args.cloudProvider}/${args.region} (${args.tier ?? "SP10"}).${sampleNote}\n\n` +
+                        `Next: Add data source/sink connections with \`atlas-streams-build\` resource='connection', ` +
+                        `then deploy a processor with resource='processor'.`,
+                },
+            ],
+        };
+    }
+    async createConnection(args) {
+        const workspaceName = this.requireWorkspaceName(args);
+        if (!args.connectionName) {
+            throw new Error("connectionName is required when adding a connection.");
+        }
+        if (!args.connectionType) {
+            throw new Error("connectionType is required. Choose from: Kafka, Cluster, S3, Https, AWSKinesisDataStreams, AWSLambda, SchemaRegistry, Sample.");
+        }
+        const config = { ...streamsArgs_js_1.ConnectionConfig.parse(args.connectionConfig ?? {}) };
+        const missingInfo = await this.normalizeAndValidateConnectionConfig(config, args.connectionType);
+        if (missingInfo) {
+            return missingInfo;
+        }
+        const body = {
+            ...config,
+            name: args.connectionName,
+            type: args.connectionType,
+        };
+        await this.apiClient.createStreamConnection({
+            params: { path: { groupId: args.projectId, tenantName: workspaceName } },
+            body: body,
+        });
+        const privateLinkWarning = config?.networking?.access?.type === "PRIVATE_LINK"
+            ? `\n\nNote: This connection uses PrivateLink and will start in PENDING state. It may take a few minutes to provision. Use \`atlas-streams-discover\` with action 'inspect-connection' to check when it becomes READY.`
+            : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Connection '${args.connectionName}' (${args.connectionType}) added to workspace '${workspaceName}'.${privateLinkWarning}\n\n` +
+                        `Next: Add more connections or deploy a processor with \`atlas-streams-build\` resource='processor'. ` +
+                        `Reference this connection as '${args.connectionName}' in your processor pipeline's $source, $merge, or $emit stages.`,
+                },
+            ],
+        };
+    }
+    /**
+     * Validates and normalizes connectionConfig for the given type. Applies sensible
+     * defaults, fixes common format mismatches, and uses elicitation to collect
+     * missing sensitive fields (like passwords) directly from the user when supported.
+     *
+     * @returns null if config is valid and ready to send, or a CallToolResult
+     *          describing what information is still needed.
+     */
+    async normalizeAndValidateConnectionConfig(config, connectionType) {
+        switch (connectionType) {
+            case "Kafka":
+                return this.validateKafkaConfig(config);
+            case "Cluster":
+                return this.validateClusterConfig(config);
+            case "S3":
+            case "AWSKinesisDataStreams":
+            case "AWSLambda":
+                return this.validateAwsConfig(config, connectionType);
+            case "SchemaRegistry":
+                return this.validateSchemaRegistryConfig(config);
+            case "Https":
+                return this.validateHttpsConfig(config);
+            default:
+                return null;
+        }
+    }
+    async validateKafkaConfig(config) {
+        const auth = config.authentication;
+        const security = config.security;
+        const missingFields = StreamsBuildTool.collectMissingFields([
+            { key: "bootstrapServers", present: !!config.bootstrapServers, schema: KAFKA_FIELDS.bootstrapServers },
+            { key: "mechanism", present: !!auth?.mechanism, schema: KAFKA_FIELDS.mechanism },
+            { key: "username", present: !!auth?.username, schema: KAFKA_FIELDS.username },
+            { key: "password", present: !!auth?.password, schema: KAFKA_FIELDS.password },
+            { key: "protocol", present: !!security?.protocol, schema: KAFKA_FIELDS.protocol },
+        ]);
+        if (missingFields.length === 0) {
+            return null;
+        }
+        return this.elicitOrReportMissing("Kafka", config, missingFields, (fields, cfg) => {
+            if (fields.bootstrapServers)
+                cfg.bootstrapServers = fields.bootstrapServers;
+            if (!cfg.authentication)
+                cfg.authentication = {};
+            const authObj = cfg.authentication;
+            if (fields.mechanism)
+                authObj.mechanism = fields.mechanism;
+            if (fields.username)
+                authObj.username = fields.username;
+            if (fields.password)
+                authObj.password = fields.password;
+            if (!cfg.security)
+                cfg.security = {};
+            const secObj = cfg.security;
+            if (fields.protocol)
+                secObj.protocol = fields.protocol;
+        });
+    }
+    async validateClusterConfig(config) {
+        const missingFields = StreamsBuildTool.collectMissingFields([
+            { key: "clusterName", present: !!config.clusterName, schema: CLUSTER_FIELDS.clusterName },
+        ]);
+        // dbRoleToExecute is a config choice, not user-specific data — safe to default
+        if (!config.dbRoleToExecute) {
+            config.dbRoleToExecute = { role: "readWriteAnyDatabase", type: "BUILT_IN" };
+        }
+        if (missingFields.length === 0) {
+            return null;
+        }
+        return this.elicitOrReportMissing("Cluster", config, missingFields, (fields, cfg) => {
+            if (fields.clusterName)
+                cfg.clusterName = fields.clusterName;
+        });
+    }
+    async validateAwsConfig(config, connectionType) {
+        const aws = config.aws;
+        const missingFields = StreamsBuildTool.collectMissingFields([
+            { key: "roleArn", present: !!aws?.roleArn, schema: AWS_FIELDS.roleArn },
+        ]);
+        if (missingFields.length === 0) {
+            return null;
+        }
+        return this.elicitOrReportMissing(connectionType, config, missingFields, (fields, cfg) => {
+            if (fields.roleArn) {
+                if (!cfg.aws)
+                    cfg.aws = {};
+                cfg.aws.roleArn = fields.roleArn;
+            }
+        }, `Note: The IAM role ARN must first be registered in the Atlas project via Cloud Provider Access.\n` +
+            `To find available ARNs: Atlas UI → Project Settings → Cloud Provider Access.\n` +
+            `To register a new one: Atlas UI → Project Settings → Cloud Provider Access → Authorize an AWS IAM role.`);
+    }
+    async validateSchemaRegistryConfig(config) {
+        // Normalize common alternative key names for schemaRegistryUrls
+        if (!config.schemaRegistryUrls) {
+            const alt = config.url || config.urls || config.endpoint || config.schemaRegistryUrl;
+            if (alt) {
+                config.schemaRegistryUrls = Array.isArray(alt) ? alt : [alt];
+                delete config.url;
+                delete config.urls;
+                delete config.endpoint;
+                delete config.schemaRegistryUrl;
+            }
+        }
+        // Normalize common alternative key names for authentication
+        if (!config.schemaRegistryAuthentication && (config.username || config.authentication)) {
+            const authSource = config.authentication || {};
+            config.schemaRegistryAuthentication = {
+                type: "USER_INFO",
+                username: config.username || authSource.username,
+                password: config.password || authSource.password,
+            };
+            delete config.username;
+            delete config.password;
+            delete config.authentication;
+        }
+        // Default provider to CONFLUENT — currently the only supported value
+        if (!config.provider) {
+            config.provider = "CONFLUENT";
+        }
+        // Default auth type to USER_INFO when credentials are provided
+        if (!config.schemaRegistryAuthentication) {
+            config.schemaRegistryAuthentication = {};
+        }
+        const auth = config.schemaRegistryAuthentication;
+        if (!auth.type) {
+            auth.type = "USER_INFO";
+        }
+        const requiresCredentials = auth.type !== "SASL_INHERIT";
+        const missingFields = StreamsBuildTool.collectMissingFields([
+            {
+                key: "schemaRegistryUrl",
+                present: Array.isArray(config.schemaRegistryUrls) && config.schemaRegistryUrls.length > 0,
+                schema: SCHEMA_REGISTRY_FIELDS.schemaRegistryUrl,
+            },
+            {
+                key: "username",
+                present: !requiresCredentials || !!auth.username,
+                schema: SCHEMA_REGISTRY_FIELDS.username,
+            },
+            {
+                key: "password",
+                present: !requiresCredentials || !!auth.password,
+                schema: SCHEMA_REGISTRY_FIELDS.password,
+            },
+        ]);
+        if (missingFields.length === 0) {
+            return null;
+        }
+        return this.elicitOrReportMissing("SchemaRegistry", config, missingFields, (fields, cfg) => {
+            if (fields.schemaRegistryUrl) {
+                cfg.schemaRegistryUrls = [fields.schemaRegistryUrl];
+            }
+            const authObj = cfg.schemaRegistryAuthentication;
+            if (fields.username)
+                authObj.username = fields.username;
+            if (fields.password)
+                authObj.password = fields.password;
+        });
+    }
+    async validateHttpsConfig(config) {
+        const missingFields = StreamsBuildTool.collectMissingFields([
+            { key: "url", present: !!config.url, schema: HTTPS_FIELDS.url },
+        ]);
+        if (missingFields.length === 0) {
+            return null;
+        }
+        return this.elicitOrReportMissing("Https", config, missingFields, (fields, cfg) => {
+            if (fields.url)
+                cfg.url = fields.url;
+        });
+    }
+    // --- Shared elicitation helpers ---
+    /**
+     * Attempts to collect all missing required fields via elicitation. If the
+     * client supports it, shows a single form with every missing field. If not
+     * (or the user declines), returns a structured response listing what's needed.
+     */
+    async elicitOrReportMissing(connectionType, config, missingFields, applyFields, additionalNote) {
+        const schema = StreamsBuildTool.buildElicitationSchema(connectionType, missingFields);
+        const elicited = await this.elicitation.requestInput(`The following information is required to create the ${connectionType} connection.`, schema);
+        if (elicited.accepted) {
+            applyFields(elicited.fields, config);
+            // Re-check: did the user leave any fields empty in the form?
+            const stillMissing = missingFields.filter((f) => !elicited.fields[f.key]);
+            if (stillMissing.length > 0) {
+                return StreamsBuildTool.missingFieldsResponse(connectionType, stillMissing, additionalNote);
+            }
+            return null;
+        }
+        return StreamsBuildTool.missingFieldsResponse(connectionType, missingFields, additionalNote);
+    }
+    static collectMissingFields(checks) {
+        return checks.filter((c) => !c.present).map((c) => ({ key: c.key, ...c.schema }));
+    }
+    static buildElicitationSchema(_connectionType, missingFields) {
+        const properties = {};
+        for (const field of missingFields) {
+            properties[field.key] = {
+                type: "string",
+                title: field.title,
+                description: field.description,
+            };
+        }
+        return {
+            type: "object",
+            properties,
+            required: missingFields.map((f) => f.key),
+        };
+    }
+    static missingFieldsResponse(connectionType, missingFields, additionalNote) {
+        const list = missingFields.map((f) => `  - ${f.title}: ${f.description}`).join("\n");
+        const note = additionalNote ? `\n\n${additionalNote}` : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Cannot create ${connectionType} connection — the following required information is missing:\n${list}\n\n` +
+                        `Please ask the user to provide these values and retry.${note}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    static validatePipelineStructure(pipeline) {
+        const TERMINAL_STAGES = new Set(["$merge", "$emit", "$https", "$externalFunction"]);
+        const firstStage = pipeline[0];
+        const firstStageKey = firstStage ? Object.keys(firstStage)[0] : undefined;
+        if (firstStageKey !== "$source") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Invalid pipeline: first stage must be \`$source\`, but found \`${firstStageKey}\`.\n\n` +
+                            `A streaming pipeline must start with $source to define the input data stream. ` +
+                            `Example: {$source: {connectionName: "myConnection", topic: "myTopic"}}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const lastStage = pipeline[pipeline.length - 1];
+        const lastStageKey = lastStage ? Object.keys(lastStage)[0] : undefined;
+        if (!lastStageKey || !TERMINAL_STAGES.has(lastStageKey)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Invalid pipeline: last stage must be a terminal stage (\`$merge\`, \`$emit\`, \`$https\`, or \`$externalFunction\`), but found \`${lastStageKey}\`.\n\n` +
+                            `Use $merge to write to Atlas clusters: {$merge: {into: {connectionName, db, coll}}}.\n` +
+                            `Use $emit to write to Kafka/Kinesis/external sinks: {$emit: {connectionName, topic}}.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const pipelineStr = JSON.stringify(pipeline);
+        const unsupportedVars = ["$$NOW", "$$ROOT", "$$CURRENT"].filter((v) => pipelineStr.includes(v));
+        if (unsupportedVars.length > 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Warning: pipeline contains ${unsupportedVars.join(", ")} which ${unsupportedVars.length === 1 ? "is" : "are"} not available in streaming context.\n\n` +
+                            `These system variables are not supported in Atlas Stream Processing pipelines. ` +
+                            `Remove or replace them before deploying.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return null;
+    }
+    async validatePipelineConnections(projectId, workspaceName, pipeline, dlq) {
+        const referencedNames = streamsToolBase_js_1.StreamsToolBase.extractConnectionNames(pipeline);
+        if (dlq?.connectionName)
+            referencedNames.add(dlq.connectionName);
+        if (referencedNames.size === 0)
+            return null;
+        let availableNames;
+        try {
+            const data = await this.apiClient.listStreamConnections({
+                params: {
+                    path: { groupId: projectId, tenantName: workspaceName },
+                    query: { itemsPerPage: 100, pageNum: 1 },
+                },
+            });
+            availableNames = new Set((data?.results ?? []).map((c) => String(c.name)));
+        }
+        catch {
+            return null; // Soft check — skip if we can't list connections
+        }
+        const missingNames = [...referencedNames].filter((n) => !availableNames.has(n));
+        if (missingNames.length === 0)
+            return null;
+        const availableList = availableNames.size > 0
+            ? [...availableNames].map((n) => `  - ${n}`).join("\n")
+            : "  (no connections found)";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Cannot create processor — the pipeline references connection(s) that do not exist in workspace '${workspaceName}':\n` +
+                        `  Missing: ${missingNames.join(", ")}\n\n` +
+                        `Available connections:\n${availableList}\n\n` +
+                        `Add the missing connection(s) first with \`atlas-streams-build\` resource='connection', then retry.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    async createProcessor(args) {
+        const workspaceName = this.requireWorkspaceName(args);
+        if (!args.processorName) {
+            throw new Error("processorName is required when deploying a processor.");
+        }
+        if (!args.pipeline || args.pipeline.length === 0) {
+            throw new Error("pipeline is required. Provide an array of aggregation stages starting with $source and ending with a terminal stage ($merge, $emit, $https, or $externalFunction).");
+        }
+        const structureError = StreamsBuildTool.validatePipelineStructure(args.pipeline);
+        if (structureError)
+            return structureError;
+        const connectionError = await this.validatePipelineConnections(args.projectId, workspaceName, args.pipeline, args.dlq);
+        if (connectionError)
+            return connectionError;
+        const body = {
+            name: args.processorName,
+            pipeline: args.pipeline,
+            options: args.dlq ? { dlq: args.dlq } : undefined,
+        };
+        await this.apiClient.createStreamProcessor({
+            params: { path: { groupId: args.projectId, tenantName: workspaceName } },
+            body: body,
+        });
+        let startMessage = "Processor created in CREATED state.";
+        if (args.autoStart) {
+            await this.apiClient.startStreamProcessor({
+                params: {
+                    path: {
+                        groupId: args.projectId,
+                        tenantName: workspaceName,
+                        processorName: args.processorName,
+                    },
+                },
+            });
+            startMessage = "Processor created and started.";
+        }
+        const dlqNote = args.dlq
+            ? ` DLQ configured: ${args.dlq.db}.${args.dlq.coll} via '${args.dlq.connectionName}'.`
+            : " Consider adding a DLQ for production use.";
+        const billingNote = args.autoStart
+            ? `\n\nNote: Billing for stream processing usage is now active for this processor. ` +
+                `Use \`atlas-streams-manage\` with action 'stop-processor' to stop billing.`
+            : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${startMessage} Processor '${args.processorName}' deployed in workspace '${workspaceName}'.${dlqNote}\n\n` +
+                        (args.autoStart
+                            ? `Use \`atlas-streams-discover\` with action 'diagnose-processor' to monitor health.`
+                            : `Use \`atlas-streams-manage\` with action 'start-processor' to begin processing.`) +
+                        billingNote,
+                },
+            ],
+        };
+    }
+    async createPrivateLink(args) {
+        if (!args.privateLinkConfig) {
+            throw new Error("privateLinkConfig is required. Provide provider and vendor-specific fields:\n" +
+                "  AWS CONFLUENT: {provider, vendor:'CONFLUENT', region, serviceEndpointId, dnsDomain, dnsSubDomain: string[] of full FQDNs ([] for serverless)}\n" +
+                "  AWS MSK: {provider, vendor:'MSK', arn}\n" +
+                "  AWS S3: {provider, vendor:'S3', region, serviceEndpointId:'com.amazonaws.<region>.s3'}\n" +
+                "  AWS KINESIS: {provider, vendor:'KINESIS', region, serviceEndpointId}\n" +
+                "  AZURE EVENTHUB: {provider, vendor:'EVENTHUB', region, dnsDomain, serviceEndpointId (full Azure Resource ID)}\n" +
+                "  AZURE CONFLUENT: {provider, vendor:'CONFLUENT', region, dnsDomain, azureResourceIds}\n" +
+                "  GCP CONFLUENT: {provider, vendor:'CONFLUENT', region, dnsDomain, gcpServiceAttachmentUris}");
+        }
+        if (!args.privateLinkConfig.provider) {
+            throw new Error("privateLinkConfig.provider is required. Choose from: AWS, AZURE, GCP.");
+        }
+        const body = {
+            ...args.privateLinkConfig,
+        };
+        await this.apiClient.createPrivateLinkConnection({
+            params: { path: { groupId: args.projectId } },
+            body: body,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `PrivateLink connection created for ${args.privateLinkConfig.provider}. ` +
+                        `It may take a few minutes to become active. ` +
+                        `Use \`atlas-streams-discover\` with action 'get-networking' to check status.\n\n` +
+                        `Once active, create connections with networking.access.type='PRIVATE_LINK' to use it.`,
+                },
+            ],
+        };
+    }
+}
+exports.StreamsBuildTool = StreamsBuildTool;
+StreamsBuildTool.toolName = "atlas-streams-build";
+StreamsBuildTool.operationType = "create";
+//# sourceMappingURL=build.js.map