DreamLake

Agent tool authorization

Generated content. The permission inventory table on this page is generated from the dreamlake-server tool catalog: regenerate it with pnpm agent:tool-inventory in dreamlake-server and never edit it by hand. It is checked against the live catalog in both CI lanes — harness/inventory.test.ts when server code changes, and the agent-tool-inventory job of .github/workflows/docs-checks.yml when this page changes — so a docs-only edit of the table fails.

2026-10-31 — typed metadata, enforcement, catalog, receipts, verification (server, branch feat/agent-tool-authorization)

Follow-up to "Service accounts, project members and tool authorization — 2026-10-30" in the built-in agent design memo (:note[6adec6fea203b8fb5430db2f]). Implemented in dreamlake-server only; not merged, not deployed, no UI change, no new dependency, no data migration. Nothing moved to service-account authority: the two permission paths that existed before are unchanged in behaviour and are now declared, enforced and recorded explicitly.

The two permission paths, kept explicit

The built-in agent has had two ways of being allowed to do something, and still has exactly two:

  1. Service-account grant — the four project tools (dreamlake_list_projects, dreamlake_search_project, dreamlake_read_file, dreamlake_folder_archive) run against the dedicated personal service account ensureAgentIdentity derived for the signed-in user, and need an explicit ServiceAccountProjectGrant on a project in the caller's own personal namespace. The human's wider project access is never consulted; removing the grant removes exactly these tools' access to that project.
  2. Caller API — every other tool (Memos, sessions, activity, memory, skills, page snapshot, layout, macro, web search) acts as the signed-in user: the turn's capability scopes decide what may be offered and called, and for tools that reach a DreamLake resource the resource route re-checks the caller's own ACL under the caller's bearer (harness/api.ts, in-process Fastify inject). The service account is not a party to these calls and never appears on their receipts.

dreamlake_folder_archive takes both: the grant first, then the caller's route (PATCH /nodes). dreamlake_search_project is conditional: a name search runs under the grant alone (Prisma on the project tree), and only content:true reaches the Memos search API as the signed-in user for mounted Memos (a Memo the caller may not read is reported as skipped, never escalated). The declaration names the deciding argument and the registry records on each receipt the mode that call actually took — service-account-grant for a name search, both for a content search — so a receipt never claims a caller check that did not happen. An agent attribution header (x-dreamlake-agent-*) is attribution, not authentication: it is bound by the transport and can be restated or cleared for an internal fetch, never pointed at another conversation, turn or agent name, and a plugin can never carry a bearer of its own.

Metadata schema (harness/plugin.ts)

Every ToolPlugin carries, beside its input schema, scope, execution location and side-effect class:

ts
authorization: {
  mode: 'caller-api' | 'service-account-grant' | 'both';
  grant?: {                      // required for service-account-grant and both; forbidden for caller-api
    target: 'project';           // the only grant store that exists: ServiceAccountProjectGrant
    selector: string | null;     // the REQUIRED input argument naming the project (null: account-only check)
    role: 'READ' | 'WRITE' | 'ADMIN';   // minimum role; mapped to projectPolicy content:read / content:create / project:update
  };
  callerCheck: 'turn-scope' | 'both' | 'conditional';   // turn scopes alone; scopes plus the resource route's ACL; or decided per call
  condition?: { argument: string; equals: boolean };     // conditional only: a boolean input; equal → both, otherwise grant only
  turnScopes: ToolScope[];       // every scope the turn must hold; must include the registry scope
  note?: string;                 // one short credential-free line for the catalog and inventory
}

execution (backend | browser | runner) says where code runs and is refused as a mode. callerCheck: 'resource-acl' alone is refused too: the registry gates every call on turn scopes, so a declaration that promised only an ACL check would describe something the registry cannot produce. callerCheck: 'conditional' declares the widest mode (both) and must name a boolean input property; enforcedAuthorizationMode(auth, args) resolves the mode for one call and the receipt stores that result (condition is refused on any other caller check). Helpers callerAuthorization(scope, callerCheck, note?) and grantAuthorization(scope, grant, callerCheck, note?) build the common shapes; the mode follows from the caller check (both ⇒ both).

