adobe avatar

adobe-for-developers

Search the developer.adobe.com docs. Manage Adobe Developer Console projects, workspaces, APIs, and credentials. Create and test I/O Events registrations and subscriber defined filters.

version
1.0.0
GitHub stars
332

Install

/plugin install adobe-for-developers@adobe-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add adobe/skills.

Contents

Discovered from source

Skills 7

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

Console Context Navigator

Track and display the user's current location in Adobe Developer Console. Every reply includes a live breadcrumb that grows as the user drills deeper.

Breadcrumb format

Always place this on the very first line of every reply:

📍 [Org: {orgName} ({orgId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})] › [Workspace: {workspaceName} ({workspaceId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})] › [Workspace: {workspaceName} ({workspaceId})] › [Credential: {credentialName} ({credentialType}) ({credentialId})]

Rules:

  • Start with only what's confirmed — never show a placeholder or "unknown"
  • Grow the breadcrumb as each level is selected, never shrink it
  • Show name and ID together (e.g. My Org (12345)) — never show just raw IDs alone
  • If the user changes selection at any level, update from that level forward

Project information requests

Use this flow whenever the user asks for information about a particular project:

  • Reuse confirmed organization and project context. Resolve only missing context with get_organisations or get_projects. If the user names a project without its ID, use get_projects with filterBy: "all" to find it; ask for a selection only if the target is ambiguous.
  • Call get_project_by_id with orgId and projectId. It pulls in profile information for the users who created or modified the project.
  • Show the requested details from that response: project name/title, description, type, enabled/deleted status, creation/modification dates, and creator/modifier information when present. Do not infer missing details.
  • For an information-only request, stop at project level. Do not fetch workspaces or credentials unless the user also asks for them.

Navigation flow

Step 1 — Org

Call get_organisations. If more than one org is returned, show them as a numbered list and ask the user to pick. If only one, select it automatically and note: "Using org: {orgName}".

Step 2 — Project

If the user wants to create a new project, do not list existing projects; hand off to dev-console-create-project, preserving the selected org context.

For project-information requests, use the flow above instead of project browsing.

Follow the shared option-selection rules to resolve project reuse, creation, and empty results.

When a project lookup is needed, call get_projects with filterBy: "all" unless the user asked for only their projects (filterBy: "me"). An empty "mine" result does not establish that the organization has no projects.

For project browsing:

  • Sort the returned projects by date_last_modified, newest first. Put missing or invalid dates last without inventing timestamps.
  • Show at most 10 projects per batch as a clean numbered list (title + last modified date, no raw IDs). State the displayed range and total, for example "Showing 1-10 of 27 projects, most recently modified first."
  • Offer "Show more" only when unseen projects remain. On request, show the next batch of up to 10 projects with continuous numbering; do not repeat earlier entries.
  • get_projects returns an array; retain that response for the selected organization and filter and reuse it for subsequent display batches rather than refetching. Restart browsing when the organization or filter changes.
  • Resolve a project named by the user against the entire returned list, not just the displayed batch. Likewise, use the full result for empty-list and single-option decisions.

Step 3 — Workspace

Reuse a confirmed workspace selection or workspace details returned by project creation; otherwise call list_workspaces for the chosen project. If only one workspace is returned (default projects always have a single Production workspace), select it automatically without asking. If multiple workspaces exist, show them as a numbered list and ask the user to pick.

Step 4 — Credential (optional)

If the user wants to go deeper, call get_credentials for the chosen workspace. For each credential also call get_credential_services to show subscribed APIs. Include, for each credential: name, type, client ID (if applicable), and subscribed APIs (or "none yet"). The layout below is a reference for content, not a literal template — adjust formatting as needed for the client:

🔑 Credential: "My S2S Cred"  (OAuth Server-to-Server)
   Client ID:  xxxxxxxxxxxxxxx
   APIs:       Adobe Analytics, Firefly API

🔑 Credential: "My Web Cred"  (AdobeId / WebApp)
   APIs:       none yet

Ask the user which credential to work with, or say "none" to stay at workspace level.

Context summary

Once the full context is set, summarize it for the user before proceeding — org, project, workspace, and credential (if selected), each with name and ID together. Box-drawing layouts like the one below don't render reliably in every client (e.g. Claude Desktop), so treat it as a reference for what to include, not a literal template to reproduce — a plain list or short paragraph is fine:

📍 Console Context
Org:         My Org Name  (12345)
Project:     My Project  (111222333444555666)
Workspace:   Production  (777888999000111222)
Credential:  My S2S Cred (OAuth S2S)  (99001)

When Instructions Are Unclear

If the user references an Adobe concept, project type, or Console feature you're unsure about — call search_adobe_docs before asking for clarification. For example:

  • Unsure what a project type means → search "Adobe Developer Console project types App Builder default"
  • User mentions a workspace concept you don't recognise → search "Adobe Developer Console workspace"
  • Unclear what a credential field means → search "Adobe Developer Console credential {field name}"

Always prefer fetching from official docs over guessing.


Rules

  • If the user says something like "switch project" or "go back", reset from that level and re-navigate
  • This skill sets context — it does not subscribe APIs. For subscribing, hand off to /dev-console-subscribe-api with the established context

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

Create Project

Create and initialize an Adobe Developer Console project in the user's selected organization. Both project types use the same flow and the same create_project tool; only the projectType argument differs.

