@lucern/sdk 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/lib/platform/sdk/mcpParityClient.js

@@ -0,0 +1,196 @@
+import { createGatewayRequestClient, randomIdempotencyKey, } from "./coreClient.js";
+function withSdkSessionId(args, sessionId) {
+    return {
+        ...(args ?? {}),
+        __sdkSessionId: sessionId,
+    };
+}
+/**
+ * Thin typed bridge for MCP-only SDK parity methods.
+ *
+ * These methods map 1:1 to the Lucern MCP handlers and execute through the
+ * platform gateway so the SDK can cover the full control-plane surface.
+ */
+export function createMcpParityClient(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    const sessionId = crypto.randomUUID();
+    function executeRead(toolName, args) {
+        return gateway.request({
+            path: `/api/platform/v1/mcp-tools/${encodeURIComponent(toolName)}`,
+            method: "POST",
+            body: withSdkSessionId(args, sessionId),
+        });
+    }
+    function executeMutation(toolName, args, idempotencyKey) {
+        return gateway.request({
+            path: `/api/platform/v1/mcp-tools/${encodeURIComponent(toolName)}`,
+            method: "POST",
+            body: withSdkSessionId(args, sessionId),
+            idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+        });
+    }
+    return {
+        sessionId,
+        listTopics(args = {}) {
+            return executeRead("list_topics", args);
+        },
+        createTopic(args, idempotencyKey) {
+            return executeMutation("create_topic", args, idempotencyKey);
+        },
+        getTopic(args) {
+            return executeRead("get_topic", args);
+        },
+        getTopicTree(args) {
+            return executeRead("get_topic_tree", args);
+        },
+        activateWorktree(args, idempotencyKey) {
+            return executeMutation("activate_worktree", args, idempotencyKey);
+        },
+        updateWorktreeMetadata(args, idempotencyKey) {
+            return executeMutation("update_worktree_metadata", args, idempotencyKey);
+        },
+        updateWorktreeTargets(args, idempotencyKey) {
+            return executeMutation("update_worktree_targets", args, idempotencyKey);
+        },
+        listAllWorktrees(args = {}) {
+            return executeRead("list_all_worktrees", args);
+        },
+        pipelineSnapshot(args) {
+            return executeRead("pipeline_snapshot", args);
+        },
+        recordScopeLearning(args, idempotencyKey) {
+            return executeMutation("record_scope_learning", args, idempotencyKey);
+        },
+        discover(args) {
+            return executeRead("discover", args);
+        },
+        analyzeTopicDensity(args) {
+            return executeRead("analyze_topic_density", args);
+        },
+        applyAutoBranching(args, idempotencyKey) {
+            return executeMutation("apply_auto_branching", args, idempotencyKey);
+        },
+        seedBeliefLattice(args = {}, idempotencyKey) {
+            return executeMutation("seed_belief_lattice", args, idempotencyKey);
+        },
+        getLatticeCoverage(args = {}) {
+            return executeRead("get_lattice_coverage", args);
+        },
+        matchEntityType(args) {
+            return executeRead("match_entity_type", args);
+        },
+        discoverEntityConnections(args) {
+            return executeRead("discover_entity_connections", args);
+        },
+        triggerBeliefReview(args, idempotencyKey) {
+            return executeMutation("trigger_belief_review", args, idempotencyKey);
+        },
+        listOntologies(args = {}) {
+            return executeRead("list_ontologies", args);
+        },
+        getOntology(args) {
+            return executeRead("get_ontology", args);
+        },
+        applyOntology(args, idempotencyKey) {
+            return executeMutation("apply_ontology", args, idempotencyKey);
+        },
+        createOntology(args, idempotencyKey) {
+            return executeMutation("create_ontology", args, idempotencyKey);
+        },
+        updateOntology(args, idempotencyKey) {
+            return executeMutation("update_ontology", args, idempotencyKey);
+        },
+        archiveOntology(args, idempotencyKey) {
+            return executeMutation("archive_ontology", args, idempotencyKey);
+        },
+        createOntologyVersion(args, idempotencyKey) {
+            return executeMutation("create_ontology_version", args, idempotencyKey);
+        },
+        publishOntologyVersion(args, idempotencyKey) {
+            return executeMutation("publish_ontology_version", args, idempotencyKey);
+        },
+        deprecateOntologyVersion(args, idempotencyKey) {
+            return executeMutation("deprecate_ontology_version", args, idempotencyKey);
+        },
+        resolveEffectiveOntology(args) {
+            return executeRead("resolve_effective_ontology", args);
+        },
+        registerSession(args = {}, idempotencyKey) {
+            return executeMutation("register_session", args, idempotencyKey);
+        },
+        heartbeatSession(args = {}, idempotencyKey) {
+            return executeMutation("heartbeat_session", args, idempotencyKey);
+        },
+        endSession(args = {}, idempotencyKey) {
+            return executeMutation("end_session", args, idempotencyKey);
+        },
+        listActiveSessions(args = {}) {
+            return executeRead("list_active_sessions", args);
+        },
+        sendAgentMessage(args, idempotencyKey) {
+            return executeMutation("send_agent_message", args, idempotencyKey);
+        },
+        broadcastMessage(args, idempotencyKey) {
+            return executeMutation("broadcast_message", args, idempotencyKey);
+        },
+        getAgentInbox(args = {}) {
+            return executeRead("get_agent_inbox", args);
+        },
+        claimFiles(args, idempotencyKey) {
+            return executeMutation("claim_files", args, idempotencyKey);
+        },
+        listTasks(args) {
+            return executeRead("list_tasks", args);
+        },
+        createAnswer(args, idempotencyKey) {
+            return executeMutation("create_answer", args, idempotencyKey);
+        },
+        getAnswer(args) {
+            return executeRead("get_answer", args);
+        },
+        flagContradiction(args, idempotencyKey) {
+            return executeMutation("flag_contradiction", args, idempotencyKey);
+        },
+        ingestObservation(args, idempotencyKey) {
+            return executeMutation("ingest_observation", args, idempotencyKey);
+        },
+        getObservationContext(args) {
+            return executeRead("get_observation_context", args);
+        },
+        getCodeContext(args) {
+            return executeRead("get_code_context", args);
+        },
+        getChangeHistory(args) {
+            return executeRead("get_change_history", args);
+        },
+        recordAttempt(args, idempotencyKey) {
+            return executeMutation("record_attempt", args, idempotencyKey);
+        },
+        getFailureLog(args) {
+            return executeRead("get_failure_log", args);
+        },
+        createEpistemicContract(args, idempotencyKey) {
+            return executeMutation("create_epistemic_contract", args, idempotencyKey);
+        },
+        evaluateContract(args, idempotencyKey) {
+            return executeMutation("evaluate_contract", args, idempotencyKey);
+        },
+        getContractStatus(args) {
+            return executeRead("get_contract_status", args);
+        },
+        checkPermission(args) {
+            return executeRead("check_permission", args);
+        },
+        filterByPermission(args) {
+            return executeRead("filter_by_permission", args);
+        },
+        manageWritePolicy(args, idempotencyKey) {
+            return args.action === "set"
+                ? executeMutation("manage_write_policy", args, idempotencyKey)
+                : executeRead("manage_write_policy", args);
+        },
+        generateSessionHandoff(args) {
+            return executeRead("generate_session_handoff", args);
+        },
+    };
+}