validateToolAuthorization runs in definePlugin and again in the ToolRegistry constructor (a plugin assembled by spreading is held to the same rule). It refuses a missing declaration, an unknown mode or caller check, an inconsistent mode/callerCheck pair, a grant target with no store, a selector that is not a required input property, a missing registry scope in turnScopes, and a multi-line or long memo.

What the registry enforces, in order (harness/registry.ts)

For every call, top-level or macro child:

  1. the tool exists and the turn holds every declared turnScopes entry — before argument parsing, before any receipt (agent_tool_scope_not_granted); list() offers only tools whose scopes are all held and that are not hidden;
  2. per-turn limits, closed-schema validation (identity-shaped arguments do not exist in any production schema), the plugin's pure preflight;
  3. the receipt is written with the authorizationMode enforced for this call (a conditional check resolved from the arguments) and the applicable actor ids;
  4. the declared grant is checked through the GrantAuthority the registry was constructed with (tools.ts serviceAccountGrants: active, caller-created account in the caller's personal namespace; project in that namespace; grant row with a role that satisfies the declared operation), using the turn-bound identity and the value of the declared selector argument. A registry without a grant authority refuses to hold a grant-declaring plugin; a selector the arguments cannot resolve refuses the call (agent_authorization_unenforced, 503) without consulting anything;
  5. the conversation lease is re-proven for side-effecting tools, then the plugin runs. The adapter's own check inside executeAgentTool stays authoritative (it re-checks the grant after fetching a file, so a revocation mid-read releases nothing).

Macro steps call ctx.executeTool, which re-enters execute with a derived tool-call id: a child is authorized exactly like a top-level call, with its own scope check, grant check, deadline and receipt. The macro allowlist never admits a grant-gated tool, a session or layout control tool, or memo deletion. The compatibility POST /agent/read-tool route (the three grant-gated read tools) no longer calls the adapter directly: it runs registry.execute under a synthetic read-only turn (projects:read only, receipt and attribution keyed on the service account id with a per-request read-api-… turn, no lease to fence), so a refused grant answers with the code the model would see and leaves the same failed receipt.

Receipts and catalog

AgentToolCall gains two optional, index-free fields: authorizationMode (the mode the registry enforced for that call — for dreamlake_search_project this is service-account-grant or both depending on content) and serviceAccountId (set only when a grant was a check of that call). A caller-api receipt therefore names one actor, the signed-in user, and never implies the account acted. Identifiers only: no bearer, grant row or role is copied. Rows written before the field existed read back as authorizationMode: null, never as caller-api. GET /agent/sessions/:id/tool-calls returns authorizationMode and actors {userId, serviceAccountId}. PRISMA_SCHEMA_REV bumped; additive Mongo fields, no migration.

GET /agent/tools carries each tool's authorization declaration verbatim beside the existing scope, execution, sideEffect, deprecated fields — static plugin metadata with no identity, bearer or grant row in it. The inventory below is rendered from that catalog, so the docs and any permission UI built on the catalog never keep a second policy list.

Verification (acceptance checklist)

  • src/builtin-agent/authorization.acceptance.test.ts — one describe per checklist item through the production registry, production plugins, the real grant authority (Prisma mocked) and the real in-process transport: actor spoofing by model arguments, page content and attribution headers rejected; missing, revoked, foreign-namespace, foreign-owned and insufficient-role grants refused before the adapter and before any PATCH, as failed receipts naming the mode and both actor ids; project search receipts record grant-only for a name search and both for a content search; every caller-authorized tool withheld and refused without each declared scope; a resource route's 403 under the route-bound bearer surfaces as a failed receipt; the production macro authorizes each step as its own tool and never dispatches a grant-gated one; a plugin lacking the declaration (or declaring its execution location as a mode) fails registration; a missing grant store, unknown grant target or unresolvable selector fails closed.
  • plugins/note/notesAgent.integration.test.ts — against the real Memos routes, an accepted edit keeps its completed receipt (finalized once) when the presence store fails afterwards (a visit fails on its own receipt; a read completes with presence:"unavailable") and when the edit's own readback cannot be answered (verified:false, ancillary failure beside the intact receipt).
  • routes.test.ts — attribution and identity headers on POST /agent/chat change nothing: receipts, the grant check and the context event follow the route-derived identity and the server-begun turn; /agent/tools exposes authorization without provisioning an identity; /agent/read-tool leaves an authorization receipt, refuses identity-shaped arguments by schema and answers a denied or revoked grant with the same code as chat, before the adapter runs.
  • harness/registry.test.ts, tools.test.ts, harness/api.test.ts, harness/receipts.test.ts, harness/inventory.test.ts — unit coverage of each part.

Local gate (no DB): pnpm prisma generate, tsc, vitest run src/builtin-agent src/ci/changeClassifier.test.ts --testTimeout=20000, pnpm agent:tool-inventory --check. This is isolated verification, not a production authorization test.

Not done (follow-ups, by design out of this change)

  • Permission UI consumption in dreamlake-ai. The catalog and inventory exist; no client reads authorization yet. The UI should render from GET /agent/tools, not from a copied list.
  • Service accounts in Project Members. No membership rows for service accounts, no unified project members add --service-account CLI; grants are still managed through service-accounts project-grants set. A row-based view must use the existing grant service, never a second membership record.
  • Service-account delegation for Memos and session tools. Those tools remain the signed-in user's own authority. Moving them needs a separate, tested server authentication/delegation change; a label swap or a project-member row cannot do it. Personal-SA access to organization-namespace projects therefore remains unsupported (agent_namespace_unavailable).
  • No new grant store (folder, file, note targets are refused at registration), no change to how grants are created or revoked, no release evidence yet.

Permission inventory (generated)

The table is generated from the registry catalog — the same data GET /agent/tools returns — by pnpm agent:tool-inventory in dreamlake-server; src/builtin-agent/harness/inventory.test.ts fails when the committed table no longer matches the live catalog (pnpm agent:tool-inventory --check says the same from the shell). Do not edit it by hand: the plugin declarations in src/builtin-agent/plugins/* are the policy.

Legend. Mode — who authorizes the call: caller API is the signed-in user's own authority (turn scopes, and the resource route's ACL under the caller's bearer); service-account grant is the personal service account's explicit project grant, checked by the harness before the adapter runs; both requires both. Grant — the grant store (project is the only one that exists), the argument that names the target (or account only when the tool enumerates grants) and the minimum role. Caller check — turn-scope: the turn's scopes alone, the tool reaches no permission-checked DreamLake resource; both: turn scopes and the resource route's ACL. Surface — offered tools are shown to the model when their scopes are held; hidden (legacy) tools stay executable for stored macros and receipts only. Execution is where the code runs and is never an authorization mode.

140 registered tools: 124 caller API, 2 service-account grant, 14 both; 13 hidden legacy.

ToolvModeGrant (target · selector · role)Caller checkTurn scopesSide effectExecutionSurfaceMemo
dreamlake_agent_project_access1caller API—bothresources:readnonebackendoffered
dreamlake_agents_create1caller API—bothresources:writewritebackendoffered
dreamlake_apply_layout1caller API—turn-scopelayout:actwritebrowserofferedApplied by the signed-in user's own browser session; no server resource.
dreamlake_apps_list1caller API—bothapps:readnonebackendoffered
dreamlake_apps_prepare_action1caller API—bothapps:preparewritebackendoffered
dreamlake_apps_read1caller API—bothapps:readnonebackendoffered
dreamlake_apps_tools1caller API—bothapps:readnonebackendoffered
dreamlake_bindr_visibility1bothproject · projectId · READbothprojects:readnonebackendofferedExplicit service-account Project grant plus current signed-in caller API authorization; the target must belong to the named Project.
dreamlake_bindr_visibility_set1bothproject · projectId · ADMINbothprojects:writewritebackendofferedExplicit service-account Project grant plus current signed-in caller API authorization; the target must belong to the named Project.
dreamlake_browser_files_list1caller API—turn-scoperesources:readnonebrowserofferedEphemeral browser cache, confined to the active conversation and turn. No Source or Project authority.
dreamlake_browser_files_read1caller API—turn-scoperesources:readnonebrowserofferedEphemeral browser cache, confined to the active conversation and turn. No Source or Project authority.
dreamlake_browser_files_replace1caller API—turn-scoperesources:writewritebrowserofferedEphemeral browser cache, confined to the active conversation and turn. No Source or Project authority.
dreamlake_browser_files_write1caller API—turn-scoperesources:writewritebrowserofferedEphemeral browser cache, confined to the active conversation and turn. No Source or Project authority.
dreamlake_command_cancel1caller API—bothsessions:controlcontrolbackendoffered
dreamlake_command_get1caller API—bothsessions:readnonebackendoffered
dreamlake_connection_entry_begin1caller API—bothresources:writewritebackendoffered
dreamlake_connection_entry_cancel1caller API—bothresources:writewritebackendoffered
dreamlake_connection_entry_status1caller API—bothresources:readnonebackendoffered
dreamlake_external_operation_get1caller API—turn-scopeexternal:readnonebackendofferedOwner and same private conversation checked on every result read.
dreamlake_files_list1caller API—bothresources:readnonebackendofferedManaged Source workspace; canonical Source routes enforce caller USE authority before and after byte reads. External layers are excluded.
dreamlake_files_read1caller API—bothresources:readnonebackendofferedManaged Source workspace; canonical Source routes enforce caller USE authority before and after byte reads. External layers are excluded.
dreamlake_files_replace1caller API—bothresources:writewritebackendofferedCanonical Source upload route enforces caller EDIT. All writes are create-only or strong-ETag conditional and read back.
dreamlake_files_write1caller API—bothresources:writewritebackendofferedCanonical Source upload route enforces caller EDIT. All writes are create-only or strong-ETag conditional and read back.
dreamlake_folder_archive1bothproject · projectId · WRITEbothprojects:writewritebackendofferedThe archive itself is a PATCH /nodes call as the signed-in user; the project grant is checked first.
dreamlake_folder_visibility1bothproject · projectId · READbothprojects:readnonebackendofferedExplicit service-account Project grant plus current signed-in caller API authorization; the target must belong to the named Project.
dreamlake_folder_visibility_set1bothproject · projectId · ADMINbothprojects:writewritebackendofferedExplicit service-account Project grant plus current signed-in caller API authorization; the target must belong to the named Project.
dreamlake_host_access_grant1caller API—bothhosts:sharewritebackendoffered
dreamlake_host_access_grants1caller API—bothhosts:readnonebackendoffered
dreamlake_host_access_revoke1caller API—bothhosts:sharewritebackendoffered
dreamlake_host_get1caller API—bothhosts:readnonebackendoffered
dreamlake_host_move1caller API—bothhosts:movewritebackendoffered
dreamlake_host_move_preview1caller API—bothhosts:readnonebackendoffered
dreamlake_hosts_list1caller API—bothhosts:readnonebackendoffered
dreamlake_libraries_list1caller API—bothresources:readnonebackendoffered
dreamlake_library_batch1caller API—bothresources:readnonebackendoffered
dreamlake_library_get_asset1caller API—bothresources:readnonebackendoffered
dreamlake_library_get_view1caller API—turn-scoperesources:readnonebrowseroffered
dreamlake_library_search1caller API—bothresources:readnonebackendoffered
dreamlake_library_set_view1caller API—turn-scopelayout:actcontrolbrowseroffered
dreamlake_library_view_images1caller API—bothresources:readnonebackendoffered
dreamlake_list_projects1service-account grantproject · account only · READturn-scopeprojects:readnonebackendofferedLists only the service account's explicit grants. Organization delegations also require the human's current Project read access.
dreamlake_mcp_call1caller API—turn-scopeexternal:proposewritebackendofferedProposes only; dispatch requires separate human confirmation and current connector authority.
dreamlake_mcp_discover1caller API—turn-scopemcp:discovernonebackendofferedPersonal owner, enabled state and exact revision rechecked before and after I/O.
dreamlake_memory_delete1caller API—bothmemory:deletewritebackendoffered
dreamlake_memory_save1caller API—bothmemory:savewritebackendoffered
dreamlake_memory_search1caller API—bothmemory:readnonebackendoffered
dreamlake_memory_update1caller API—bothmemory:updatewritebackendoffered
dreamlake_move_preflight1caller API—bothresources:readnonebackendoffered
dreamlake_note_append2caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_create2caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_delete1caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_diff1caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_edit1caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_file_op1caller API—bothnotes:writewritebackendoffered
dreamlake_note_file_preview1caller API—bothnotes:readnonebackendoffered
dreamlake_note_file_read1caller API—bothnotes:readnonebackendoffered
dreamlake_note_file_write1caller API—bothnotes:writewritebackendoffered
dreamlake_note_files1caller API—bothnotes:readnonebackendoffered
dreamlake_note_find2caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_move1caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_patch2caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_note_permalink1caller API—bothnotes:writewritebackendoffered
dreamlake_note_presence1caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_projects1caller API—bothnotes:readnonebackendoffered
dreamlake_note_query1caller API—bothnotes:readnonebackendoffered
dreamlake_note_read3caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_select1caller API—bothnotes:readnonebackendoffered
dreamlake_note_update2caller API—bothnotes:writewritebackendoffered
dreamlake_note_version_save1caller API—bothnotes:writewritebackendoffered
dreamlake_note_versions1caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_visit1caller API—bothnotes:readnonebackendhidden (legacy)
dreamlake_note_write1caller API—bothnotes:writewritebackendhidden (legacy)
dreamlake_notes_append1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_contributors1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_create1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_diff1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_edit1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_files_move1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_find1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_grep1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_insert1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_list2caller API—bothnotes:readnonebackendoffered
dreamlake_notes_move1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_outline1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_patch1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_presence1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_read1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_remove1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_rename1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_replace1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_search1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_transfer_accept1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_transfer_execute1caller API—bothnotes:writewritebackendoffered
dreamlake_notes_transfer_preview1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_transfer_status1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_versions_list1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_versions_read1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_visit1caller API—bothnotes:readnonebackendoffered
dreamlake_notes_write1caller API—bothnotes:writewritebackendoffered
dreamlake_open_resources_find1caller API—bothnotes:readnonebackendofferedOpen Memos are read through their permission-checked API as the signed-in user.
dreamlake_page_find1caller API—turn-scopeprojects:readnonebrowserofferedReads the browser snapshot this turn supplied; no server resource is touched.
dreamlake_page_read1caller API—turn-scopeprojects:readnonebrowserofferedReads the browser snapshot this turn supplied; no server resource is touched.
dreamlake_personal_extensions_list1caller API—turn-scopeextensions:readnonebackendofferedPersonal owner and enabled state rechecked by the extension service.
dreamlake_personal_skill_read1caller API—turn-scopeextensions:readnonebackendofferedPersonal owner, enabled state and exact revision rechecked on every read.
dreamlake_project_access1bothproject · projectId · READbothprojects:readnonebackendofferedExplicit service-account Project grant and current human route ACL.
dreamlake_project_access_set1bothproject · projectId · ADMINbothprojects:writewritebackendofferedExplicit service-account Project ADMIN; product transaction reauthorizes human ADMIN.
dreamlake_project_grant1bothproject · projectId · ADMINbothprojects:writewritebackendofferedExplicit service-account Project ADMIN; product transaction reauthorizes human ADMIN.
dreamlake_project_grants1bothproject · projectId · ADMINbothprojects:readnonebackendofferedExplicit service-account Project ADMIN and current human route ACL.
dreamlake_project_revoke1bothproject · projectId · ADMINbothprojects:writewritebackendofferedExplicit service-account Project ADMIN; product transaction reauthorizes human ADMIN.
dreamlake_propose_creation1caller API—turn-scopecreation:proposenonebackendoffered
dreamlake_read_file1service-account grantproject · projectId · READturn-scopeprojects:readnonebackendofferedThe grant is re-checked after the object is fetched, so a revocation mid-read releases nothing.
dreamlake_research_collect1caller API—turn-scopeweb:searchnonebackendofferedSearch and read children each re-enter the registry with caller scopes and durable receipts.
dreamlake_research_save1caller API—bothnotes:writewritebackendofferedOnly evidence read in this turn; canonical Memo creation reauthorizes the caller and verifies its body write.
dreamlake_resource_api_control1caller API—bothresources:controlcontrolbackendoffered
dreamlake_resource_api_discover1caller API—turn-scoperesources:readnonebackendoffered
dreamlake_resource_api_read1caller API—bothresources:readnonebackendoffered
dreamlake_resource_api_write1caller API—bothresources:writewritebackendoffered
dreamlake_resource_project_api_control1bothproject · projectId · WRITEbothresources:control projects:writecontrolbackendofferedResolves target and parent via caller API; both must belong to the granted project. Project-root mutations additionally check ADMIN.
dreamlake_resource_project_api_read1bothproject · projectId · READbothprojects:readnonebackendofferedResolves target and parent via caller API; both must belong to the granted project. Project-root mutations additionally check ADMIN.
dreamlake_resource_project_api_write1bothproject · projectId · WRITEbothprojects:writewritebackendofferedResolves target and parent via caller API; both must belong to the granted project. Project-root mutations additionally check ADMIN.
dreamlake_run_macro1caller API—turn-scopelayout:actwritebrowserofferedEach step re-enters the registry and is authorized as its own tool, with its own scope and receipt.
dreamlake_runners_list1caller API—bothsessions:readnonebackendoffered
dreamlake_search_project1bothproject · projectId · READconditional: both when content = true, else grant onlyprojects:readnonebackendofferedName search uses explicit grant authority; organization delegation intersects current human Project access. content:true also searches mounted Memo bodies through the caller API; unreadable Memos are skipped.
dreamlake_session_archive1caller API—bothsessions:controlwritebackendoffered
dreamlake_session_get1caller API—bothsessions:readnonebackendoffered
dreamlake_session_rename1caller API—bothsessions:controlwritebackendoffered
dreamlake_session_resume1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_session_send1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_session_start1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_session_status1caller API—bothsessions:controlnonerunneroffered
dreamlake_session_stop1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_session_subagents1caller API—bothsessions:controlnonerunneroffered
dreamlake_session_sync1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_sessions_activity1caller API—bothsessions:readnonebackendoffered
dreamlake_sessions_broadcast1caller API—bothsessions:controlcontrolrunneroffered
dreamlake_sessions_list1caller API—bothsessions:readnonebackendoffered
dreamlake_skills_list1caller API—turn-scopeskills:readnonebackendofferedPinned server bundle; no user resource.
dreamlake_skills_read1caller API—turn-scopeskills:readnonebackendofferedPinned server bundle; no user resource.
dreamlake_web_read3caller API—turn-scopeweb:readnonebackendofferedPublic web page under caller turn scope; no DreamLake resource.
dreamlake_web_search3caller API—turn-scopeweb:searchnonebackendofferedExternal provider under a deployment credential; no DreamLake resource.