Skip to main content

Skills and Connectors

Install plugins and Skills, connect external services, and assign resources to Wakers with least-privilege access.

Capabilities & Resources centrally manages reusable plugins, Skills, connectors, knowledge bases, WakerFlows, and public projects. A Skill defines a repeatable working method; a connector lets a Waker call an external application, MCP service, or built-in tool. A resource appearing in the marketplace or My resources does not mean every Waker can use it. The complete path is: install or create → assign to a Waker → check permissions → validate in a new chat.

Open Capabilities & Resources

Path: left navigation → Capabilities & Resources. Use the tabs to switch resource types; Plugins manages plugin installations. A Waker's Skills and Connectors pages manage only the resources assigned to that Waker.
Skill marketplace

Choose the right resource

NeedUse
Apply a repeatable method to a class of tasksSkill
Install and manage related Skills, connectors, and other capabilities togetherPlugin
Access an external app, account, or MCP serviceConnector
Search stable information repeatedlyKnowledge Base
Orchestrate multi-stage or multi-Waker workWakerFlow
Provide a reusable code or document workspaceProject
Do not store tokens in a Skill, and do not use a connector description as a business knowledge base.

Install and manage plugins

A plugin bundles related Skills, connectors, and other capabilities for installation and management together. Open Capabilities & Resources → Plugins. Browse Plugin Marketplace for available packages and manage existing installations under My Plugins. Installation targets here are local Wakers.

Install from the plugin marketplace

  1. Search or filter for a plugin. Open its details and review its purpose, source, version, included Skills and connectors, and configuration and permission requirements. Viewing details does not install it.
  2. Select Install, then install it for the local Wakers that need the capability in the usage scope.
  3. Check each Waker's installation, enablement, and readiness status. Complete configuration or authorization as described below when required.
  4. Start a new chat with the target Waker and run a small task matching the plugin's purpose. You can also select Try from a card's menu in My Plugins to open a new chat with an installed Waker.

Upload a local plugin ZIP

  1. Under My Plugins, select Add plugin and choose or drop a plugin ZIP, up to 50 MiB.
  2. Select Validate and continue, then check the detected plugin name, version, and contents.
  3. Choose one or more local Wakers and confirm installation. Successful validation alone does not install the plugin.
  4. Return to My Plugins to check every target's result, complete any configuration or authorization, and validate in a new chat.
You can also open the target Waker → Plugins → Upload plugin. This installs only to that Waker and also lists the plugin under My Plugins. A local plugin with the same name but different contents cannot be overwritten directly. Follow the conflict message instead of repeatedly uploading it.

Configure and authorize plugin connectors

  1. When a plugin requires configuration or authorization, select Configure or Authorize and confirm which Waker you are managing.
  2. In the plugin's Connector settings, complete the required fields and external-account authorization. Where tool selection is available, enable only the tools needed for the task.
  3. Refresh status, check the connection and tool list, then enable the plugin for the target Waker and verify an actual call.
An installed plugin does not mean every bundled connector is ready. Check each connector you intend to use. Reauthorizing or disconnecting authorization shared by multiple Wakers can affect other users; inspect its usage scope first.

Manage usage scope and enablement

Select Manage under My Plugins to inspect the plugin across Wakers and install, enable, disable, or remove it per row. You can also manage an installation from the target Waker's Plugins page. Disabling preserves the installation and configuration for later re-enablement. For Pending completion, Pending retry, or unsynchronized runtime configuration, follow Retry operation or Retry sync until the target state is confirmed. A pending operation is not success; do not start a duplicate installation. Validate changes in a new chat.

Update and remove

  • Update a marketplace plugin: when Update appears, review the release notes and permission changes, then update and check the associated Wakers' versions. Marketplace updates switch the current account's associated installations, so verify every affected Waker. Local uploads do not receive automatic marketplace updates.
  • Remove it from one Waker: remove the target row in the usage scope or uninstall from that Waker's Plugins page. Other Wakers retain their installations.
  • Delete it from My Plugins: the card menu's Delete action uninstalls from all Wakers listed in the confirmation and removes the shared package. Check that scope before confirming. Future use requires downloading a marketplace plugin again or uploading a local plugin again.