package/dist/{packages/sdk/src → lib/platform/sdk}/mcpParitySurface.d.ts

@@ -1,8 +1,10 @@
+/** Descriptor mapping an MCP tool name to its SDK method path and read/mutation classification. */
 export type McpParityMethod = {
     toolName: string;
     methodPath: string;
     kind: "read" | "mutation";
 };
+/** Complete registry of MCP tools with SDK parity, mapping tool names to SDK method paths. */
 export declare const SDK_MCP_PARITY_METHODS: readonly McpParityMethod[];
 export declare const SDK_MCP_PARITY_METHOD_PATHS: string[];
 export declare const SDK_MCP_PARITY_TOOL_NAMES: string[];

package/dist/lib/platform/sdk/mcpParitySurface.js

@@ -0,0 +1,57 @@
+/** Complete registry of MCP tools with SDK parity, mapping tool names to SDK method paths. */
+export const SDK_MCP_PARITY_METHODS = [
+    { toolName: "activate_worktree", methodPath: "worktrees.activate", kind: "mutation" },
+    { toolName: "update_worktree_metadata", methodPath: "worktrees.updateMetadata", kind: "mutation" },
+    { toolName: "update_worktree_targets", methodPath: "worktrees.updateTargets", kind: "mutation" },
+    { toolName: "list_all_worktrees", methodPath: "worktrees.listAll", kind: "read" },
+    { toolName: "pipeline_snapshot", methodPath: "worktrees.pipelineSnapshot", kind: "read" },
+    { toolName: "record_scope_learning", methodPath: "context.recordScopeLearning", kind: "mutation" },
+    { toolName: "discover", methodPath: "context.discover", kind: "read" },
+    { toolName: "analyze_topic_density", methodPath: "context.analyzeTopicDensity", kind: "read" },
+    { toolName: "apply_auto_branching", methodPath: "context.applyAutoBranching", kind: "mutation" },
+    { toolName: "seed_belief_lattice", methodPath: "context.seedBeliefLattice", kind: "mutation" },
+    { toolName: "get_lattice_coverage", methodPath: "context.getLatticeCoverage", kind: "read" },
+    { toolName: "match_entity_type", methodPath: "context.matchEntityType", kind: "read" },
+    { toolName: "discover_entity_connections", methodPath: "context.discoverEntityConnections", kind: "read" },
+    { toolName: "trigger_belief_review", methodPath: "context.triggerBeliefReview", kind: "mutation" },
+    { toolName: "list_ontologies", methodPath: "ontologies.list", kind: "read" },
+    { toolName: "get_ontology", methodPath: "ontologies.get", kind: "read" },
+    { toolName: "apply_ontology", methodPath: "ontologies.bind", kind: "mutation" },
+    { toolName: "create_ontology", methodPath: "ontologies.create", kind: "mutation" },
+    { toolName: "update_ontology", methodPath: "ontologies.update", kind: "mutation" },
+    { toolName: "archive_ontology", methodPath: "ontologies.archive", kind: "mutation" },
+    { toolName: "create_ontology_version", methodPath: "ontologies.createVersion", kind: "mutation" },
+    { toolName: "publish_ontology_version", methodPath: "ontologies.publishVersion", kind: "mutation" },
+    { toolName: "deprecate_ontology_version", methodPath: "ontologies.deprecateVersion", kind: "mutation" },
+    { toolName: "resolve_effective_ontology", methodPath: "ontologies.resolveEffective", kind: "read" },
+    { toolName: "register_session", methodPath: "coordination.registerSession", kind: "mutation" },
+    { toolName: "heartbeat_session", methodPath: "coordination.heartbeatSession", kind: "mutation" },
+    { toolName: "end_session", methodPath: "coordination.endSession", kind: "mutation" },
+    { toolName: "list_active_sessions", methodPath: "coordination.listActiveSessions", kind: "read" },
+    { toolName: "send_agent_message", methodPath: "coordination.sendAgentMessage", kind: "mutation" },
+    { toolName: "broadcast_message", methodPath: "coordination.broadcastMessage", kind: "mutation" },
+    { toolName: "get_agent_inbox", methodPath: "coordination.getInbox", kind: "read" },
+    { toolName: "claim_files", methodPath: "coordination.claimFiles", kind: "mutation" },
+    { toolName: "create_topic", methodPath: "topics.create", kind: "mutation" },
+    { toolName: "get_topic", methodPath: "topics.get", kind: "read" },
+    { toolName: "get_topic_tree", methodPath: "topics.getTree", kind: "read" },
+    { toolName: "list_tasks", methodPath: "tasks.list", kind: "read" },
+    { toolName: "create_answer", methodPath: "answers.create", kind: "mutation" },
+    { toolName: "get_answer", methodPath: "answers.get", kind: "read" },
+    { toolName: "flag_contradiction", methodPath: "contradictions.flag", kind: "mutation" },
+    { toolName: "ingest_observation", methodPath: "observations.ingest", kind: "mutation" },
+    { toolName: "get_observation_context", methodPath: "observations.getContext", kind: "read" },
+    { toolName: "get_code_context", methodPath: "coding.getCodeContext", kind: "read" },
+    { toolName: "get_change_history", methodPath: "coding.getChangeHistory", kind: "read" },
+    { toolName: "record_attempt", methodPath: "coding.recordAttempt", kind: "mutation" },
+    { toolName: "get_failure_log", methodPath: "coding.getFailureLog", kind: "read" },
+    { toolName: "create_epistemic_contract", methodPath: "contracts.create", kind: "mutation" },
+    { toolName: "evaluate_contract", methodPath: "contracts.evaluate", kind: "mutation" },
+    { toolName: "get_contract_status", methodPath: "contracts.getStatus", kind: "read" },
+    { toolName: "check_permission", methodPath: "policy.checkPermission", kind: "read" },
+    { toolName: "filter_by_permission", methodPath: "policy.filterByPermission", kind: "read" },
+    { toolName: "manage_write_policy", methodPath: "policy.manageWritePolicy", kind: "mutation" },
+    { toolName: "generate_session_handoff", methodPath: "bootstrap.generateSessionHandoff", kind: "read" },
+];
+export const SDK_MCP_PARITY_METHOD_PATHS = SDK_MCP_PARITY_METHODS.map((entry) => entry.methodPath);
+export const SDK_MCP_PARITY_TOOL_NAMES = SDK_MCP_PARITY_METHODS.map((entry) => entry.toolName);

