@salesforce/b2c-dx-mcp 2.1.2 → 3.0.0

package/node_modules/@salesforce/b2c-agent-plugins/b2c/skills/b2c-controllers/references/SFRA-PATTERNS.md

@@ -0,0 +1,400 @@
+# SFRA Controller Patterns
+
+Detailed patterns for SFRA controllers using the `server` module.
+
+## Basic Route Structure
+
+```javascript
+'use strict';
+
+var server = require('server');
+
+server.get('RouteName', function (req, res, next) {
+    // Handler logic
+    next();
+});
+
+module.exports = server.exports();
+```
+
+## HTTP Methods
+
+```javascript
+server.get('Show', handler);      // GET requests
+server.post('Submit', handler);   // POST requests
+server.use('Any', handler);       // Any HTTP method
+```
+
+## Multiple Middleware
+
+Chain multiple middleware functions:
+
+```javascript
+server.get('Show',
+    middleware1,
+    middleware2,
+    function (req, res, next) {
+        // Final handler
+        next();
+    }
+);
+```
+
+## Request Object Properties
+
+```javascript
+server.get('Example', function (req, res, next) {
+    // Query parameters (?param=value)
+    var param = req.querystring.param;
+    var pid = req.querystring.pid;
+
+    // Form data (POST body)
+    var email = req.form.email;
+    var password = req.form.password;
+
+    // Current customer
+    var customer = req.currentCustomer;
+    var profile = req.currentCustomer.profile;
+    var isAuthenticated = customer.authenticated;
+
+    // Locale and session
+    var locale = req.locale;
+    var currency = req.session.currency;
+
+    // HTTP details
+    var method = req.httpMethod;
+    var headers = req.httpHeaders;
+    var host = req.httpHost;
+
+    next();
+});
+```
+
+## Response Methods
+
+```javascript
+server.get('Example', function (req, res, next) {
+    // Render ISML template
+    res.render('path/to/template', {
+        key1: 'value1',
+        key2: { nested: 'data' }
+    });
+
+    // Return JSON (for AJAX)
+    res.json({
+        success: true,
+        data: { id: 123 }
+    });
+
+    // Redirect
+    res.redirect(URLUtils.url('Home-Show'));
+
+    // Set HTTP status
+    res.setStatusCode(404);
+
+    // Set response header
+    res.setHttpHeader('X-Custom-Header', 'value');
+
+    next();
+});
+```
+
+## View Data Pattern
+
+Build view data incrementally across middleware:
+
+```javascript
+server.get('Show',
+    function (req, res, next) {
+        res.setViewData({ step1: 'data' });
+        next();
+    },
+    function (req, res, next) {
+        var viewData = res.getViewData();
+        viewData.step2 = 'more data';
+        res.setViewData(viewData);
+        next();
+    },
+    function (req, res, next) {
+        res.render('template', res.getViewData());
+        next();
+    }
+);
+```
+
+## Route Events
+
+```javascript
+server.post('Submit', function (req, res, next) {
+    var form = server.forms.getForm('profile');
+
+    // BeforeComplete: runs after all middleware, before render
+    this.on('route:BeforeComplete', function (req, res) {
+        var viewData = res.getViewData();
+        Transaction.wrap(function () {
+            // Database operations
+            customer.profile.firstName = viewData.firstName;
+        });
+    });
+
+    res.setViewData({ firstName: form.firstName.value });
+    next();
+});
+```
+
+## Extending Controllers
+
+### Using module.superModule
+
+```javascript
+'use strict';
+
+var server = require('server');
+var base = module.superModule;  // Parent controller
+
+server.extend(base);
+
+// Methods available after server.extend():
+// - server.append()   Add to end of existing route
+// - server.prepend()  Add to beginning of existing route
+// - server.replace()  Replace existing route entirely
+```
+
+### Append Pattern (Most Common)
+
+```javascript
+server.append('Show', function (req, res, next) {
+    // Runs AFTER original handler
+    var viewData = res.getViewData();
+    viewData.customField = 'custom value';
+    res.setViewData(viewData);
+    next();
+});
+```
+
+### Prepend Pattern
+
+```javascript
+server.prepend('Show', function (req, res, next) {
+    // Runs BEFORE original handler
+    // Useful for validation, logging, etc.
+    if (!someCondition) {
+        res.redirect(URLUtils.url('Error-Show'));
+        return next();
+    }
+    next();
+});
+```
+
+### Replace Pattern
+
+```javascript
+server.replace('Show', function (req, res, next) {
+    // Completely replaces original handler
+    // Original code does NOT run
+    res.render('custom/template');
+    next();
+});
+```
+
+## Common Middleware Examples
+
+### Caching Middleware
+
+```javascript
+var cache = require('*/cartridge/scripts/middleware/cache');
+
+server.get('Show',
+    cache.applyDefaultCache,  // Apply standard caching
+    function (req, res, next) {
+        res.render('template');
+        next();
+    }
+);
+
+// Custom cache duration
+server.get('Data',
+    cache.applyShortPromotionSensitiveCache,
+    handler
+);
+```
+
+### Authentication Middleware
+
+```javascript
+var userLoggedIn = require('*/cartridge/scripts/middleware/userLoggedIn');
+
+server.get('Account',
+    userLoggedIn.validateLoggedIn,
+    function (req, res, next) {
+        // Only runs if user is logged in
+        res.render('account/dashboard');
+        next();
+    }
+);
+```
+
+### HTTPS Middleware
+
+```javascript
+server.post('Checkout',
+    server.middleware.https,
+    function (req, res, next) {
+        // Only runs over HTTPS
+        next();
+    }
+);
+```
+
+### CSRF Protection
+
+```javascript
+var csrfProtection = require('*/cartridge/scripts/middleware/csrf');
+
+// Generate CSRF token (for form pages)
+server.get('ShowForm',
+    csrfProtection.generateToken,
+    function (req, res, next) {
+        res.render('form');  // Template includes CSRF hidden field
+        next();
+    }
+);
+
+// Validate CSRF token (for form submissions)
+server.post('Submit',
+    csrfProtection.validateAjaxRequest,
+    function (req, res, next) {
+        // Only runs if CSRF token is valid
+        next();
+    }
+);
+```
+
+## Form Handling
+
+```javascript
+server.get('ShowForm', function (req, res, next) {
+    var form = server.forms.getForm('profile');
+    form.clear();  // Reset form data
+
+    res.render('forms/profile', {
+        profileForm: form
+    });
+    next();
+});
+
+server.post('SubmitForm', function (req, res, next) {
+    var form = server.forms.getForm('profile');
+
+    if (form.valid) {
+        // Process valid form
+        var firstName = form.customer.firstname.value;
+        var lastName = form.customer.lastname.value;
+
+        this.on('route:BeforeComplete', function () {
+            Transaction.wrap(function () {
+                // Save to database
+            });
+        });
+
+        res.json({ success: true });
+    } else {
+        res.json({
+            success: false,
+            error: true,
+            fieldErrors: formErrors.getFormErrors(form)
+        });
+    }
+    next();
+});
+```
+
+## AJAX Responses
+
+```javascript
+server.get('GetData', function (req, res, next) {
+    var result = {
+        success: true,
+        data: {
+            items: [],
+            count: 0
+        }
+    };
+
+    res.json(result);
+    next();
+});
+
+// With error handling
+server.post('Process', function (req, res, next) {
+    try {
+        // Process request
+        res.json({ success: true });
+    } catch (e) {
+        res.json({
+            success: false,
+            errorMessage: Resource.msg('error.general', 'error', null)
+        });
+    }
+    next();
+});
+```
+
+## Complete Controller Example
+
+```javascript
+'use strict';
+
+var server = require('server');
+var cache = require('*/cartridge/scripts/middleware/cache');
+var csrfProtection = require('*/cartridge/scripts/middleware/csrf');
+var userLoggedIn = require('*/cartridge/scripts/middleware/userLoggedIn');
+
+var ProductMgr = require('dw/catalog/ProductMgr');
+var Transaction = require('dw/system/Transaction');
+var URLUtils = require('dw/web/URLUtils');
+var Resource = require('dw/web/Resource');
+
+server.get('Show',
+    cache.applyDefaultCache,
+    function (req, res, next) {
+        var pid = req.querystring.pid;
+        var product = ProductMgr.getProduct(pid);
+
+        if (!product || !product.online) {
+            res.setStatusCode(404);
+            res.render('error/notfound');
+            return next();
+        }
+
+        res.render('product/detail', {
+            product: product,
+            breadcrumbs: getBreadcrumbs(product)
+        });
+        next();
+    }
+);
+
+server.post('AddToWishlist',
+    server.middleware.https,
+    userLoggedIn.validateLoggedIn,
+    csrfProtection.validateAjaxRequest,
+    function (req, res, next) {
+        var pid = req.form.pid;
+
+        this.on('route:BeforeComplete', function () {
+            Transaction.wrap(function () {
+                // Add to wishlist
+            });
+        });
+
+        res.json({
+            success: true,
+            message: Resource.msg('wishlist.added', 'wishlist', null)
+        });
+        next();
+    }
+);
+
+module.exports = server.exports();
+```

