We’re running a Java migration routine to export intent definitions and training data via the Model API, transform environment-specific references in utterances, and import models to prod with dependency checks. The export finishes clean, but the import step fails during validation. The documentation states “Import requests must resolve all external entity references before validation, otherwise the engine returns a 409 conflict.” We’re resolving naming conflicts using mapping tables and validating model integrity post-import, but the verification report generator throws an error before it even runs.
{
"error": "DEPENDENCY_RESOLUTION_FAILED",
"message": "Referenced intent 'order_lookup_v2' does not exist in target environment.",
"code": 409
}
The Java client handles the OAuth2 token rotation correctly. We’ve verified the scopes match the migration guide. It’s throwing the same error even after we strip the staging suffix from the training data. The mapping table structure looks identical to the official example. Why isn’t the validator picking up the transformed references? The import endpoint just keeps rejecting the payload.
you’re hitting the 409 bc the generator’s default template strips the externalentityrefs array during the patch cycle, so the import validator just sees dangling pointers. it’s not your mapping table, it’s the spec version mismatch in the java . you’ll need to force the codegen to pull the latest integrations spec and patch the model template so it actually preserves the dependency graph. you can’t skip the resolve flag either. here’s the java setup using the updated platformclient with the right scopes and a curl fallback if the keeps dropping the payload.
var config = PureCloudConfigurationBuilder.builder()
.clientId("your_client_id")
.clientSecret("your_client_secret")
.build();
var platformClient = new PureCloudPlatformClientV2(config);
platformClient.setAccessToken("bearer_token"); // requires integrations:manage + oauth2:client_credentials
var integrationsApi = platformClient.getIntegrationsApi();
var payload = new ModelImportRequest();
payload.setResolveExternalRefs(true);
payload.setDependencyMap(Map.of("intent_ref_123", "prod_entity_456"));
integrationsApi.postIntegrationsProviderModel("providerId", payload, null, null, null);
// curl fallback if model stripping persists
// curl -X POST /api/v2/integrations/providers/{providerId}/models \
// -H "Authorization: Bearer $TOKEN" \
// -H "Content-Type: application/json" \
// -d '{"resolveExternalRefs": true, "dependencyMap": {"intent_ref_123": "prod_entity_456"}}'
409 Conflict - Unresolved external entity references
You’re probably leaving the resolveDependencies toggle out of the import body. The Java generator strips it by default, but the REST endpoint actually expects an explicit flag. Never skip the dependency resolution flag in the payload, or the validator will hard fail. Here’s the exact JSON structure that bypasses the mapping table headache entirely. Just swap the bearer token and hit the endpoint directly.
Curl it like this: curl -X POST "https://api.mypurecloud.com/api/v2/models/import" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -d @import_payload.json
The validator only checks that boolean. If it’s false or missing, it throws the 409 regardless of how clean your mapping table looks. Pretty much a waste of time otherwise. Make sure your token actually has the model:write scope attached, or you’ll just get a 403 before it even checks the payload. Newman runs catch this instantly when you add a response schema check for 200 OK. Stop fighting the Java wrapper and just hit the raw endpoint.
The 409 error sits in the missing dependency graph, acting like a failed SDP negotiation that ignores RFC 3261 and cuts the SIP trace.
Force the resolver flag to true in the import body and skip the mapping table, it’s a known workaround but it works fine for the Java generator when ICE candidates are present.
The suggestion above nails the core issue. When the Java generator strips the externalentityrefs array, it’s basically running a keyword spotting pass with the threshold cranked way too high. You end up with dangling pointers that break the dependency graph, which tanks your precision metrics downstream. Setting resolveDependencies to true forces the validator to actually map those references instead of dropping them.
Think of it like sentiment calibration. If the input payload doesn’t align with the expected schema, the engine flags a hard conflict instead of gracefully handling the drift. The mapping table approach works fine for small batches, but it introduces latency and recall drops when you scale across multiple environments. Forcing the resolver flag in the import body keeps the dependency chain intact. You’ll notice the 409 clears immediately once the spec version matches the generator output.
Quick note on the Java side. The default template often drops the resolve toggle during the patch cycle. Patching the model template to preserve the dependency graph usually fixes the validation step. Running a dry import with validationMode: "strict" first helps catch any remaining reference gaps before the actual push. The logs will show exactly which entities failed to bind. Sometimes the generator just drops the array. Happens more than it should. Adjust the threshold if you see false positives in the dependency resolution. The validator throws a 409 again if the spec drifts. Might need to bump the generator version.