Before removal, check dependent tasks, Autonomous Work, and WakerFlows. Manage bundled Skills and connectors through their parent plugin; use the plugin's settings to adjust a connector.

Install a Skill from the marketplace

  1. Open Skills → Skill Marketplace.
  2. Search or filter for the capability. Install counts and recommendations are signals, not a security review.
  3. Open the detail page and read the use cases, triggers, source, included files, and scripts.
  4. Confirm that file access, network access, and external tools are appropriate for the environment.
  5. Install the Skill and check its status and version under My Skills.
  6. Open the target Waker → Skills and add or confirm the Skill.
  7. Start a new chat and run one low-risk task that directly matches the Waker's responsibility.
Installation is complete only when the intended Waker recognizes the use case, follows the expected method, and does not access objects outside the permitted scope.

Upload your own Skill

Use the upload entry in the resource center or the target Waker. Depending on the page, the package can be a Markdown file or an archive containing SKILL.md and required resources. Before uploading, check:
  • the name, description, and trigger conditions in SKILL.md;
  • scripts that write files, access the network, or invoke commands;
  • relative paths and required bundled resources;
  • credentials, personal data, and private addresses;
  • conflicts with instructions in existing Skills.
Validate the package on a test Waker first. After changing its structure or scripts, upload the new version and rerun a fixed regression task.

Manage self-evolving Skills

Path: Waker Management → target Waker → Memory & Learning → Self-evolving Skill. Self-evolution turns a successfully completed complex task into a reusable way of working. When enabled, the Waker reviews suitable completed tasks, updates an existing evolving Skill first, and creates a new Skill only when necessary. This page contains Skills summarized by the Waker during tasks and uploaded Skills for which Allow self-evolution was explicitly enabled.
  1. Turn on the Waker-level switch. Turning it off stops new chat-driven creation and updates, but does not delete existing Skills.
  2. For an uploaded Skill, open its details and enable Allow self-evolution only when the Waker may improve that package. Leave it read-only when the original content must remain fixed.
  3. Complete a complex task with clear inputs, steps, and an accepted result. Ordinary questions normally do not produce a reusable Skill.
  4. Return to this page and verify that the new or updated Skill describes the right trigger, procedure, boundaries, and completion criteria.
  5. Run a similar but not identical task to confirm that the Waker applies the Skill in the right situation instead of forcing it onto unrelated work.
Self-evolution does not replace human review. Methods involving external sending, publishing, deletion, production operations, or sensitive data still need permission controls and human approval. Edit, disable evolution, or roll back when a Skill captures an accidental path, overgeneralizes one task, or retains information that should not persist.

Inspect history and roll back

For Skills that support version management:
  1. Open the Skill details and select History.
  2. Select a version and inspect its summary and file diff. Identify whether it came from creation, editing, self-evolution, or rollback.
  3. Choose the required historical version and roll back.
  4. Start a new chat and rerun a fixed task to verify the active content.
Rollback changes the active Skill content; it does not undo tasks or external operations that already used that Skill. If the page reports an evolution conflict, compare the current and proposed versions, then keep the current version, accept the proposal, or merge manually. Do not overwrite without reading the diff.

Update, replace, or uninstall a Skill

  1. Identify Wakers, Autonomous Work items, and WakerFlows that depend on it.
  2. Review changes to inputs, tools, and permission scope.
  3. Update one test Waker and run the fixed sample.
  4. Expand the update only after the result is confirmed.
  5. Before uninstalling, remove or replace the Skill in dependent workflows.
Existing chats can retain previous context. Validate updates in a new chat.

Install a connector

Connector marketplace
  1. Open Connectors → Connector Marketplace.
  2. Review supported tools, authentication, permission scope, edition, and environment requirements.
  3. Select install or connect, then complete OAuth, QR-code, credential, or local-command authorization as prompted.
  4. Confirm the connection under My Connectors. If tool switches are available, enable only the tools needed for current work.
  5. Add the connector under the target Waker → Connectors.
  6. Validate with a read-only query or test object before enabling write, send, or delete operations.