Steps

  1. Resolve the project type from explicit user signals — Use only explicit instructions for the project being created, from the current request or earlier conversation. Follow the most recent explicit instruction:

    • The user explicitly requests "App Builder" or a "template" project → projectType: "appBuilder".
    • The user explicitly requests a default/empty project or rejects App Builder/templates → projectType: "default".
    • No explicit App Builder/template request for this project → projectType: "default".

    Never infer App Builder from requested APIs, credentials, runtime features, project names, other skills, or prior projects. Unrelated or negated mentions of "App Builder" or "template", including documentation discussions, do not count as a request. Do not ask the user to choose or confirm the project type.

    Steps 2–5 are identical for both types.

  2. Select an organization — Reuse the org if it has already been selected in this request. Otherwise call get_organisations. If multiple organizations are returned, show their names as a numbered list and ask the user to choose. If only one is returned, select it automatically and tell the user which organization will be used. Keep IDs internal; use the selected organization's id as orgId.

  3. Resolve project naming — Follow the shared naming rules.

  4. Create and initialize the project — Call create_project once with the selected orgId, name, title, and the projectType from step 1. Do not pass a template ID or workspace details; the tool sets up the project for the chosen type:

    • Default project: creates the project with its default workspace.
    • App Builder template project: creates the project from the App Builder template together with Production and Stage workspaces, both with runtime enabled.
  5. Report the result — On success, explicitly state the created project's title and type:

    • Default: "Created {title} as a default project."
    • App Builder: "Created {title} as an App Builder template project, with Production and Stage workspaces, both with runtime enabled."

    Retain the returned projectId and any workspace IDs for follow-up, but do not display raw IDs. If the response does not include workspace details, call list_workspaces for the created project. If the response includes console_url, display it as: 🔗 View in Adobe Developer Console: {console_url}

If the user also wants to subscribe an API, continue with dev-console-subscribe-api skill using the created org, project, and workspace context. For an App Builder template project with more than one workspace, ask which workspace to use (Production or Stage) unless the user already said. Do not ask the user to select or re-enter IDs already returned by project creation.

Rules

  • This skill creates a project only; it does not create credentials or subscribe APIs.
  • Do not call create_project until the project type, organization, and project name are known.
  • Do not ask for custom workspace names, descriptions, or template choices; the connector does not accept them.
  • If project creation reports that Adobe Developer Terms have not been accepted, ask the user to review the terms and explicitly confirm agreement before calling accept_developer_terms. Then retry project creation once.
  • Do not claim success if the tool returns an error or an ambiguous result.

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

Subscribe API Flow

Guide the user through subscribing an Adobe API to a credential in an existing project, step by step.

Before starting: invoke the dev-console-context skill to establish the org, project, and workspace. If the user wants a new project, invoke dev-console-create-project first and continue with the context it returns. After the workspace is selected or created, call get_credentials and immediately call get_credential_services for each returned credential before presenting the credentials and their subscriptions. Do not repeat these calls if the context skill already made them during this request.

Steps

  1. Find the API — If the user asks "what APIs are available", "show me available APIs", or similar, call list_services with filterBy: "enabled" and display only the enabled APIs as a list (name + description, no raw codes). If the user named a specific API, call list_services with filterBy: "enabled" to find its code and full details. Never guess an SDK code.

  2. Pick credential type — Always validate against the API's supported types — never skip this check because an existing credential was found. An API can have multiple enabled instances with different type values. Collect ALL enabled instances for the API code. Reuse a type already specified by the user if it is supported; otherwise:

    • Include admin_entp instances as Admin Enterprise credentials; do not filter them out or redirect the user to Console for creation or subscription.
    • If only one credential type → proceed with it automatically, including when that type is Admin Enterprise.
    • If multiple credential types → show them as a numbered list and ask: "This API supports multiple credential types. Which would you like to use?"
      1. Analytics credential (internal: analytics) — if an analytics instance is present
      2. User Auth (AdobeId) — for user-facing apps (internal: adobeid)
      3. OAuth Server-to-Server — for server-to-server access (internal: oauth_server_to_server, also used for entp)
      4. Admin Enterprise (internal: admin_entp) — if an admin_entp instance is present
    • Wait for the user to pick when multiple supported types remain unresolved. Do not auto-select based on what credentials already exist in the workspace.
    • Show only credential type names in this list — never mention existing credentials here. Do not append "subscribe to the existing X credential" or any reference to existing workspace credentials. Existing credential lookup happens after the type is chosen.
  3. Check for product profiles — After the credential type is decided, inspect its properties.licenseConfigs array from the matching API instance:

    • If it is non-empty: present the profiles as a numbered list (show name, never raw id or productId) and tell the user: "You can select one or more of these profiles." Collect their choices — you'll need the selected profiles' id and productId fields when subscribing.
    • If it is empty or absent: continue with no licenseConfigs.
    • This step must complete before any credential creation or subscription call — even when creating a new credential. Never pass services to create_oauth_s2s_credential until licenseConfigs have been resolved.
  4. Subscribe — Use a credential of the selected type from the chosen workspace. If several matching credentials exist, ask the user to choose by credential name. If none exists, create one using Credential creation inputs below. For a newly created project, use the selected workspace ID from the creation/context flow for every credential creation and subscription call. For an App Builder project, preserve the user's Production or Stage selection; never replace a selected Stage workspace with Production. Automatically use Production only for a default project with a single workspace. If no workspace has been selected, use the returned workspace details or call list_workspaces to resolve the selection before proceeding. If the selected type is User Auth (AdobeId), call list_workspaces to confirm the selected workspace before creating that credential; this confirmation must not change the user's selection.

    Admin Enterprise credential (admin_entp):

    • For a new credential, call create_admin_enterprise_credential with orgId, projectId, workspaceId, the creation inputs below, and services including any product profiles selected in step 3. This creates the credential and subscribes the API in one call.
    • For an existing credential, call subscribe_admin_enterprise_credential_to_services with orgId, credentialId, and services including any product profiles selected in step 3. No project or workspace ID is required by this tool; choose only a credential from the selected workspace.
    • Pass only the services to add or change. The connector fetches existing subscriptions and merges them before calling the replacement PUT endpoint, preserving other APIs. For an already-subscribed SDK code, include all intended license configs and roles (existing plus new), because that service's settings are replaced.
    • update_admin_enterprise_credential changes only the credential's name, description, and redirect settings; it does not add, replace, or remove API subscriptions. Never call it to subscribe an API or report a subscription success based on its response.
    • Do not pass admin_entp to subscribe_credential_to_services; that tool does not support it.

    OAuth Server-to-Server credential (oauth_server_to_server) → call subscribe_credential_to_services:

    • Pass orgId, projectId, workspaceId, credentialType: "oauth_server_to_server", credentialId, and services.
    • Each service entry must include licenseConfigs if the user selected product profiles in step 3. An empty licenseConfigs: [] is NOT the same as omitting it — pass the user's selections.
    • The credentialType must always match the credential's actual type (oauth_server_to_server), never the API's type (entp).

    Other credential types (adobeid, analytics, entp, oauth_server_to_server) use subscribe_credential_to_services (PUT). The server automatically preserves all already-subscribed services — only pass the service(s) you want to add or change; do NOT pre-fetch and re-send the full existing list. Preservation is per-service, not per-licenseConfig: if you're adding a licenseConfig to an already-subscribed service, include that service's full intended licenseConfigs list (existing plus new), not just the new one.

  5. Report success — If the subscription tool succeeds, report success without a separate verification call. For Admin Enterprise service tools, the DTO-derived JSON body uses sdkList, error, and errorDetails (not errorList). HTTP 200 can contain partial failures: the connector returns an MCP error if either error array is non-empty, including the failed SDK codes and returned SDK list. Some changes may already have applied; inspect current subscriptions before retrying and never automatically retry the whole list. For Admin Enterprise creation, inspect subscriptionResult when present; do not report an API as subscribed if it appears in errorList or its subscription is otherwise unconfirmed. "✓ [API name] has been successfully subscribed to your [credential type] credential." List the APIs confirmed by the response. The services array may contain only additions, so do not present it as the full current list. Only call get_credential_services if the response is ambiguous or an error was returned.

