@sellable/mcp 0.1.753 → 0.1.755

package/dist/tools/integrations.js

@@ -0,0 +1,502 @@
+import { getApi, SellableApiError } from "../api.js";
+/**
+ * The THREE provider-neutral managed-integration tools.
+ *
+ * ## PROVIDER TOOL NAMES ARE ARGUMENTS. That is the architecture in one sentence.
+ *
+ * `gmail-find-email` is a `toolName` STRING passed at call time. Nothing writes it
+ * into a config file, a Hermes profile, a `tools.include` list, or an MCP tool name.
+ * A source scan in `tests/mcp/integration-tools.test.ts` asserts no provider action
+ * key appears under `packages/sellable-install/**` or in any generated config, so
+ * the deleted materialization design cannot creep back.
+ *
+ * Three problems disappear from this phase as a consequence, worth recording so
+ * nobody re-solves them: the `profile-materializer` tool-name regex (no hyphens,
+ * 128 chars, sorted, duplicate-free) never has to accept a hyphenated provider key;
+ * the global-flat-list mutation hazard has no list to mutate; and the context-bloat
+ * problem of materializing N provider tools into every prompt does not exist.
+ *
+ * ## THE ACTOR IS NOT A TOOL INPUT
+ *
+ * No `inputSchema` here carries a requester, a channel, or an actor field, and this
+ * module DESIGNS NO ACTOR MECHANISM — it CONSUMES plan 141-04 T2's. The trusted
+ * triple arrives from `boundary.context` (which the MCP context proxy injects only
+ * after REJECTING any model-supplied `_meta`) and `server.ts` passes it here, where
+ * it becomes an explicit versioned BODY field the route re-verifies against
+ * `WorkspaceSlackIdentity`. A model-supplied actor claim is worthless, so the model
+ * is never offered a place to put one.
+ *
+ * ## WHY `registry.ts` AND `server.ts` ARE SHARED, NOT OWNED
+ *
+ * Phase 142 plan 142-05 adds three CONNECT tools to the same two files. Phase 141
+ * merges first, so 142's edits are additive to this plan's landed set. Neither plan
+ * may claim exclusive ownership of `registry.ts` or `server.ts`, and neither may
+ * reorder the other's entries.
+ *
+ * Registering three tools also grows `SELLABLE_MCP_TOOL_NAMES`, and
+ * `src/lib/sellable-agent/worker-broker.ts:832-837` computes `toolInclude` from it
+ * into the runtime revision manifest — so `toolsHash` moves ONCE. That is expected:
+ * plan 141-04 T1's drift test classifies a moved `toolsHash` as `RELOAD_MCP`, a
+ * one-time installer-version event exercised by plan 141-09's canary. It is NOT a
+ * per-connect event; 141-04's zero-drift proof is about connects.
+ *
+ * Release versioning is not tool registration: `mcp/sellable/package.json` is
+ * UNTOUCHED here and plan 141-09 T2 owns the `@sellable/mcp` WIP version.
+ */
+/**
+ * THE PUBLISHED RESULT ENVELOPE — a cross-phase contract, not prose.
+ *
+ * Plan 142-05 T1 carries `SA142-52`, which requires the connect tools' envelopes to
+ * MIRROR this one key-for-key, and instructs its executor to STOP and report rather
+ * than guess if the contract "is not importable from the MCP package". So it is
+ * exported, frozen, and structurally asserted against every handler result.
+ *
+ * The key set is STABLE across success and failure — `error` and `guidance` are
+ * present as `null` rather than omitted — which is what makes a structural
+ * comparison possible at all.
+ *
+ * | key           | meaning                                                        |
+ * | ------------- | -------------------------------------------------------------- |
+ * | `ok`          | the success/failure DISCRIMINATOR                              |
+ * | `outcome`     | snake_case: `ok`, `refused`, `approval_required`, `catalog_incomplete`, `not_connected`, `upstream_degraded` |
+ * | `attribution` | snake_case: `provider`, `configuration`, `policy`, `sellable`   |
+ * | `error`       | the snake_case code, forwarded VERBATIM from the route          |
+ * | `guidance`    | one human sentence, or `null`                                   |
+ * | `result`      | the payload                                                     |
+ *
+ * `approval_required` and `catalog_incomplete` are RESULTS inside this envelope, not
+ * errors: the Agent must be able to explain them, not just fail.
+ */
+export const INTEGRATIONS_RESULT_ENVELOPE_KEYS = Object.freeze([
+    "ok",
+    "outcome",
+    "attribution",
+    "error",
+    "guidance",
+    "result",
+]);
+const SELECTOR_PATTERN = /^[a-z0-9_-]+$/i;
+const LIST_PATH = "/api/v3/sellable-agent/integrations/tools/list";
+const DESCRIBE_PATH = "/api/v3/sellable-agent/integrations/tools/describe";
+const CALL_PATH = "/api/v3/sellable-agent/integrations/tools/call";
+/**
+ * The client-side deadline, in milliseconds.
+ *
+ * The backend routes export `maxDuration` 20 s (the two reads) and 40 s (the call),
+ * so these sit just above them: the server's own truthful error wins the race and
+ * the client bound only fires when the server never answered at all. Before this
+ * plan there was NO client-side timeout anywhere in `api.ts`, which meant a hung
+ * backend hung the whole Slack turn.
+ */
+const READ_TIMEOUT_MS = 25_000;
+const CALL_TIMEOUT_MS = 45_000;
+const SELECTOR_PROPERTIES = {
+    appSlug: {
+        type: "string",
+        minLength: 1,
+        maxLength: 64,
+        description: "The connected app, e.g. 'gmail'. Use this when the workspace has exactly one connected account for the app; if it has more than one, the call is refused as ambiguous and you must pass accountLabel instead.",
+    },
+    bindingId: {
+        type: "string",
+        minLength: 1,
+        maxLength: 64,
+        description: "An exact integration binding id, as returned by a previous integrations_list_tools call.",
+    },
+    accountLabel: {
+        type: "string",
+        minLength: 1,
+        maxLength: 120,
+        description: "The human label the user gave the connected account. This is the ONLY way to tell two connections over the same inbox apart, because the provider's own account name can be byte-identical for both.",
+    },
+};
+const ENVELOPE_OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        ok: { type: "boolean" },
+        outcome: {
+            type: "string",
+            enum: [
+                "ok",
+                "refused",
+                "approval_required",
+                "catalog_incomplete",
+                "not_connected",
+                "upstream_degraded",
+            ],
+        },
+        attribution: {
+            type: "string",
+            enum: ["provider", "configuration", "policy", "sellable"],
+        },
+        error: { type: ["string", "null"] },
+        guidance: { type: ["string", "null"] },
+        result: {},
+    },
+    required: ["ok", "outcome", "attribution", "error", "guidance", "result"],
+    additionalProperties: false,
+};
+export const integrationsToolDefinitions = [
+    {
+        name: "integrations_list_tools",
+        description: "List the provider actions this Agent is allowed to run against a connected app, for one connected account. Returns only reviewed, policy-allowed actions plus a COUNT of the ones that are not allowed, so you can truthfully say there are actions you cannot run without naming them. Call this before integrations_describe_tool or integrations_call_tool. A 'catalog_incomplete' outcome means the provider catalog could not be read completely — it does NOT mean the app has no usable actions.",
+        inputSchema: {
+            type: "object",
+            properties: SELECTOR_PROPERTIES,
+            required: [],
+            additionalProperties: false,
+        },
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        annotations: {
+            title: "List allowed integration actions",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: "integrations_describe_tool",
+        description: "Describe one allowed provider action's arguments before calling it: per argument you get its type, whether it is required, its default, and its category. For an argument whose valid values come from a remote lookup you get either the resolved option list or an explicit marker telling you to ask the user or narrow the query. The connected account is pinned server-side and is never an argument you supply. Use this instead of guessing at an argument shape.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...SELECTOR_PROPERTIES,
+                toolName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                    description: "The provider action key, exactly as returned by integrations_list_tools, e.g. 'gmail-find-email'.",
+                },
+                propName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                    description: "Resolve the option list for just this one argument, instead of every argument.",
+                },
+                optionQuery: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 200,
+                    description: "A server-side filter applied while resolving that argument's options, so a large list can be narrowed rather than truncated.",
+                },
+            },
+            required: ["toolName"],
+            additionalProperties: false,
+        },
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Describe an allowed integration action",
+            // Resolving options is a READ: `components/configure` creates no provider
+            // state.
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: "integrations_call_tool",
+        description: "Run one allowed provider action against a connected account. The exact account is resolved server-side from the binding — you never pass an account id, and one passed in the arguments is rejected. An action outside the reviewed allowlist is refused permanently: that is a policy decision, not a validation problem, so do not retry it with different arguments. An 'approval_required' outcome means a human must approve this exact call on the Integrations page first.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...SELECTOR_PROPERTIES,
+                toolName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                    description: "The provider action key, exactly as returned by integrations_list_tools.",
+                },
+                arguments: {
+                    type: "object",
+                    description: "The action's arguments, using the exact names integrations_describe_tool returned. The connected account, the authorization, and the provider user id are all set server-side and are stripped if present here.",
+                    additionalProperties: true,
+                },
+                approvalId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                    description: "The approval reference returned by a previous approval_required outcome for these EXACT arguments.",
+                },
+            },
+            required: ["toolName"],
+            additionalProperties: false,
+        },
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Run an allowed integration action",
+            /**
+             * DECLARED HONESTLY as `false`, even though every v1-allowlisted Gmail
+             * action is `readOnlyHint: true`.
+             *
+             * This tool is PROVIDER-NEUTRAL and its allowlist is DATA: the moment a
+             * mutating action is promoted on any binding, a `true` here becomes a lie
+             * that no test would catch, because nothing would have changed in this file.
+             * A false negative on an annotation costs a little caution; a false positive
+             * costs a silent write.
+             */
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+];
+/**
+ * The two CLOSED enums, read off the declared `outputSchema` so there is one source.
+ *
+ * `outcome` and `attribution` are validated by the MCP CLIENT against
+ * `ENVELOPE_OUTPUT_SCHEMA` (`@modelcontextprotocol/sdk` runs ajv over
+ * `structuredContent`; the python SDK does the same via `jsonschema`). An off-enum
+ * value therefore does not degrade the envelope — it makes the client reject the
+ * WHOLE response, so the operator loses the refusal AND its reason.
+ *
+ * `toolError` forwards the route's fields VERBATIM, and off-enum values exist
+ * server-side already (`attribution: "app"` in
+ * `src/lib/sellable-agent/integration-connect-copy.ts`). So an unrecognized value is
+ * normalized FAIL-CLOSED to a refusal by `sellable`, while the route's `error` code —
+ * the field that actually carries the reason — is still forwarded verbatim.
+ */
+const ENVELOPE_OUTCOMES = ENVELOPE_OUTPUT_SCHEMA.properties.outcome.enum;
+const ENVELOPE_ATTRIBUTIONS = ENVELOPE_OUTPUT_SCHEMA.properties.attribution.enum;
+function envelope(value) {
+    const outcome = value.outcome ?? (value.ok ? "ok" : "refused");
+    const attribution = value.attribution ?? (value.ok ? "policy" : "sellable");
+    return {
+        ok: value.ok,
+        outcome: ENVELOPE_OUTCOMES.includes(outcome)
+            ? outcome
+            : value.ok
+                ? "ok"
+                : "refused",
+        attribution: ENVELOPE_ATTRIBUTIONS.includes(attribution)
+            ? attribution
+            : "sellable",
+        error: value.error ?? null,
+        guidance: value.guidance ?? null,
+        result: value.result ?? null,
+    };
+}
+/**
+ * Errors are RETURNED, never thrown, and the route's `error` is forwarded VERBATIM.
+ *
+ * No MCP-side error-code list is exported: this helper forwards whatever the route
+ * said, so a hand-copied list would be a second maintained list the MCP never
+ * produces. Copied in shape from `company-info.ts:96-125`.
+ */
+function toolError(action, error) {
+    if (error instanceof SellableApiError) {
+        let forwarded = {};
+        try {
+            const parsed = JSON.parse(error.body);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                forwarded = parsed;
+            }
+        }
+        catch {
+            // Plain-text body; fall through to the generic shape below.
+        }
+        return envelope({
+            ok: false,
+            outcome: typeof forwarded.outcome === "string" ? forwarded.outcome : "refused",
+            attribution: typeof forwarded.attribution === "string"
+                ? forwarded.attribution
+                : error.isAuthError
+                    ? "policy"
+                    : "sellable",
+            error: typeof forwarded.error === "string"
+                ? forwarded.error
+                : `integration_${action}_failed`,
+            guidance: typeof forwarded.guidance === "string"
+                ? forwarded.guidance
+                : (error.guidance ?? null),
+            result: forwarded.detail ?? null,
+        });
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    return envelope({
+        ok: false,
+        outcome: "refused",
+        attribution: "sellable",
+        error: `integration_${action}_failed`,
+        guidance: reason,
+    });
+}
+/** Bound validation that REJECTS before any API call is made. */
+function validateSelector(input) {
+    const selector = {};
+    for (const key of ["appSlug", "bindingId"]) {
+        const value = input[key];
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value !== "string" ||
+            value.length < 1 ||
+            value.length > 64 ||
+            !SELECTOR_PATTERN.test(value)) {
+            return {
+                ok: false,
+                envelope: envelope({
+                    ok: false,
+                    error: "integration_selector_rejected",
+                    guidance: `${key} must be 1-64 characters of letters, digits, hyphen, or underscore.`,
+                }),
+            };
+        }
+        selector[key] = value;
+    }
+    const label = input.accountLabel;
+    if (label !== undefined && label !== null) {
+        if (typeof label !== "string" || label.length < 1 || label.length > 120) {
+            return {
+                ok: false,
+                envelope: envelope({
+                    ok: false,
+                    error: "integration_selector_rejected",
+                    guidance: "accountLabel must be 1-120 characters.",
+                }),
+            };
+        }
+        selector.accountLabel = label;
+    }
+    if (Object.keys(selector).length === 0) {
+        return {
+            ok: false,
+            envelope: envelope({
+                ok: false,
+                error: "integration_selector_required",
+                guidance: "Pass appSlug, bindingId, or accountLabel to say which connected account to use.",
+            }),
+        };
+    }
+    return { ok: true, selector };
+}
+function validateToolName(value) {
+    if (typeof value !== "string" ||
+        value.length < 1 ||
+        value.length > 128 ||
+        !SELECTOR_PATTERN.test(value)) {
+        return {
+            ok: false,
+            envelope: envelope({
+                ok: false,
+                error: "integration_tool_name_rejected",
+                guidance: "toolName must be a provider action key of 1-128 characters, exactly as integrations_list_tools returned it.",
+            }),
+        };
+    }
+    return { ok: true, toolName: value };
+}
+/**
+ * The actor travels as EXPLICIT BODY FIELDS. `server.ts` supplies the verified
+ * triple; the model has no way to reach these keys because no `inputSchema`
+ * declares them.
+ */
+function actorBody(actor) {
+    if (!actor)
+        return {};
+    return {
+        slackRequesterId: actor.requesterId,
+        slackChannelId: actor.channelId,
+        providerRequestId: actor.providerRequestId,
+    };
+}
+function normalizeRouteResult(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return envelope({
+            ok: false,
+            error: "integration_response_malformed",
+            guidance: "The Sellable integrations API returned an unexpected shape. Retry after refreshing the Sellable MCP package.",
+        });
+    }
+    const record = value;
+    const { ok, outcome, attribution, error, guidance, terminal, status, ...rest } = record;
+    void terminal;
+    void status;
+    return envelope({
+        ok: ok === true,
+        outcome: typeof outcome === "string" ? outcome : undefined,
+        attribution: typeof attribution === "string" ? attribution : undefined,
+        error: typeof error === "string" ? error : null,
+        guidance: typeof guidance === "string" ? guidance : null,
+        result: Object.keys(rest).length ? rest : null,
+    });
+}
+export async function integrationsListTools(input = {}, actor, agentEffectId) {
+    const selector = validateSelector(input);
+    if (!selector.ok)
+        return selector.envelope;
+    try {
+        const response = await getApi().post(LIST_PATH, { ...selector.selector, ...actorBody(actor) }, {
+            timeoutMs: READ_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        return normalizeRouteResult(response);
+    }
+    catch (error) {
+        return toolError("list_tools", error);
+    }
+}
+export async function integrationsDescribeTool(input = {}, actor, agentEffectId) {
+    const selector = validateSelector(input);
+    if (!selector.ok)
+        return selector.envelope;
+    const tool = validateToolName(input.toolName);
+    if (!tool.ok)
+        return tool.envelope;
+    try {
+        const response = await getApi().post(DESCRIBE_PATH, {
+            ...selector.selector,
+            toolName: tool.toolName,
+            ...(typeof input.propName === "string" && input.propName
+                ? { propName: input.propName }
+                : {}),
+            ...(typeof input.optionQuery === "string" && input.optionQuery
+                ? { optionQuery: input.optionQuery }
+                : {}),
+            ...actorBody(actor),
+        }, {
+            timeoutMs: READ_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        return normalizeRouteResult(response);
+    }
+    catch (error) {
+        return toolError("describe_tool", error);
+    }
+}
+export async function integrationsCallTool(input = {}, actor, agentEffectId) {
+    const selector = validateSelector(input);
+    if (!selector.ok)
+        return selector.envelope;
+    const tool = validateToolName(input.toolName);
+    if (!tool.ok)
+        return tool.envelope;
+    const args = input.arguments;
+    if (args !== undefined &&
+        (args === null || typeof args !== "object" || Array.isArray(args))) {
+        return envelope({
+            ok: false,
+            error: "integration_arguments_rejected",
+            guidance: "arguments must be an object keyed by the argument names integrations_describe_tool returned.",
+        });
+    }
+    try {
+        const response = await getApi().post(CALL_PATH, {
+            ...selector.selector,
+            toolName: tool.toolName,
+            ...(args ? { arguments: args } : {}),
+            ...(typeof input.approvalId === "string" && input.approvalId
+                ? { approvalId: input.approvalId }
+                : {}),
+            ...actorBody(actor),
+        }, {
+            timeoutMs: CALL_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        return normalizeRouteResult(response);
+    }
+    catch (error) {
+        return toolError("call_tool", error);
+    }
+}

package/dist/tools/registry.d.ts

@@ -8623,6 +8623,161 @@ export declare const allTools: ({
         openWorldHint: boolean;
         idempotentHint: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            toolName: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            propName: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            optionQuery: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            appSlug: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "The connected app, e.g. 'gmail'. Use this when the workspace has exactly one connected account for the app; if it has more than one, the call is refused as ambiguous and you must pass accountLabel instead.";
+            };
+            bindingId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "An exact integration binding id, as returned by a previous integrations_list_tools call.";
+            };
+            accountLabel: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 120;
+                readonly description: "The human label the user gave the connected account. This is the ONLY way to tell two connections over the same inbox apart, because the provider's own account name can be byte-identical for both.";
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly ok: {
+                readonly type: "boolean";
+            };
+            readonly outcome: {
+                readonly type: "string";
+                readonly enum: readonly ["ok", "refused", "approval_required", "catalog_incomplete", "not_connected", "upstream_degraded"];
+            };
+            readonly attribution: {
+                readonly type: "string";
+                readonly enum: readonly ["provider", "configuration", "policy", "sellable"];
+            };
+            readonly error: {
+                readonly type: readonly ["string", "null"];
+            };
+            readonly guidance: {
+                readonly type: readonly ["string", "null"];
+            };
+            readonly result: {};
+        };
+        readonly required: readonly ["ok", "outcome", "attribution", "error", "guidance", "result"];
+        readonly additionalProperties: false;
+    };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            toolName: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            arguments: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+            };
+            approvalId: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+                description: string;
+            };
+            appSlug: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "The connected app, e.g. 'gmail'. Use this when the workspace has exactly one connected account for the app; if it has more than one, the call is refused as ambiguous and you must pass accountLabel instead.";
+            };
+            bindingId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 64;
+                readonly description: "An exact integration binding id, as returned by a previous integrations_list_tools call.";
+            };
+            accountLabel: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 120;
+                readonly description: "The human label the user gave the connected account. This is the ONLY way to tell two connections over the same inbox apart, because the provider's own account name can be byte-identical for both.";
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly ok: {
+                readonly type: "boolean";
+            };
+            readonly outcome: {
+                readonly type: "string";
+                readonly enum: readonly ["ok", "refused", "approval_required", "catalog_incomplete", "not_connected", "upstream_degraded"];
+            };
+            readonly attribution: {
+                readonly type: "string";
+                readonly enum: readonly ["provider", "configuration", "policy", "sellable"];
+            };
+            readonly error: {
+                readonly type: readonly ["string", "null"];
+            };
+            readonly guidance: {
+                readonly type: readonly ["string", "null"];
+            };
+            readonly result: {};
+        };
+        readonly required: readonly ["ok", "outcome", "attribution", "error", "guidance", "result"];
+        readonly additionalProperties: false;
+    };
+    annotations: {
+        title: string;
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;