Marketplace availability varies by CN or Global edition, account, version, and feature flag. Follow the connector types shown in the product.

Understand connector states

StateMeaningStill verify
InstalledThe connector is present in ResourcesIt may still need sign-in, authorization, or Waker assignment
AuthorizedThe external account or local service is authenticatedThe scope is sufficient but not excessive
EnabledThe target Waker can see the connectorTools are available and the test uses a new chat
Connected / HealthyThe connector runtime can communicateA read-only task returns the expected result
Installed does not mean ready. Troubleshoot in the order install → authorize → enable → connect → invoke.

Configure Browser Connector

Browser Connector lets a Waker read or operate authorized browser tabs for page checks, form assistance, and web research. It does not automatically receive the entire browsing history and works only in a connected, authorized browser environment.

1. Install and assign

  1. Search for Browser Connector in the marketplace, open its details, and install it.
  2. Select the Waker that needs browser access.
  3. Open Browser Connector under My Connectors. The first-use view provides extension installation and connection guidance.
Prefer the extension-store link shown by the product. If manual loading is required, enable developer mode in the browser's extension manager, choose Load unpacked, and select the directory provided by the product. Do not download a same-named extension from an untrusted source.

2. Connect and inspect tabs

  1. Open the web page that the Waker should use.
  2. Select the Browser Connector extension and connect it to the current QoderWake instance.
  3. Return to connector details and confirm a Connected or Healthy state and the expected available tab.
  4. Resolve Not authorized, Disconnected, or Version incompatible states directly; do not expand Waker permissions to bypass a connection problem.

3. Validate with a read-only task

Start a new chat and ask the Waker to read the title and summarize the structure of the currently authorized tab. Confirm it selected the intended tab before testing clicks, typing, or downloads. Sending, submitting, deleting, purchasing, publishing, and account-setting changes are high-impact browser operations. The Waker should state the target, impact, and recovery plan, then wait for human confirmation.

Add a custom MCP connector

When the page provides manual or JSON configuration:
  1. Obtain the confirmed configuration format from the service provider.
  2. Use a trusted command, server address, and startup arguments.
  3. Put credentials in protected fields or environment variables, not task text or ordinary JSON.
  4. Restrict accessible directories, network destinations, and tool names.
  5. Save, check the discovered tool count, and execute one read-only call.
When the tool count is zero, check service startup, configuration syntax, networking, and authentication before expanding permissions.

Pass the IM requester's identity

Group members can share a Waker and MCP connector while the MCP service checks access for each requester. When enabled, the Waker passes the current requester's identity to this connector during IM tasks. DingTalk, Feishu / Lark, and WeCom smart bots are supported.

Enable identity forwarding

Path: target Waker → Connectors → Custom connector → add or edit a connector.
  1. Choose Streamable HTTP or SSE and enter the service URL and required authentication.
  2. Enable Pass IM requester identity and leave Headers Helper empty.
  3. Save and enable the connector, then @mention the bot in IM to start a task.
STDIO does not support this feature. A nonempty custom Headers Helper overrides built-in identity forwarding.

Feishu permissions

Enable these application identity permissions for the bot application in the Feishu developer console:
PermissionPurpose
contact:user.employee_id:readonly (get user ID)Required to pass the requester's identity ID.
contact:user.base:readonly (get basic user information)Required when forwarding a name.
Publish the permission changes or obtain administrator approval, ensure the data scope covers the users, and send a new message to test. Corresponding user identity permissions are not required. These permissions let the bot obtain requester information; they do not grant access to projects, orders, or other business data.

What identity headers do and how to use them