Credential creation inputs

When no credential exists and one must be created, apply the Common Skill Rules for names, titles, and descriptions. Preserve valid user-supplied values; otherwise derive the missing name using the pattern {projectName}-{type}[-{subtype}], without a naming prompt:

Credential typePlatform / subtypeAuto-generated name example
OAuth S2S—mcptesting-s2s
Admin Enterprise—mcptesting-admin-enterprise
AdobeIdWebAppmcptesting-adobeid-webapp
AdobeIdSinglePageAppmcptesting-adobeid-singlepageapp
AdobeIdNativeAppmcptesting-adobeid-native
AdobeIdapiKeymcptesting-adobeid-apikey
AnalyticsWebmcptesting-analytics-web
AnalyticsiOSmcptesting-analytics-ios
AnalyticsAndroidmcptesting-analytics-android

For a missing description, use: "{Type} credential for {projectTitle}" (e.g. "OAuth S2S credential for mcptesting").

For generated names, use lowercase letters, digits, and hyphens, and truncate to 50 characters if needed. Do not silently modify user-supplied values; follow the shared validation and fallback rules.

OAuth Server-to-Server (create_oauth_s2s_credential)

  • Use the name and description resolved above. No further input needed — proceed directly to creation.
  • Never pass services to create_oauth_s2s_credential — always create the credential first (no services), then subscribe in a separate subscribe_credential_to_services call. Inline service attachment is unreliable and causes confusing retry flows.

Admin Enterprise (create_admin_enterprise_credential)

  • Use the name and description resolved above.
  • Ask for defaultRedirectUri (the OAuth callback URL) and redirectUriPattern (the regex for allowed redirect URIs). Never invent placeholder values or use an unrestricted pattern by default.
  • Pass the selected API in services, including product profiles selected in step 3. Do not make a separate subscription call after successful inline subscription.

User Auth — AdobeId (create_user_auth_credential)

  • Use the name and description resolved above.
  • Resolve platform from the matching API instance's platformList, when provided, and documented API support.
    1. WebApp — web application
    2. SinglePageApp — SPA/React/Angular app
    3. NativeApp — desktop or mobile app
    4. apiKey — server-side API key access
    

Before asking for platform, if available_scopes is present:

  • Display a table of available scopes and tell the user: "All scopes are granted by default and cannot be deselected."