package/dist/{packages/sdk/src → lib/platform/sdk}/ontologyClient.d.ts

@@ -1,10 +1,13 @@
 import { type GatewayClientConfig, type GatewayScope } from "./coreClient";
 import type { JsonObject } from "./types";
+/** Configuration for the ontology client. */
 export type OntologyClientConfig = GatewayClientConfig;
+/** Input for binding an ontology to a topic. */
 export type OntologyBindingInput = GatewayScope & {
     ontologyId: string;
     topicId: string;
 };
+/** Input for creating an ontology definition. */
 export type OntologyDefinitionInput = GatewayScope & {
     ontologyKey: string;
     name: string;
@@ -12,11 +15,13 @@ export type OntologyDefinitionInput = GatewayScope & {
     tenantId?: string;
     tier?: "platform" | "pack" | "tenant";
 };
+/** Input for updating mutable fields on an ontology definition. */
 export type OntologyDefinitionUpdateInput = GatewayScope & {
     name?: string;
     description?: string;
     status?: "draft" | "active" | "deprecated";
 };
+/** Input for creating a versioned snapshot of entity and edge type definitions. */
 export type OntologyVersionInput = GatewayScope & {
     version: string;
     entityTypes: Array<{
@@ -42,8 +47,13 @@ export type OntologyVersionInput = GatewayScope & {
 };
 /**
  * Create the ontology client for ontology definitions and versions.
+ * @param config - Gateway transport configuration.
+ * @returns An object with methods to manage ontology definitions, versions, and bindings.
  */
 export declare function createOntologyClient(config?: OntologyClientConfig): {
+    /**
+     * List ontology definitions matching optional filters.
+     */
     list(filters?: GatewayScope & {
         tenantId?: string;
         tier?: string;
@@ -54,7 +64,13 @@ export declare function createOntologyClient(config?: OntologyClientConfig): {
         items: any[];
         definitions: any[];
     }>>;
+    /**
+     * Get an ontology definition by identifier.
+     */
     get(id: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+    /**
+     * Bind an ontology definition to a topic.
+     */
     bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
     /**
      * List ontology definitions.

package/dist/lib/platform/sdk/ontologyClient.js

@@ -0,0 +1,161 @@
+import { createGatewayRequestClient, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
+import { createListResult, mapGatewayData } from "./sdkSurface.js";
+/**
+ * Create the ontology client for ontology definitions and versions.
+ * @param config - Gateway transport configuration.
+ * @returns An object with methods to manage ontology definitions, versions, and bindings.
+ */
+export function createOntologyClient(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        /**
+         * List ontology definitions matching optional filters.
+         */
+        async list(filters = {}) {
+            return gateway
+                .request({
+                path: `/api/platform/v1/ontologies${toQueryString(filters)}`,
+            })
+                .then((response) => mapGatewayData(response, (data) => {
+                const record = data && typeof data === "object" && !Array.isArray(data)
+                    ? data
+                    : {};
+                const ontologies = Array.isArray(record.ontologies)
+                    ? record.ontologies
+                    : Array.isArray(record.definitions)
+                        ? record.definitions
+                        : Array.isArray(data)
+                            ? data
+                            : [];
+                const total = typeof record.total === "number" && Number.isFinite(record.total)
+                    ? record.total
+                    : ontologies.length;
+                return {
+                    ...record,
+                    ...createListResult(ontologies, "definitions"),
+                    ontologies,
+                    total,
+                };
+            }));
+        },
+        /**
+         * Get an ontology definition by identifier.
+         */
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`,
+            });
+        },
+        /**
+         * Bind an ontology definition to a topic.
+         */
+        async bind(input, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(input.ontologyId)}/bind`,
+                method: "POST",
+                body: {
+                    topicId: input.topicId,
+                },
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * List ontology definitions.
+         */
+        async listDefinitions(filters = {}) {
+            return this.list(filters);
+        },
+        /**
+         * Get an ontology definition.
+         */
+        async getDefinition(id) {
+            return this.get(id);
+        },
+        /**
+         * Create an ontology definition.
+         */
+        async createDefinition(input, idempotencyKey) {
+            return gateway.request({
+                path: "/api/platform/v1/ontologies",
+                method: "POST",
+                body: input,
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * Update an ontology definition.
+         */
+        async updateDefinition(id, input, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`,
+                method: "PATCH",
+                body: input,
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * Archive an ontology definition.
+         */
+        async archiveDefinition(id, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`,
+                method: "DELETE",
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * List versions for an ontology definition.
+         */
+        async listVersions(ontologyId, filters = {}) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(ontologyId)}/versions${toQueryString(filters)}`,
+            }).then((response) => mapGatewayData(response, (data) => createListResult(Array.isArray(data) ? data : [], "versions")));
+        },
+        /**
+         * Create an ontology version.
+         */
+        async createVersion(ontologyId, input, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(ontologyId)}/versions`,
+                method: "POST",
+                body: input,
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * Publish an ontology version.
+         */
+        async publishVersion(ontologyId, versionId, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(ontologyId)}/versions/${encodeURIComponent(versionId)}/publish`,
+                method: "POST",
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * Deprecate an ontology version.
+         */
+        async deprecateVersion(ontologyId, versionId, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(ontologyId)}/versions/${encodeURIComponent(versionId)}/deprecate`,
+                method: "POST",
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        /**
+         * List topics directly bound to a specific ontology definition.
+         * Uses the topics gateway with ontologyId filter.
+         */
+        async listTopics(ontologyId) {
+            return gateway.request({
+                path: `/api/platform/v1/topics?ontologyId=${encodeURIComponent(ontologyId)}`,
+            }).then((response) => mapGatewayData(response, (data) => createListResult(Array.isArray(data) ? data : [], "topics")));
+        },
+        /**
+         * @deprecated Use listTopics.
+         */
+        async listTopicsByOntology(ontologyId) {
+            return this.listTopics(ontologyId);
+        },
+    };
+}

package/dist/lib/platform/sdk/packRuntime.d.ts

@@ -0,0 +1 @@
+export * from "@/lib/platform/packs";

package/dist/lib/platform/sdk/packRuntime.js

@@ -0,0 +1 @@
+export * from "@/lib/platform/packs";

package/dist/{packages/sdk/src → lib/platform/sdk}/packsClient.d.ts

@@ -2,28 +2,39 @@ import { type GatewayClientConfig, type GatewayScope, LucernApiError } from "./c
 import type { JsonObject } from "./types";
 export { LucernApiError };
 export type { GatewayScope, PlatformGatewaySuccess } from "./coreClient";
+/** Configuration for the packs client. */
 export type PacksClientConfig = GatewayClientConfig;
+/** Input for installing a pack into a tenant or workspace scope. */
 export type PackInstallInput = GatewayScope & {
     packKey: string;
     version?: string;
     autoEnable?: boolean;
     metadata?: JsonObject;
 };
+/** Input for enabling a previously installed pack. */
 export type PackEnableInput = GatewayScope & {
     packKey: string;
     metadata?: JsonObject;
 };
+/** Input for disabling an active pack. */
 export type PackDisableInput = GatewayScope & {
     packKey: string;
     force?: boolean;
     metadata?: JsonObject;
 };
+/** Input for uninstalling a pack from a tenant or workspace scope. */
+export type PackUninstallInput = GatewayScope & {
+    packKey: string;
+    metadata?: JsonObject;
+};
+/** Input for upgrading a pack through the prepare/canary/commit/rollback lifecycle. */
 export type PackUpgradeInput = GatewayScope & {
     packKey: string;
     mode: "prepare" | "canary" | "commit" | "rollback";
     targetVersion?: string;
     metadata?: JsonObject;
 };
+/** Input for creating or updating a pack entitlement record. */
 export type PackEntitlementInput = GatewayScope & {
     packKey: string;
     status: "active" | "disabled" | "revoked";
@@ -34,6 +45,8 @@ export type PackEntitlementInput = GatewayScope & {
 };
 /**
  * Create the packs client for pack catalog, state, and entitlement operations.
+ * @param config - Gateway transport configuration.
+ * @returns An object with methods to manage pack lifecycle, telemetry, and entitlements.
  */
 export declare function createPacksClient(config?: PacksClientConfig): {
     /**
@@ -44,6 +57,14 @@ export declare function createPacksClient(config?: PacksClientConfig): {
      * @deprecated Use listCatalog.
      */
     getCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+    /**
+     * Get the discovery catalog for packs.
+     */
+    getDiscoveryCatalog(): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+    /**
+     * Get discovery details for a specific pack.
+     */
+    getDiscoveryDetail(packKey: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
     /**
      * List pack states for the current scope.
      */
@@ -94,6 +115,10 @@ export declare function createPacksClient(config?: PacksClientConfig): {
      * Disable a pack.
      */
     disable(input: PackDisableInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
+    /**
+     * Uninstall a pack.
+     */
+    uninstall(input: PackUninstallInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
     /**
      * Upgrade a pack.
      */