Once enabled, the Waker automatically includes requester identity in MCP calls for the current IM task. The MCP service reads these headers, maps the IM user to a business account, and checks that account's permissions. Multiple group members can use the same connector, with access evaluated for each request. For example, a request from Chen Chen in Feishu might include the following headers. All values are examples:
X-QoderWake-AtWaker-Sender-Id: user_example_001
X-QoderWake-AtWaker-Sender-Channel: feishu
X-QoderWake-AtWaker-Sender-Name: %E9%99%88%E6%99%A8
  • Connector administrators: enable forwarding and leave Headers Helper empty. You do not need to enter these headers manually. Do not fix one person's ID in Headers, because requests must identify the actual requester.
  • MCP service maintainers: read Sender-Id and Sender-Channel, map the user within the verified organization/application integration scope, and check permission for the requested resource and action. The example name decodes to 陈晨 (Chen Chen) and is for display only.
  • Group members: @mention the bot normally without entering a user ID in the question. When another member asks, the platform passes that execution turn's requester identity.
The runtime generates these headers from platform-confirmed identity; the model does not fill them from question text. They do not replace the connector's access token or OAuth authentication, and do not grant business permissions directly.

Available identity fields

HeaderMeaning and use
X-QoderWake-AtWaker-Sender-IdCurrent requester ID for business-account mapping: DingTalk staffId, Feishu / Lark user_id, or trusted live WeCom from.userid. Do not treat every channel's ID as an employee number.
X-QoderWake-AtWaker-Sender-ChannelIdentity channel: dingtalk, dingtalk-user, feishu, lark, or wecom-bot.
X-QoderWake-AtWaker-Sender-NameOptional directory name, encoded with encodeURIComponent and decoded server-side with decodeURIComponent. It can be missing, duplicated, or cached; do not use it for authorization.
X-QoderWake-AtWaker-Sender-Open-IdOptional channel user ID: DingTalk openDingTalkId, Feishu open_id, or the same live from.userid for WeCom. Do not interchange it with Sender-Id.
X-QoderWake-AtWaker-Sender-Union-IdOptional cross-application user ID, currently sourced only from Feishu / Lark when available in platform data.
Only confirmed fields are forwarded. If the requester cannot be identified, no identity headers are sent. Initialization, tool discovery, and manual connection checks in the UI may also have no IM requester identity.

Who manages permissions

ConfigurationControlsDoes not mean
Feishu application permissionsWhether the bot can obtain user IDs, names, and related informationThe user can access business data.
Waker connectorWhether identity is forwarded, MCP connectivity, and available toolsEnabling the switch creates business accounts or permission groups.
MCP service and business systemWhich resources and actions the user can accessNames, question text, or tool visibility alone are sufficient authorization.
The MCP service must:
  1. Authenticate the caller. Use its existing access token or another supported mechanism to verify a trusted integration. Identity headers are not signed credentials; their presence alone is insufficient.
  2. Map the business account. Look up the user by trusted organization/application integration scope plus Sender-Channel and Sender-Id. Obtain that scope from an authenticated integration; these headers alone do not provide complete tenant information.
  3. Check permission for this request. Use existing roles, project membership, or permission groups to check the target resource and action. Project read access does not imply permission to modify or delete it.
  4. Execute only after authorization. Read or modify data only after approval and limit the result. Reject missing identity, unmapped accounts, or insufficient permission without falling back to a shared account or administrator access.
This feature does not automatically sign every group member into OAuth or switch shared connector credentials to personal tokens. Even when a service uses shared credentials for the underlying system, it must check the requester's business permissions rather than return everything those credentials can access.

Example: query progress according to project access