package/node_modules/@salesforce/b2c-agent-plugins/b2c/skills/b2c-custom-api-development/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: b2c-custom-api-development
+description: Develop Custom SCAPI REST endpoints with api.json routes, schema.yaml definitions, and OAuth scope configuration. Use this skill whenever the user needs to create a custom API on the Commerce platform, define OpenAPI 3.0 schemas for request/response, structure the rest-apis cartridge folder, or debug endpoint registration and 404 issues. Also use when building headless commerce integrations, choosing between Shopper (`ShopperToken`) and Admin (`AmOAuth2`) APIs, or troubleshooting why a Custom API endpoint isn't appearing or returning 404 in `b2c scapi custom status` — even if they just say 'custom REST endpoint', 'expose my script as an API', or 'my admin custom API isn't registering'.
+---
+
+# Custom API Development Skill
+
+This skill guides you through developing Custom APIs for Salesforce B2C Commerce. Custom APIs let you expose custom script code as REST endpoints under the SCAPI framework.
+
+> **Tip:** If `b2c` CLI is not installed globally, use `npx @salesforce/b2c-cli` instead (e.g., `npx @salesforce/b2c-cli code deploy`).
+
+## Scope & grounding
+
+This skill provides CLI-specific workflows and quickstart patterns for Custom API development. It covers OpenAPI 3.0 contract structure, OAuth scope configuration, cartridge-path resolution rules, and circuit breaker behavior. However, platform-specific validation rules, operational limits, security scheme requirements, and Script API integration patterns can drift across Commerce Cloud releases. Before answering questions that reference specific API versions or framework behavior, or before emitting code the user will run, confirm current platform specifics against the official documentation via `b2c docs search` / `b2c docs read` (CLI) or `docs_search` / `docs_read` (MCP). The official documentation is the authoritative source for Custom API contract specifications, runtime behavior, and B2C Commerce platform details not covered here.
+
+**Canonical docs** (confirm platform specifics with these):
+- `commerce-api/custom-apis` - overview, cartridge resolution, operational limits
+- `commerce-api/custom-api-components-references` - schema.yaml and script.js requirements
+- `commerce-api/custom-api-authentication` - OAuth scope rules, security schemes
+- `commerce-api/custom-api-caching` - caching behavior and configuration
+- `commerce-api/custom-api-remote-includes` - remote include patterns
+- `commerce-api/custom-api-circuit-breaker` - current thresholds and behavior
+- `commerce-api/custom-api-troubleshooting` - common issues and solutions
+- `commerce-api/custom-api-status-report` - registration status details
+- `dw.system.RESTResponseMgr` - Script API response manager
+- `dw.system.Request` - Script API request object
+- `dw.system.RESTErrorResponse` - Script API error response
+- `dw.system.RESTSuccessResponse` - Script API success response
+
+## Overview
+
+A Custom API URL has this structure:
+
+```
+https://{shortCode}.api.commercecloud.salesforce.com/custom/{apiName}/{apiVersion}/organizations/{organizationId}/{endpointPath}
+```
+
+Three components are required to create a Custom API:
+
+1. **API Contract** - An OAS 3.0 schema file (YAML)
+2. **API Implementation** - A script using the B2C Commerce Script API
+3. **API Mapping** - An `api.json` file binding endpoints to implementations
+
+## Cartridge Structure
+
+```
+/my-cartridge
+    /cartridge
+        package.json
+        /rest-apis
+            /my-api-name              # API name (lowercase alphanumeric and hyphens only)
+                api.json              # Mapping file
+                schema.yaml           # OAS 3.0 contract
+                script.js             # Implementation
+```
+
+**Important:** API directory names can only contain alphanumeric lowercase characters and hyphens.
+
+## Component 1: API Contract (schema.yaml)
+
+> Illustrative minimal example; confirm current schema validation rules, security scheme structure, and scope naming requirements with `b2c docs read commerce-api/custom-api-components-references` and `b2c docs read commerce-api/custom-apis`.
+
+Minimal example:
+
+```yaml
+openapi: 3.0.0
+info:
+  version: 1.0.0
+  title: My Custom API
+components:
+  securitySchemes:
+    ShopperToken:
+      type: oauth2
+      flows:
+        clientCredentials:
+          tokenUrl: https://{shortCode}.api.commercecloud.salesforce.com/shopper/auth/v1/organizations/{organizationId}/oauth2/token
+          scopes:
+            c_my_scope: My custom scope
+  parameters:
+    siteId:
+      name: siteId
+      in: query
+      required: true
+      schema:
+        type: string
+        minLength: 1
+paths:
+  /my-endpoint:
+    get:
+      operationId: getMyData
+      parameters:
+        - $ref: '#/components/parameters/siteId'
+      responses:
+        '200':
+          description: Success
+security:
+  - ShopperToken: ['c_my_scope']
+```
+
+**Key requirements:**
+- Use `ShopperToken` for Shopper APIs (requires siteId), `AmOAuth2` for Admin APIs
+- Custom scopes must start with `c_`, max 25 chars
+- Custom parameters must have `c_` prefix
+
+### Cartridge path requirements (where the platform looks up your `rest-apis/` folder)
+
+> Illustrative of platform cartridge resolution rules; confirm current runtime behavior and site context handling with `b2c docs read commerce-api/custom-apis`.
+
+| Call shape | Cartridge path searched |
+|---|---|
+| Shopper API (`ShopperToken`) — always site-scoped | The **storefront site's** cartridge path (the site that issued the SLAS token) |
+| Admin API (`AmOAuth2`) with `siteId=<storefront-site>` | That **storefront site's** cartridge path |
+| Admin API (`AmOAuth2`) with `siteId=Sites-Site` (the special BM/organization site) | The **Business Manager** cartridge path |
+| Admin API (`AmOAuth2`) with `siteId` omitted | The **Business Manager** cartridge path |
+
+Admin APIs can be invoked in either site or organization context — the `siteId` parameter is optional, and one special value addresses the org context explicitly:
+
+- Passing a real storefront site ID (e.g. `siteId=RefArch`) runs the call in that site's context and resolves the cartridge against that site's cartridge path.
+- Passing `siteId=Sites-Site` is the literal way to invoke the Admin API against the **Business Manager / organization site**. `Sites-Site` is not a real storefront — it's the system-defined site that represents BM/org-level operations. The platform resolves the cartridge through the BM cartridge path.
+- Omitting `siteId` entirely is equivalent to org context and also resolves through the BM cartridge path.
+
+The BM cartridge path is the common gotcha: if your Admin API is intended for org-level operations (called with `siteId=Sites-Site` or with `siteId` omitted), the cartridge containing `rest-apis/` **must** be on the BM cartridge path. A typical symptom is "registers fine when called with a storefront `siteId` but 404s in org context," or never appears in `b2c scapi custom status` for the org context.
+
+Manage cartridge paths with the CLI (no BM clicks needed):
+
+```bash
+# Inspect the current BM cartridge path
+b2c sites cartridges list --bm
+
+# Add a cartridge to BM for org-context Admin APIs
+b2c sites cartridges add my_admin_api_cartridge --bm --position first
+
+# Add a cartridge to a storefront site (for Shopper APIs or site-scoped Admin APIs)
+b2c sites cartridges add my_api_cartridge --site-id RefArch --position first
+```
+
+After updating any cartridge path, re-activate the code version (`b2c code deploy --reload` or `b2c code activate <version>`) so the platform re-registers the endpoints.
+
+To set the BM cartridge path manually in Business Manager: **Administration > Sites > Manage Sites > Business Manager (link in the header) > Settings > Cartridges**.
+
+See [Contract Reference](references/CONTRACT.md) for full schema examples and Shopper vs Admin API differences.
+
+## Component 2: Implementation (script.js)
+
+> Illustrative Script API usage; confirm current Custom API integration patterns, RESTResponseMgr requirements, and request object methods with `b2c docs read commerce-api/custom-api-components-references` and Script API docs for `dw.system.RESTResponseMgr` / `dw.system.Request`.
+
+```javascript
+var RESTResponseMgr = require('dw/system/RESTResponseMgr');
+
+exports.getMyData = function() {
+    var myParam = request.getHttpParameterMap().get('c_my_param').getStringValue();
+    var result = { data: 'my data', param: myParam };
+    RESTResponseMgr.createSuccess(result).render();
+};
+exports.getMyData.public = true;  // Required
+```
+
+**Key requirements:**
+- Mark exported functions with `.public = true`
+- Use `RESTResponseMgr.createSuccess()` for responses
+- Use `RESTResponseMgr.createError()` for error responses (RFC 9457 format)
+
+See [Implementation Reference](references/IMPLEMENTATION.md) for caching, remote includes, and external service calls.
+
+## Component 3: Mapping (api.json)
+
+```json
+{
+  "endpoints": [
+    {
+      "endpoint": "getMyData",
+      "schema": "schema.yaml",
+      "implementation": "script"
+    }
+  ]
+}
+```
+
+**Important:** Implementation name must NOT include file extension.
+
+## Development Workflow
+
+1. Create cartridge with `rest-apis/{api-name}/` structure
+2. Define contract (schema.yaml) with endpoints and security
+3. Implement logic (script.js) with exported functions
+4. Create mapping (api.json) binding endpoints to implementation
+5. Deploy and **activate** the code version (`--reload`) to register endpoints — required on first registration and any contract (`schema.yaml` / `api.json`) change
+6. Check registration status and test
+7. For subsequent edits to `script.js` of an already-registered endpoint, redeploy without `--reload` — re-activation isn't needed for implementation-only changes
+
+### Deployment
+
+```bash
+# Deploy and activate to (re-)register endpoints
+b2c code deploy ./my-cartridge --reload
+
+# Deploy without re-activation (fine for implementation-only edits to already-registered endpoints)
+b2c code deploy ./my-cartridge
+
+# Check registration status
+b2c scapi custom status --tenant-id zzpq_013
+
+# Show failed registrations with error reasons
+b2c scapi custom status --tenant-id zzpq_013 --status not_registered --columns apiName,endpointPath,errorReason
+```
+
+#### When you need to re-activate the code version (`--reload`)
+
+Custom API endpoint registration is rebuilt on **code-version activation**, not on every file upload. That means:
+
+| Change | Re-activation required? |
+|---|---|
+| New endpoint, new API, or first-time registration | Yes |
+| Edits to `schema.yaml` (paths, params, security, scopes, request/response shapes) | Yes |
+| Edits to `api.json` (endpoint → implementation mapping) | Yes |
+| Adding/removing the cartridge from a site or BM cartridge path | Yes |
+| Edits to `script.js` (or any implementation/library code) for an **already-registered** endpoint | **No** — the new code is picked up live; just deploy without `--reload` |
+
+So during normal iteration on the *implementation* of an endpoint that's already registered, you can deploy repeatedly without paying the re-activation cost. Reach for `--reload` (or `b2c code activate <version>`) only when the *contract* changes or when an endpoint isn't registering yet.
+
+## Authentication Setup
+
+### For Shopper APIs
+
+1. Create a SLAS client with your custom scope(s):
+   ```bash
+   b2c slas client create --default-scopes --scopes "c_my_scope"
+   ```
+2. Obtain token via SLAS client credentials
+3. Include `siteId` in all requests
+
+### For Admin APIs
+
+1. Configure your custom scope (`c_my_admin_scope`) on the Account Manager API Client (Role: "Salesforce Commerce API")
+2. Obtain a token via Account Manager OAuth with **both** required scope types:
+   - **Tenant scope**: `SALESFORCE_COMMERCE_API:<tenant_id>` — grants access to the tenant
+   - **Custom Admin scope(s)**: `c_my_admin_scope` — as declared in `schema.yaml`
+3. Omit `siteId` from requests (or use `siteId=Sites-Site`) for org context
+
+```bash
+# b2c auth token accepts multiple scopes (repeat --auth-scope or comma-separate).
+# It does NOT auto-inject the tenant scope, so list it explicitly:
+TOKEN=$(b2c auth token \
+  --auth-scope "SALESFORCE_COMMERCE_API:zzpq_013" \
+  --auth-scope c_my_admin_scope)
+```
+
+> **Why the tenant scope matters:** the SCAPI subcommands (`b2c scapi custom status`, `b2c scapi schemas list`) inject `SALESFORCE_COMMERCE_API:<tenant_id>` for you, but `b2c auth token` and raw curl send only the scopes you pass. A token missing the tenant scope returns 403 against any Admin API (custom or system).
+
+See [Testing Reference](references/TESTING.md) for curl examples and authentication setup.
+
+## Troubleshooting
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| 400 Bad Request | Invalid/unknown params | Define all params in schema |
+| 401 Unauthorized | Invalid token | Check token validity |
+| 403 Forbidden | Missing scope | Verify scope in token. For Admin APIs the token needs **both** `SALESFORCE_COMMERCE_API:<tenant_id>` and your custom scope(s) |
+| 404 Not Found | Not registered | Check `b2c scapi custom status` |
+| 500 Internal Error | Script error | Check `b2c logs get --level ERROR` |
+| 503 Service Unavailable | Circuit breaker open | Fix errors, wait for reset |
+
+### Registration Issues
+
+- **Shopper-API endpoint not appearing:** verify the cartridge is on the **site's** cartridge path (`b2c sites cartridges list --site-id <site>`), then re-activate the code version.
+- **Admin-API endpoint called with a storefront `siteId`:** verify the cartridge is on **that site's** cartridge path.
+- **Admin-API endpoint called with `siteId=Sites-Site` (or with `siteId` omitted) returns 404 / never registers:** the cartridge must be on the **Business Manager cartridge path**. Check with `b2c sites cartridges list --bm` and add it via `b2c sites cartridges add <cartridge> --bm --position first`. Re-activate the code version after. See [Cartridge path requirements](#cartridge-path-requirements-where-the-platform-looks-up-your-rest-apis-folder) above.
+- **Check logs:** Use `b2c logs get` or filter Log Center with `CustomApiRegistry`
+
+## Related Skills
+
+- `b2c-cli:b2c-code` - Deploying cartridges and activating code versions
+- `b2c-cli:b2c-scapi-custom` - Checking Custom API registration status
+- `b2c-cli:b2c-slas` - Creating SLAS clients for testing Shopper APIs
+- `b2c:b2c-webservices` - Service configuration for external calls
+
+## Reference Documentation
+
+- [Contract Reference](references/CONTRACT.md) - Full schema.yaml examples, Shopper vs Admin APIs
+- [Implementation Reference](references/IMPLEMENTATION.md) - script.js patterns, caching, remote includes
+- [Testing Reference](references/TESTING.md) - Authentication setup, curl examples

package/node_modules/@salesforce/b2c-agent-plugins/b2c/skills/b2c-custom-api-development/evals/trigger-evals.json

@@ -0,0 +1,12 @@
+[
+  {"query": "I need to create a REST endpoint that our mobile app can call to get personalized product recommendations. The endpoint should accept a customer ID and return a JSON array. How do I set up the cartridge folder structure with the api.json and schema files?", "should_trigger": true},
+  {"query": "My custom API endpoint returns 404 after deploying the cartridge. I've checked the code version is active and the cartridge is on the path. How do I verify the endpoint is registered and debug why it's not being found?", "should_trigger": true},
+  {"query": "I'm writing the OpenAPI 3.0 schema.yaml for my custom endpoint. It needs to accept a JSON body with an array of product IDs and return enriched product data. What are the supported schema features and any limitations I should know about?", "should_trigger": true},
+  {"query": "Our headless storefront needs a custom endpoint that combines data from multiple system objects into a single response. How do I use the script context in a custom API to access things like ProductMgr and CustomerMgr, and what's the right way to return the response?", "should_trigger": true},
+  {"query": "I need to set up OAuth scopes for my custom API so that only authenticated shoppers can call it, not guest users. How do I configure the scope in SLAS and reference it in my api.json?", "should_trigger": true},
+  {"query": "We're migrating from OCAPI to headless and need to replicate three custom OCAPI endpoints as custom SCAPI endpoints. What's the mapping between OCAPI hook patterns and the custom API script approach?", "should_trigger": true},
+  {"query": "How do I call an external payment gateway API from my B2C Commerce script? I need to set up a service with credentials and make an HTTP POST with a JSON body.", "should_trigger": false},
+  {"query": "I need to configure OCAPI permissions so our OMS can read and update orders via the Data API. Where do I set up the client ID permissions in Business Manager?", "should_trigger": false},
+  {"query": "How do I create a controller endpoint on the storefront that returns JSON for an AJAX autocomplete search? It needs to handle GET requests with a query parameter.", "should_trigger": false},
+  {"query": "I want to add a typed API client to the b2c-tooling-sdk that wraps the Shopper Search API. How do I generate types from the OpenAPI spec and set up the client factory?", "should_trigger": false}
+]