Platform-specific inputs — NEVER invent placeholder values, always wait for the user:

  • WebApp / SinglePageApp: ask for both:
    1. defaultRedirectUri — plain URL (e.g. https://example.com/callback)
    2. redirectUriList — one or more redirect URI patterns; pass as plain URLs, the server escapes dots automatically
  • NativeApp: no extra inputs required — proceed directly.
  • apiKey: ask for domain. No redirect URI needed.

Analytics (create_analytics_credential)

  • Use the name and description resolved above.
  • Resolve platform from the matching API instance's platformList, when provided, and documented API support. Filter the following platform labels before offering a choice:
    1. Web — web app
    2. iOS — iOS mobile app
    3. Android — Android mobile app
    

Platform-specific inputs — NEVER invent placeholder values:

  • Web: ask for both:
    1. defaultRedirectUri — plain URL (e.g. https://example.com/callback)
    2. redirectUriList — one or more redirect URI patterns; pass as plain URLs, the server escapes dots automatically
  • iOS: ask for urlScheme. No redirect URI needed.
  • Android: no extra inputs required — proceed directly.

After creating a credential that needs a separate subscription call, use its returned id as credentialId. Admin Enterprise creation already includes the requested services. Never re-fetch credentials after a fresh creation.

Whenever any tool response includes a console_url field (credential creation or subscription), always display it to the user as a clickable link:

🔗 View in Adobe Developer Console: {console_url}

When Instructions Are Unclear

If you're unsure about an API, credential type, product profile, or Adobe concept during this flow — call search_adobe_docs before asking the user to clarify. For example:

  • User asks to subscribe an API you don't recognise → search "Adobe {API name} API developer documentation"
  • Unclear what scopes or product profiles an API requires → search "Adobe {API name} OAuth scopes product profile"
  • Unsure which credential type fits the user's use case → search "Adobe Developer Console credential types OAuth S2S user auth"

Always prefer fetching from official docs over guessing.


Rules

  • entp APIs (e.g. Adobe Campaign) use an OAuth S2S credential. Never show "entp" to the user.
  • admin_entp instances are selectable as Admin Enterprise credentials. Use create_admin_enterprise_credential for creation with inline services and subscribe_admin_enterprise_credential_to_services to add or update APIs on existing credentials. API removal is handled by dev-console-unsubscribe-api skill. update_admin_enterprise_credential only updates credential details and does not change subscriptions.
  • Always use the API type field to determine credential type. Completely ignore oauthServerToServerOnly. Mapping: adobeid → create_user_auth_credential, analytics → create_analytics_credential, entp → create_oauth_s2s_credential, oauth_server_to_server → create_oauth_s2s_credential, admin_entp → create_admin_enterprise_credential.
  • Never skip step 2. Credential type must be chosen based on the API's supported types every time — not inferred from what credentials already exist in the workspace.
  • Never show raw IDs (licenseConfigId, credentialId, productId) to the user — use names instead.
  • Integrations and credentials are the same concept. The get_credentials response uses id_integration as the credential ID — use this value wherever credentialId is required in any tool call. integration_name is the credential's display name.
  • Never use internal jargon — present licenseConfigs as "product profiles" to the user.
  • Never skip product profile selection. If properties.licenseConfigs is non-empty for an API, always complete step 3 and include the selected licenseConfigs in the services array — both when subscribing to an existing credential and when creating a new one. An omitted or empty licenseConfigs means the subscription will have no product profile attached.
  • list_services returns a very large payload that exceeds the inline token limit. When you need to find an API code or inspect its details, search the saved file with a shell command (e.g. python3 -c "import json; ..." filtering by name/code) rather than reading the full response inline.

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

Unsubscribe API Flow

Remove one or more API subscriptions from a credential in the selected workspace.

Before starting: invoke the dev-console-context skill to establish the org, project, and workspace context, reusing any selected credential. Otherwise, resolve the credential here: list credentials in the selected workspace and inspect each with get_credential_services before offering a selection. Offer only credentials subscribed to the requested API, or credentials with any subscription if no API was specified.

Steps

  1. Confirm the target — Resolve the requested API or APIs from get_credential_services; ask for a selection only if the target is unresolved. Show API, credential, and project names only; never show raw IDs or SDK codes. Only offer currently subscribed APIs. If none match the request, report that without offering an unsubscription.

  2. Explain the change and request approval — Before calling a tool, summarize the API name(s), credential name, and project name that will be affected, and say that the change has no automatic undo. Do not ask the user to type a name or provide a typed confirmation. The client's Yes/No approval prompt is the confirmation.

  3. Remove the subscription:

    • For credential types adobeid, analytics, entp, and oauth_server_to_server, call unsubscribe_credential_from_service with orgId, projectId, workspaceId, the credential's actual credentialType, credentialId, and the selected API's sdkCode in sdkCodes.
    • For Admin Enterprise (admin_entp), call unsubscribe_admin_enterprise_credential_from_service with orgId, credentialId, and one service item containing the selected API's sdkCode plus any required subscription settings. Use the existing subscription details; do not invent settings. Make one call per API so the client can approve each removal separately.
    • Never emulate unsubscription by sending a reduced service list to a subscription or update tool. For OAuth Server-to-Server, always use unsubscribe_credential_from_service; it selects the dedicated upstream unsubscribe path.
    • If the user declines a client approval prompt, stop without retrying or working around it.
  4. Report the result — Report removal only when the tool confirms success. For Admin Enterprise, inspect the returned status and body for failures before claiming success. For other credential types, use the tool's returned remaining APIs when available; do not make a verification call unless the response is ambiguous or an error occurred.

Rules

  • Use the credential's actual type, not the API's type. In particular, an API with type entp may be subscribed to an OAuth Server-to-Server credential.
  • For Admin Enterprise, update_admin_enterprise_credential changes credential details only; it cannot remove an API subscription.
  • If an API's identity or required Admin Enterprise subscription settings are unclear, inspect the available subscription details or call search_adobe_docs. Never guess an SDK code or settings.

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

I/O Events — Filtering & Sample Events

Before starting: invoke the io-events-registration skill.

Sample Events Flow

Trigger when the user asks about sample events, wants to test their registration, or says things like "show me a sample event", "test my registration", "what does the event look like", "send a test event".

Step 1 — Check availability

Call check_sample_event with providerId and eventCode.

  • If { available: false } → tell the user: "No sample event is available for this event type." and stop.
  • If { available: true } → proceed to Step 2.

Step 2 — Ask the user

"A sample event is available. Would you like to: 1. View the sample payload 2. Send it to your registration as-is (for testing) 3. Send a custom version of it (edit the payload before sending) 4. All of the above"

Step 3a — View sample payload

Call get_sample_event with providerId and eventCode. Display the result:

📦 Sample Event

Format:  cloud_events_v1
Payload:
{
  "specversion": "1.0",
  "type": "ai_cloud_docs_deleted",
  ...
}

Step 3b — Send to registration (as-is)

Call get_registrations_for_workspace to fetch existing registrations. Show as a numbered list and ask the user to pick one:

1. My Journal Reg     (journal)   ID: reg-abc123
2. My Webhook Reg     (webhook)   ID: reg-def456

Call post_sample_event with providerId, eventCode, registrationId and no custom payload.

  • If { posted: true } → "✓ Sample event sent to your registration successfully."
  • If { posted: false } → "This event type does not support posting sample events."

Step 3c — Send a custom event

Call get_sample_event to fetch the sample payload (if not already done in Step 3a).

To determine the format, use event_delivery_format from the provider returned by list_event_providers — not the format field on the sample payload.

CloudEvents format (event_delivery_format === "cloud_events_v1"):

Parse sample_payload as JSON and show the user every field — marking type and source as read-only (Adobe enforces these server-side):

📦 Sample Event — customise before sending:

Editable:
  specversion:      "1.0"
  id:               "abc-123"
  time:             "2026-06-30T10:00:00Z"
  datacontenttype:  "application/json"
  data:             { ... }

Read-only (set by Adobe):
  type:    "{type value}"
  source:  "{source value}"

Change any editable field and I'll send it.

Wait for the user's changes. Build the final payload by merging their edits with the canonical type and source from the original sample.

Other formats (event_delivery_format is not "cloud_events_v1"):

Show the full sample_payload as editable — user can change any field including envelope fields. No restrictions apply.

Once ready, confirm before sending:

I'll send this custom event to your registration. Proceed?

Call get_registrations_for_workspace if a registration hasn't been selected yet → show list → user picks.

Call post_sample_event with providerId, eventCode, registrationId, and payload set to the merged payload.

  • If { posted: true } → "✓ Custom event sent to your registration successfully."
  • If { posted: false } → "This event type does not support posting sample events."

Subscriber Filter Flow

Trigger when user says "add filter", "create filter", "subscriber filter", "filter events", "define filter", "filter registration", "validate filter".

Subscriber Defined Filters use AWS Event Ruler JSON syntax to match against event payloads. Only events that match the filter reach the registration's endpoint.


Step F1 — Resolve registration context

If consumerOrgId, projectId, workspaceId are not already known, invoke the io-events-registration skill Step 1 first.

Call get_registrations_for_workspace to get all registrations. Then validate eligibility:

Step F1a — Filter by delivery type

Exclude any registration with delivery_type: "aws_eventbridge" — AWS EventBridge handles its own filtering natively.

Step F1b — Validate CloudEvents v1 format

For the remaining registrations, collect all unique provider_id values from their events_of_interest. Call list_event_providers with consumerOrgId and imsOrgCode to get provider details.

For each provider, check its event_delivery_format field:

  • "cloud_events_v1" → eligible ✅
  • "adobe_io" → not eligible — Subscriber Defined Filters are not supported for the Adobe I/O format ❌
  • Any other value (or missing) → not eligible ❌

A registration is fully eligible if all its providers use "cloud_events_v1". A registration is partially eligible if only some providers do — show it but warn that events from "adobe_io" providers will be delivered unfiltered. A registration is ineligible if none of its providers use "cloud_events_v1" — exclude it.

Step F1c — Show eligible registrations

Eligible: 1. My Journal Reg (journal)  2. My Webhook Reg ⚠️ (webhook)
Not eligible: ✗ My EventBridge Reg (aws_eventbridge)

Ask the user to pick from the eligible list only.

If no eligible registrations exist, tell the user:

Subscriber Defined Filters are only supported for journal, webhook, and runtime action
registrations whose events use the CloudEvents v1 format.

None of your current registrations are eligible. Create an eligible registration first.

If the user picks a partially eligible registration, warn before proceeding:

⚠️  One or more providers in this registration do not use CloudEvents v1 format.
    Filters will only apply to events from eligible providers.
    Events from other providers will be delivered unfiltered.

Step F1d — Check for existing filter

Call get_subscriber_filters on the selected registration. Only one filter is allowed per registration.

  • If a filter already exists → tell the user:

    ⚠️  This registration already has a Subscriber Defined Filter:
        Name:       {name}
        Expression: {subscriber_filter}
    
    Only one filter is allowed per registration.
    Would you like to update the existing filter instead?
    

    If yes → redirect to the Update Filter Flow (Step U3, skipping U1 and U2). If no → stop.

  • If no filter exists → proceed to Step F2.


Step F2 — Introduce the DSL and show available patterns

Call get_subscriber_filter_patterns to retrieve all supported patterns.

Explain briefly: Adobe I/O Events uses the AWS Event Ruler DSL — you write a JSON expression matched against each event's payload, and only matching events are delivered.

Show the patterns as a numbered list using the name from each entry. Ask which pattern the user would like to use.


Step F3 — Show the example for the chosen pattern

Find the entry in the get_subscriber_filter_patterns response whose name matches what the user picked. Display its value as formatted JSON:

Here is an example for "{patternName}":

{value as pretty-printed JSON}

Then ask:

"Would you like to create a filter like this for your registration, or combine multiple patterns?"


Step F3.5 — Offer a sample event payload for reference

After showing the pattern example, ask:

"Would you also like to see a real sample event payload? This can help you identify the exact field names to use in your filter."

If the user says yes:

  1. From the registration selected in Step F1, get the events_of_interest list (call get_event_registration if not already in context).
  2. If multiple event types, show them as a numbered list and ask which one to preview.
  3. Call check_sample_event with providerId and eventCode.
    • If { available: false } → "No sample payload is available for this event type."
    • If { available: true } → call get_sample_event and display:
📦 Sample Event Payload

Format:  {format}
Payload:
{sample_payload as pretty-printed JSON}

Use the field names from this payload in your filter expression.
Top-level CloudEvent fields (specversion, id, source, type, datacontenttype, time)
can be referenced directly. Event-specific data lives under the "data" key.
  1. Proceed to Step F4.

Step F4 — User writes the filter expression

Ask:

"Write your filter expression in Event Ruler JSON. Conditions on different fields are implicitly AND-ed together."

If the user is unsure, offer to help build it field by field:

"What field in the event payload do you want to filter on? (e.g. data.status, type, source)"


Step F5 — Validate the filter

Call validate_subscriber_filter with:

  • consumerOrgId, projectId, workspaceId, registrationId from context
  • subscriber_filter: an object with name: "validation-check" and subscriber_filter: the user's expression string

If validation succeeds (200):

✓ Your filter expression is valid!

It will match events where:
  {plain-English summary of the filter}

Would you like to go ahead and create this filter?

If validation fails (400):

✗ The filter expression has an issue:
  {error message from the API}

Please correct the expression and try again.

Return to Step F4 if the user wants to fix it.


Step F6 — Resolve filter metadata

Once the user confirms creation in Step F5, apply the shared naming rules using the validated filter's conditions as context.


Step F7 — Create the filter

Call create_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, name, description, and subscriber_filter.

Report:

✓ Subscriber filter created!

   Name:        {name}
   ID:          {id}
   Expression:  {subscriber_filter}

Events that match this filter will now be delivered to registration "{registrationName}".

Managing existing filters

User intentAction
"show my filters" / "list filters"Call get_subscriber_filters → display as numbered list with name, ID, expression
"view filter" / "get filter details"Call get_subscriber_filter with the filter ID
"delete filter" / "remove filter"Run the Delete Filter Flow below

Delete Filter Flow

Step D1 — Pick registration

Call get_registrations_for_workspace → show all registrations. Ask the user to pick one.

Step D2 — Show available filters

Call get_subscriber_filters. Display as a numbered list:

Filters on "{registrationName}":
1. My Status Filter  (ID: 497f6eca-…)  {"data":{"status":[{"equals":"published"}]}}

If no filters exist → "This registration has no subscriber filters to delete." and stop.

Step D3 — Announce the deletion

Once the user picks a filter, tell them which one is about to be deleted and that it can't be undone:

"This will permanently delete the filter {name} from {registrationName}."

Do not ask them to type the filter name. The client shows its own Yes / No approval prompt when you call the tool; that prompt is the confirmation.

Step D4 — Delete

Call delete_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, and subscriberFilterId. If the user declines the approval prompt, stop — do not retry or work around it — and ask what they would like to do instead.

Report: "✓ Filter "{name}" deleted successfully."


Update Filter Flow

Step U1 — Pick registration

Call get_registrations_for_workspace → show all registrations. Ask the user to pick one.

Step U2 — Pick filter

Call get_subscriber_filters. Display as a numbered list. If no filters exist → redirect to Step F2.

Step U3 — Show current filter and pick a new pattern

Display the current filter, then call get_subscriber_filter_patterns and show the pattern list as in Step F2.

Step U4 — Show pattern example — same as Step F3. Optionally offer a sample event payload (Step F3.5).

Step U5 — User writes the new filter expression — same as Step F4.

Step U6 — Validate — same as Step F5. Loop back to Step U5 if invalid.

Step U7 — Preserve or explicitly update metadata

Apply the shared naming rules for metadata updates. If a requested metadata change is ambiguous, ask only for the missing information.

Step U8 — Call update

Call update_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, subscriberFilterId, name, description, and the new subscriber_filter.

Report:

✓ Subscriber filter updated!

   Name:        {name}
   ID:          {subscriberFilterId}
   Expression:  {subscriber_filter}

When Instructions Are Unclear

If the user's intent is ambiguous or a concept needs clarification — call search_adobe_docs before asking the user. For example:

  • Unsure how AWS Event Ruler syntax works → search "Adobe I/O Events subscriber defined filter AWS Event Ruler syntax"
  • User mentions a filter pattern you don't recognise → search "Adobe I/O Events filter pattern {pattern name}"
  • Unclear what CloudEvents fields are available for filtering → search "Adobe I/O Events CloudEvents v1 payload fields"

Always prefer fetching from official docs over guessing.


Rules

  • Only one Subscriber Defined Filter is allowed per registration — always call get_subscriber_filters before creating and redirect to update if one already exists
  • Subscriber Defined Filters only work on registrations with event_delivery_format: "cloud_events_v1" — providers with "adobe_io" format or AWS EventBridge registrations are not eligible
  • For CloudEvents sample events: type and source are read-only (enforced by Adobe) — all other fields including data are editable

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

I/O Events Registration Flow

Guide the user through creating an event registration to receive events from Adobe services.

Before starting: invoke the dev-console-context skill.

Steps

Step 1 — Org, Project, Workspace

  1. Call get_organisations → ask user to pick org. Store both id (numeric) and code (IMS org code).

  2. Ask: "Do you want to use an existing project or create a new one?"

    If existing project:

    • Call get_projects with filterBy: "me" → show as numbered list → user picks project.

    If new project:

    • Invoke dev-console-create-project and reuse its returned projectId and workspace context directly. A default project has a single Production workspace; an App Builder template project has Production and Stage, so ask the user which one to use unless they already said.
  3. For existing projects: call list_workspaces → auto-select if only one workspace (Production), otherwise ask user to pick.


Step 2 — Pick event provider

Call both in parallel:

  • list_event_providers with both consumerOrgId (org id field) and imsOrgCode (org code field)
  • get_provider_metadata with imsOrgCode (the org code field)

Map and enrich:

  1. From list_event_providers, collect the unique provider_metadata values across all returned providers.
  2. Filter get_provider_metadata results to only those whose id matches one of the collected provider_metadata values — discard the rest.
  3. For display, use the enriched metadata (group, label, description, type) for the filtered entries only.

Show the enriched list grouped by group — only providers actually available to this org:

Creative Cloud:
  1. Adobe Illustrator Cloud Docs — OAuth S2S or User Auth
Adobe Services:
  2. Adobe Admin Console Audit Logs — OAuth S2S only

Credential type display — map providerMetadata.type field:

  • entp → show "OAuth S2S only"
  • adobeid → show "User Auth only"
  • entp_and_adobeid → show "OAuth S2S or User Auth"

Ask the user to pick one provider category.

After picking, if has_multiple_providers: true → show instances (from list_event_providers filtered by providerMetadataId) and let the user pick one or more. If has_multiple_providers: false → auto-select the single instance.


Step 3 — Pick event types

For each selected provider id, call list_provider_events.

Combine all returned event types. Show and ask user to pick one or more:

1. Cloud Doc Deleted   (ai_cloud_docs_deleted)
2. Cloud Doc Created   (ai_cloud_docs_created)
3. Cloud Doc Updated   (ai_cloud_docs_updated)

Step 4 — Pick credential

Use the type from the selected provider metadata to determine which credential types are valid:

Provider metadata typeValid credentials to show
entpOAuth S2S only
adobeidUser Auth (AdobeId) only
entp_and_adobeidBoth OAuth S2S and User Auth

4a. Ask credential type first (based on provider type):

  • If entp → skip asking, proceed with OAuth S2S automatically
  • If adobeid → skip asking, proceed with User Auth automatically
  • If entp_and_adobeid → ask:
    This provider supports multiple credential types. Which would you like to use?
    1. OAuth Server-to-Server
    2. User Auth (AdobeId)
    

4b. If OAuth S2S selected:

  • Call get_credentials and check if one exists (flow_type: "entp" or integration_type: "oauth_server_to_server")
  • If exists → use it, call get_credential_secrets with id_integration to get client_id
  • If not → follow the OAuth S2S credential creation steps from the dev-console-subscribe-api skill (### OAuth Server-to-Server section), then call get_credential_secrets

4c. If User Auth selected:

Ask for platform: WebApp, SinglePageApp, NativeApp, or apiKey.

  • Call get_credentials and check if a User Auth credential exists for that platform (flow_type: "adobeid")
  • If exists → use it, call get_credential_secrets to get client_id
  • If not → follow the User Auth credential creation steps from the dev-console-subscribe-api skill (### User Auth — AdobeId section) for the chosen platform, then call get_credential_secrets

Step 5 — Pick delivery type

Ask the user to pick one delivery type:

How would you like to receive events?
1. Journal         — poll events from a journal endpoint (Adobe manages the queue)
2. Webhook         — push events to a URL in real time
3. AWS EventBridge — deliver events to AWS
4. Runtime Action  — invoke an App Builder runtime action

If Journal selected: no extra inputs needed.

If Webhook selected:

  1. Ask for webhook URL
  2. Ask: "Single events or batches?" → Single = "webhook", Batch = "webhook_batch"

If AWS EventBridge selected:

  • Ask for AWS Region and AWS Account ID
  • delivery_type: "aws_eventbridge", goes into destination_metadata: { aws_region, aws_account_id }

If Runtime Action selected:

  • Ask for runtime action path (e.g. my-org/my-app/my-action)
  • Goes into top-level runtime_action field

Step 6 — Resolve registration metadata

Apply the shared naming rules.


Step 7 — Create registration

One create_event_registration call for the delivery type the user picked. Use consumerOrgId, projectId, workspaceId, client_id, name, optional description, events_of_interest, enabled: true.

Deliverydelivery_typeExtra fields
Journal"journal"—
Webhook"webhook" or "webhook_batch"webhook_url
AWS EventBridge"aws_eventbridge"destination_metadata
Runtime Action"journal"runtime_action

Note: Adobe automatically provisions a journal in the background for non-journal registrations — do not create a separate journal registration unless the user explicitly chose Journal.


Step 8 — Report success

✓ Event registration created successfully!

   Provider:      {providerLabel}
   Events:        {event_codes}
   Credential:    {credentialName} ({credentialType})
   Delivery:      {delivery_type}
   Registration:  {name}  (ID: {registration_id})

If delivery_type is webhook or webhook_batch, check webhook_status in the response:

  • verified → all good, Adobe confirmed the endpoint.
  • verification_pending → Adobe hasn't sent the challenge yet or the endpoint hasn't responded. Tell the user:
    ⏳ Webhook verification is pending.
    Adobe will send a GET request with a `challenge` query param to your URL.
    Your endpoint must respond with the `challenge` value to complete verification.
    Run `get_event_registration` in a few moments to check the status.
    
  • verification_failed → offer to re-trigger (see Webhook Verification Flow below).

If delivery_type is journal, tell the user:

📋 Your journal registration is ready. Events will queue here as they arrive.
Use the Journal Reading Flow to fetch them with `get_journal_events_batch`.

Journal Reading Flow

Trigger when user says "read journal", "fetch events", "poll journal", "get journal events", "what events came in", "show me my events", "read from journal".

Journal is pull-based. Unlike webhook/runtime/AWS EventBridge (push), the consumer fetches batches on demand. Adobe queues events; you drain them.

  1. If workspace context is not set, run Step 1 first.
  2. Call get_registrations_for_workspace → filter to delivery_type: "journal" → show as numbered list → user picks one.
  3. Call get_credentials → match the registration's client_id to a credential's client_id → use its id_integration as credentialId.
  4. Ask: "Start from the beginning, the latest event, or a specific position (since cursor)?"
    • Beginning / default → call get_journal_events_batch with consumerOrgId, imsOrgCode, credentialId, registrationId.
    • Latest → call with latest: true.
    • Cursor → ask for the since value → pass as since.
  5. Display results:
    • If empty → "No events in the journal yet. Events will appear once the source produces them."
    • If events found → show a compact summary, then offer to fetch more:
      Fetched {count} event(s):
      1. {type}  {time}  source: {source}
      
      Fetch more?
      
  6. If the user wants more, call get_journal_events_batch again with the since cursor from the previous response's _links.next link.

Tracing Flow

Trigger when user says "trace events", "debug delivery", "check event delivery", "why didn't I receive events", "event trace".

Tracing is push-based only. Applicable to webhook, webhook_batch, aws_eventbridge, and runtime_action registrations. Journal registrations have no delivery attempts to trace.

  1. If workspace context is not set, run Step 1 first.
  2. Call get_registrations_for_workspace → filter out delivery_type: "journal" → show remaining registrations → user picks one.
  3. Call get_credentials → match client_id → use id_integration as credentialId.
  4. Call get_tracing_for_registration with consumerOrgId, imsOrgCode, credentialId, registrationId.
  5. Display results:
    • If empty array → "No trace events found — no events have been delivered to this registration yet."
    • If traces found → show as a table:
      Date                  Event Code              Status
      2026-06-20T10:00:00   ai_cloud_docs_deleted   delivered
      

Add Event Providers to Existing Registration

Trigger when user says "add more events", "add another provider", "subscribe to more events", "add event type", "extend registration", "add provider to registration".

A registration can cover multiple providers and event types. Adding more must go through update_event_registration — never create a new registration for this.

Step A1 — Pick registration

Call get_registrations_for_workspace → show as numbered list → user picks one.

Step A2 — Show current events

Call get_event_registration to fetch the full registration. Display what's already subscribed:

Current events on "{name}":
  1. {providerLabel} — {event_code}
  2. {providerLabel} — {event_code}

Step A3 — Pick new provider

Follow Step 2 (Pick event provider) from the main flow to let the user pick a new provider and event types. Skip any providers/event codes already in events_of_interest.

Step A4 — Pick new event types

Follow Step 3 (Pick event types) for the newly selected provider.

Step A5 — Confirm

I'll add the following to "{name}":
  + {providerLabel} — {event_codes}

Existing subscriptions are preserved. Proceed?

Step A6 — Update

Call update_event_registration with all existing fields from Step A2 plus the new entries appended to events_of_interest.

Report:

✓ Registration updated!

   Name:    {name}
   Events:  {all event_codes, old + new}

Delete Registration Flow

Trigger when user says "delete registration", "remove event registration", "unsubscribe from events".

  1. If the user hasn't specified which registration, call get_registrations_for_workspace and show the list.
  2. Once the user picks one, tell them which registration is about to be deleted and that it can't be undone: "This will permanently delete registration {name}." Do not ask them to type the name. The client shows its own Yes / No approval prompt when you call the tool; that prompt is the confirmation.
  3. Call delete_event_registration for the chosen registration. If the user declines the approval prompt, stop — do not retry or work around it — and ask what they would like to do instead.
  4. Report: "✓ Registration '{name}' deleted successfully."

Webhook Verification Flow

Trigger when:

  • The user says "webhook verification failed", "re-verify webhook", "retry webhook", "webhook status failed", "webhook not verified", "webhook challenge", "re-trigger webhook"
  • You see webhook_status: "verification_failed" in any registration response

How it works: Calling update_event_registration with the same fields re-triggers Adobe's challenge flow.

Step V1 — Identify the registration

Call get_registrations_for_workspace → filter to webhook/webhook_batch registrations with webhook_status: "verification_failed" → show as numbered list → user picks one. Auto-select if only one.

Step V2 — Show status and explain

⚠️  Webhook verification failed for "{name}"

   Webhook URL:  {webhook_url}
   Status:       verification_failed

Adobe sent a GET challenge request to your webhook URL but did not receive
the correct response. Your endpoint must echo back the `challenge` query
parameter value in the response body.

Would you like me to re-trigger the verification challenge now?

Step V3 — Re-trigger the challenge

Call get_event_registration to fetch the full current registration.

Then call update_event_registration with the exact same values as the current registration:

consumerOrgId, imsOrgCode, projectId, workspaceId, registrationId  ← from context
name, description, webhook_url, events_of_interest, delivery_type, enabled  ← from current registration

Step V4 — Confirm and advise

✓ Webhook verification re-triggered!

Adobe will now send a new challenge GET request to:
{webhook_url}

Your endpoint must respond with:
  HTTP 200
  Body: the value of the `challenge` query parameter

Run `get_event_registration` in a few seconds to confirm the status
changes from `verification_pending` → `verified`.

When Instructions Are Unclear

If the user's intent is ambiguous, a concept is unfamiliar, or you need more context about an Adobe product or API before proceeding — call search_adobe_docs with the relevant question before asking the user to clarify. For example:

  • Not sure what delivery type fits the user's use case → search "Adobe I/O Events delivery types comparison"
  • Unclear what credential type a provider requires → search "Adobe I/O Events credential types entp adobeid"
  • User mentions a product you don't recognise → search "what is {product} Adobe developer platform"

Always prefer fetching from official docs over guessing.


Rules

  • Use patch_event_registration for targeted changes (enable/disable, rename, change webhook URL)
  • Use update_event_registration when changing multiple fields at once (events, delivery type, etc.)
  • JSON Patch path examples: "/enabled", "/name", "/webhook_url", "/delivery_type"
  • Use providerMetadata.type to determine valid credential types — never offer credential types not supported by the provider
  • Only create one registration — the delivery type the user explicitly chose
  • A registration can include events from multiple providers — if the user wants to add more providers to an existing registration, use the Add Event Providers to Existing Registration flow (update_event_registration); if they explicitly want a new separate registration, proceed with the main creation flow
  • Never create an extra journal registration alongside another delivery type — Adobe provisions one in the background automatically
  • For journal delivery, remind the user to use the Journal Reading Flow (get_journal_events_batch) to fetch events
  • Tracing only applies to push-based registrations — never call get_tracing_for_registration for a journal registration
  • When webhook_status: "verification_failed" is seen on any registration, proactively flag it and offer the Webhook Verification Flow
  • To re-trigger webhook verification, call update_event_registration with the exact same fields — always fetch the current registration first via get_event_registration

Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.

Search Adobe Developer Docs

Retrieve grounded answers from official Adobe developer documentation. This skill is a retriever — passages are fetched and returned for you to synthesize into a final answer. Do not answer from training knowledge alone.


When to invoke

  • Any question about Adobe developer products, APIs, SDKs, or platform concepts
  • Before starting a provisioning flow (credential creation, API subscription, I/O Events setup) — gather context first
  • When the user explicitly asks to search Adobe documentation

Flow

Step 1 — Check if scoped to a specific product

Does the user mention a specific product (e.g. "search only App Builder docs", "look this up in Express Add-ons docs")?

  • Yes → Call list_doc_collections to get available collection IDs. Match the user's product to a collectionId. Proceed to Step 2 with that collectionId.
  • No → Proceed to Step 2 with no collectionId (searches all collections).

Step 2 — Retrieve passages

Call search_adobe_docs with:

  • query: the user's question or topic as-is
  • collectionId: from Step 1 (omit to search all)
  • numberOfResults: 5 (default) — increase to 10 if the question is broad

Step 3 — Handle results

Results found:

Synthesize the answer from the returned passages. For each passage used, cite the source:

{Your synthesized answer}

Sources:
- {title} — {sourceUrl}
- {title} — {sourceUrl}

Zero results:

Tell the user no documentation was found and suggest rephrasing or broadening the query. If offering collection scopes, first reuse or call list_doc_collections and use only returned collection names; omit that suggestion if none are available:

No results found for "{query}". Try:
- Rephrasing with different keywords
- Using a broader search term
- Scoping to a specific collection (e.g. App Builder, Express Add-ons)

Then offer to retry with a rephrased query.


Rules

  • Never answer Adobe documentation questions from training knowledge alone — always call search_adobe_docs first
  • Always cite source URLs from the returned passages
  • Synthesis happens here in the LLM — the tool only retrieves; do not ask the tool to generate answers
  • If the user asks about a product not covered by any collection, tell them the available collections (from list_doc_collections) and suggest the closest match

Hooks 1

Sponsors

Details

Marketplace
adobe/skills
Source
plugins/adobe-for-developers
Author
Adobe
Category
Development
License
Apache-2.0
Keywords
adobe, adobe-developer-platform, developer-console, credentials, io-events, documentation, mcp

More from adobe/skills

All 19