A team connects its project management system through MCP and configures project access. Chen Chen can view the Customer Portal project; Lin Xiao cannot. Both send the same request in the same group:
@bot Show the current progress of the Customer Portal project.
RequesterSender-Id received (example)Server processingExpected result
Chen Chenuser_example_001Map the account and confirm project read accessReturn progress and action items.
Lin Xiaouser_example_002Map the account and find no project read accessReport access denied without returning project data.
The following illustrates validation order in an MCP tool handler. The helper functions must integrate with the provider's authentication, account mapping, and project permission systems. They are not built-in QoderWake APIs or a complete MCP service:
async function getProjectProgress(request, args) {
  // Authenticate MCP access and obtain the trusted tenant/application scope.
  const access = await verifyMcpAccess(request);
  if (!access) throw new Error("UNAUTHENTICATED");

  const senderId = request.headers.get("X-QoderWake-AtWaker-Sender-Id");
  const channel = request.headers.get("X-QoderWake-AtWaker-Sender-Channel");
  if (!senderId || !channel) throw new Error("SENDER_IDENTITY_REQUIRED");

  const user = await findBusinessUser({
    tenantId: access.tenantId,
    appId: access.appId,
    channel,
    senderId
  });
  if (!user) throw new Error("USER_NOT_MAPPED");

  const allowed = await canAccessProject(user, args.projectId, "read");
  if (!allowed) throw new Error("PROJECT_ACCESS_DENIED");

  return readProjectProgress(args.projectId);
}
args.projectId identifies the project to query. User identity always comes from identity headers passed by an authenticated integration, never another user ID supplied by the model in tool arguments. Convert the example errors to the service's own protocol error results.

Validation and boundaries

  • Run the same query from one authorized and one unauthorized account. Confirm different identities reach the service and results respect each account's permissions.
  • Switch back to the first account and verify that the previous member's identity is not reused. Retest after changing permissions.
  • Test missing identity, unknown accounts, and unauthorized resources; business calls must be denied. Handle initialization and discovery through separate connection authentication and metadata policies without relaxing business authorization.
  • A connector being available proves communication, not user authorization. Check actual tool-call results.
  • Other group members may still see group replies. Identity checks limit this tool access; they do not isolate existing group messages or task context. Limit sensitive output or choose an appropriate delivery channel.

Assign resources to a Waker

The resource center answers “what capabilities are available”; a Waker detail page answers “what this Waker may use.”
  1. Open the target Waker's Skills or Connectors page.
  2. Select Add and choose an installed resource.
  3. Confirm that the resource matches the Waker's role.
  4. Open Permissions and verify that file, tool, and model safety rules remain limited.
  5. Validate in a new chat.
One connector can be assigned to several Wakers, but every Waker still follows its own responsibility and permission boundary.

Sync and repair resources

With remote configuration management enabled, Waker metadata, role context, Skills, and Connector configuration can sync to managed devices. Login tokens, keys, and other credentials stay on the device that owns them.
  • After updating a Skill, refresh configuration on the target device and verify the effective version in a new conversation.
  • Changes may be queued while a remote device is offline. Verify them after it comes online and applies them.
  • Reauthorize a Connector on the credential-owning device when authorization is required or has expired.
  • Reauthorization first removes the connection's existing authorization. Related Wakers and other devices sharing it may be temporarily unavailable until completion.
  • For diagnostics, check installation, authorization, enablement, connectivity, and invocation. Do not broaden Waker permissions to conceal connection problems.
Successful synchronization means configuration arrived; it does not prove script dependencies, external-account permissions, or local paths work. Run a read-only validation task on every target device.

Credential and permission safety

  • Start with read-only access, a test account, and the smallest scope.
  • Keep human confirmation for external sending, deletion, publishing, payments, and production changes.
  • Never put secrets, tokens, or cookies in tasks, memory, knowledge bases, role files, or screenshots.
  • Compare the authorization screen with the actual tools; reject permissions that are not required.
  • Before removing a connector, check dependent Wakers, Autonomous Work, and WakerFlows.

Troubleshooting

SymptomCheck
Resource not foundSearch/filter → CN or Global edition and account → version and feature flag
Installed but unusedAssigned Waker → new chat → role and trigger description
Connector not authorizedRepeat authentication → account permission → network and edition
Browser Connector cannot find a tabExtension installed and enabled → current instance connected → tab authorized → connection refreshed
No tools discoveredService state → configuration → authentication → network
Call rejectedWaker permission → connector permission → external object permission
Automation fails after updateSkill/connector version → changed inputs or tools → rerun the workflow
Completion check: the resource is available, the target Waker uses the correct capability in a new chat, permissions remain minimal, and test objects are not confused with production objects.