@holon-run/agentinbox 0.7.0 → 1.0.0-beta.1

package/dist/src/source_hosts.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSourceRegistration = resolveSourceRegistration;
+function resolveSourceRegistration(input) {
+    const config = input.config ?? {};
+    if (input.sourceType === "github_repo") {
+        return {
+            hostType: "github",
+            hostKey: `uxcAuth:${stringOrDefault(config.uxcAuth, input.configRef ?? "default")}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "repo_events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "github_repo_ci") {
+        return {
+            hostType: "github",
+            hostKey: `uxcAuth:${stringOrDefault(config.uxcAuth, input.configRef ?? "default")}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "ci_runs",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "feishu_bot") {
+        return {
+            hostType: "feishu",
+            hostKey: `app:${stringOrDefault(config.appId, input.configRef ?? input.sourceKey)}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.appId) ? { appId: config.appId } : {}),
+                ...(valueOrUndefined(config.appSecret) ? { appSecret: config.appSecret } : {}),
+                ...(valueOrUndefined(config.schemaUrl) ? { schemaUrl: config.schemaUrl } : {}),
+                ...(valueOrUndefined(config.replyInThread) ? { replyInThread: config.replyInThread } : {}),
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "message_events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "local_event") {
+        return {
+            hostType: "local_event",
+            hostKey: input.sourceKey,
+            hostConfig: {},
+            streamKind: "events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    return {
+        hostType: "remote_source",
+        hostKey: input.sourceKey,
+        hostConfig: config,
+        streamKind: "default",
+        streamKey: input.sourceKey,
+        streamConfig: config,
+        sourceType: input.sourceType,
+    };
+}
+function stringOrDefault(value, fallback) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+function valueOrUndefined(value) {
+    return value !== undefined && value !== null;
+}

package/dist/src/source_resolution.js

@@ -25,7 +25,7 @@ async function resolveSourceIdentity(source, context = {}) {
     if (source.sourceType !== "remote_source") {
         throw new Error(`unsupported source type for source resolution: ${source.sourceType}`);
     }
-    const moduleRegistry = context.moduleRegistry ?? context.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     const module = await moduleRegistry.resolve(source, homeDir);
     const capabilityDescription = typeof module.describeCapabilities === "function"
@@ -38,7 +38,7 @@ async function resolveSourceIdentity(source, context = {}) {
     };
 }
 async function resolveSourceSchema(source, context = {}) {
-    const moduleRegistry = context.moduleRegistry ?? context.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     const resolvedContext = { ...context, moduleRegistry, homeDir };
     const identity = await resolveSourceIdentity(source, resolvedContext);

package/dist/src/source_schema.js

@@ -21,8 +21,8 @@ const SOURCE_SCHEMAS = {
         payloadExamples: [],
         eventVariantExamples: [],
         configFields: [
-            { name: "profilePath", type: "string", required: true, description: "Local module path under $AGENTINBOX_HOME/source-profiles." },
-            { name: "profileConfig", type: "object", required: false, description: "Module-specific configuration passed to validate/spec/map hooks." },
+            { name: "modulePath", type: "string", required: true, description: "Local module path under $AGENTINBOX_HOME/source-modules." },
+            { name: "moduleConfig", type: "object", required: false, description: "Module-specific configuration passed to validate/spec/map hooks." },
         ],
     },
     github_repo: {

package/dist/src/sources/feishu.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeishuDeliveryAdapter = exports.FeishuUxcClient = exports.DEFAULT_FEISHU_EVENT_TYPES = exports.FEISHU_IM_SCHEMA_URL = exports.FEISHU_OPENAPI_ENDPOINT = void 0;
+exports.feishuDeliveryOperationsForHandle = feishuDeliveryOperationsForHandle;
+exports.invokeFeishuDeliveryOperation = invokeFeishuDeliveryOperation;
 exports.normalizeFeishuBotEvent = normalizeFeishuBotEvent;
 exports.parseFeishuSourceConfig = parseFeishuSourceConfig;
 const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
@@ -54,37 +56,73 @@ class FeishuDeliveryAdapter {
         this.client = client ?? new FeishuUxcClient();
     }
     async send(request, attempt) {
-        const config = parseDeliveryConfig(request.payload);
-        const message = normalizeDeliveryMessage(request.payload);
-        if (attempt.surface === "message_reply") {
-            await this.client.replyToMessage({
-                endpoint: config.endpoint,
-                schemaUrl: config.schemaUrl,
-                auth: config.auth,
-                messageId: attempt.targetRef,
-                msgType: message.msgType,
-                content: message.content,
-                replyInThread: config.replyInThread,
-                uuid: config.uuid,
-            });
-            return { status: "sent", note: "sent Feishu message reply" };
-        }
-        if (attempt.surface === "chat_message") {
-            await this.client.sendChatMessage({
-                endpoint: config.endpoint,
-                schemaUrl: config.schemaUrl,
-                auth: config.auth,
-                chatId: attempt.targetRef,
-                msgType: message.msgType,
-                content: message.content,
-                uuid: config.uuid,
-            });
-            return { status: "sent", note: "sent Feishu chat message" };
-        }
-        throw new Error(`unsupported Feishu surface: ${attempt.surface}`);
+        return invokeFeishuDeliveryOperation(attempt, "send_text", request.payload, this.client);
     }
 }
 exports.FeishuDeliveryAdapter = FeishuDeliveryAdapter;
+function feishuDeliveryOperationsForHandle(handle) {
+    if (handle.surface !== "message_reply" && handle.surface !== "chat_message") {
+        return [];
+    }
+    return [{
+            name: "send_text",
+            title: handle.surface === "message_reply" ? "Reply With Text" : "Send Text Message",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["text"],
+                properties: {
+                    text: { type: "string", minLength: 1 },
+                    endpoint: { type: "string", minLength: 1 },
+                    schemaUrl: { type: "string", minLength: 1 },
+                    schema_url: { type: "string", minLength: 1 },
+                    uxcAuth: { type: "string", minLength: 1 },
+                    auth: { type: "string", minLength: 1 },
+                    replyInThread: { type: "boolean" },
+                    reply_in_thread: { type: "boolean" },
+                    uuid: { type: "string", minLength: 1 },
+                },
+            },
+            canonicalTextAlias: true,
+        }];
+}
+async function invokeFeishuDeliveryOperation(handle, operation, input, client = new FeishuUxcClient()) {
+    if (operation !== "send_text") {
+        throw new Error(`unknown Feishu delivery operation: ${operation}`);
+    }
+    const text = asString(input.text);
+    if (!text || text.trim().length === 0) {
+        throw new Error("send_text requires input.text");
+    }
+    const config = parseDeliveryConfig(input);
+    const message = normalizeDeliveryMessage({ text });
+    if (handle.surface === "message_reply") {
+        await client.replyToMessage({
+            endpoint: config.endpoint,
+            schemaUrl: config.schemaUrl,
+            auth: config.auth,
+            messageId: handle.targetRef,
+            msgType: message.msgType,
+            content: message.content,
+            replyInThread: config.replyInThread,
+            uuid: config.uuid,
+        });
+        return { status: "sent", note: "sent Feishu message reply" };
+    }
+    if (handle.surface === "chat_message") {
+        await client.sendChatMessage({
+            endpoint: config.endpoint,
+            schemaUrl: config.schemaUrl,
+            auth: config.auth,
+            chatId: handle.targetRef,
+            msgType: message.msgType,
+            content: message.content,
+            uuid: config.uuid,
+        });
+        return { status: "sent", note: "sent Feishu chat message" };
+    }
+    throw new Error(`deliver send only supports canonical Feishu text surfaces; use deliver invoke for ${handle.surface}`);
+}
 function normalizeFeishuBotEvent(source, config, raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return null;

package/dist/src/sources/github.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GithubDeliveryAdapter = exports.GithubUxcClient = exports.DEFAULT_GITHUB_EVENT_TYPES = exports.GITHUB_ENDPOINT = void 0;
+exports.githubDeliveryOperationsForHandle = githubDeliveryOperationsForHandle;
+exports.invokeGithubDeliveryOperation = invokeGithubDeliveryOperation;
 exports.normalizeGithubRepoEvent = normalizeGithubRepoEvent;
+exports.canonicalGithubPullRequestRef = canonicalGithubPullRequestRef;
 exports.deriveGithubTrackedResource = deriveGithubTrackedResource;
 exports.githubSubscriptionShortcutSpec = githubSubscriptionShortcutSpec;
 exports.expandGithubSubscriptionShortcut = expandGithubSubscriptionShortcut;
@@ -48,6 +51,34 @@ class GithubUxcClient {
             options: { auth: input.auth },
         });
     }
+    async updateIssueState(input) {
+        await this.client.call({
+            endpoint: exports.GITHUB_ENDPOINT,
+            operation: "patch:/repos/{owner}/{repo}/issues/{issue_number}",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                issue_number: input.issueNumber,
+                state: input.state,
+            },
+            options: { auth: input.auth },
+        });
+    }
+    async mergePullRequest(input) {
+        await this.client.call({
+            endpoint: exports.GITHUB_ENDPOINT,
+            operation: "put:/repos/{owner}/{repo}/pulls/{pull_number}/merge",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                pull_number: input.pullNumber,
+                merge_method: input.mergeMethod ?? null,
+                commit_title: input.commitTitle ?? null,
+                commit_message: input.commitMessage ?? null,
+            },
+            options: { auth: input.auth },
+        });
+    }
 }
 exports.GithubUxcClient = GithubUxcClient;
 class GithubDeliveryAdapter {
@@ -57,33 +88,131 @@ class GithubDeliveryAdapter {
     }
     async send(request, attempt) {
         const payloadText = stringifyDeliveryPayload(request.payload);
-        const target = parseTargetRef(attempt.targetRef);
-        if (attempt.surface === "issue_comment" || attempt.surface === "pull_request_comment") {
-            await this.client.createIssueComment({
-                owner: target.owner,
-                repo: target.repo,
-                issueNumber: target.number,
-                body: payloadText,
-            });
-            return { status: "sent", note: "sent GitHub issue comment" };
-        }
-        if (attempt.surface === "review_comment") {
-            if (!attempt.threadRef || !attempt.threadRef.startsWith("review_comment:")) {
-                throw new Error("review_comment delivery requires threadRef=review_comment:<id>");
-            }
-            await this.client.replyToReviewComment({
-                owner: target.owner,
-                repo: target.repo,
-                pullNumber: target.number,
-                commentId: Number(attempt.threadRef.slice("review_comment:".length)),
-                body: payloadText,
-            });
-            return { status: "sent", note: "sent GitHub review comment reply" };
-        }
-        throw new Error(`unsupported GitHub surface: ${attempt.surface}`);
+        return invokeGithubDeliveryOperation(attempt, canonicalGithubOperationForSurface(attempt.surface), { body: payloadText }, this.client);
     }
 }
 exports.GithubDeliveryAdapter = GithubDeliveryAdapter;
+function githubDeliveryOperationsForHandle(handle) {
+    if (handle.surface === "review_comment") {
+        return [{
+                name: "reply_in_review_thread",
+                title: "Reply In Review Thread",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            }];
+    }
+    if (handle.surface === "issue_comment") {
+        return [
+            {
+                name: "add_comment",
+                title: "Add Comment",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            },
+            {
+                name: "close_issue",
+                title: "Close Issue",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "reopen_issue",
+                title: "Reopen Issue",
+                inputSchema: emptyObjectSchema(),
+            },
+        ];
+    }
+    if (handle.surface === "pull_request_comment") {
+        return [
+            {
+                name: "add_comment",
+                title: "Add Comment",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            },
+            {
+                name: "close_issue",
+                title: "Close Pull Request",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "reopen_issue",
+                title: "Reopen Pull Request",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "merge_pull_request",
+                title: "Merge Pull Request",
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        mergeMethod: { type: "string", enum: ["merge", "squash", "rebase"] },
+                        commitTitle: { type: "string" },
+                        commitMessage: { type: "string" },
+                    },
+                },
+            },
+        ];
+    }
+    return [];
+}
+async function invokeGithubDeliveryOperation(handle, operation, input, client = new GithubUxcClient()) {
+    const target = parseTargetRef(handle.targetRef);
+    if (operation === "add_comment") {
+        const body = requireDeliveryBody(input, operation);
+        await client.createIssueComment({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            body,
+        });
+        return { status: "sent", note: "sent GitHub issue comment" };
+    }
+    if (operation === "reply_in_review_thread") {
+        const body = requireDeliveryBody(input, operation);
+        if (!handle.threadRef || !handle.threadRef.startsWith("review_comment:")) {
+            throw new Error("reply_in_review_thread requires threadRef=review_comment:<id>");
+        }
+        await client.replyToReviewComment({
+            owner: target.owner,
+            repo: target.repo,
+            pullNumber: target.number,
+            commentId: Number(handle.threadRef.slice("review_comment:".length)),
+            body,
+        });
+        return { status: "sent", note: "sent GitHub review comment reply" };
+    }
+    if (operation === "close_issue") {
+        await client.updateIssueState({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            state: "closed",
+        });
+        return { status: "sent", note: "closed GitHub issue" };
+    }
+    if (operation === "reopen_issue") {
+        await client.updateIssueState({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            state: "open",
+        });
+        return { status: "sent", note: "reopened GitHub issue" };
+    }
+    if (operation === "merge_pull_request") {
+        await client.mergePullRequest({
+            owner: target.owner,
+            repo: target.repo,
+            pullNumber: target.number,
+            mergeMethod: asMergeMethod(input.mergeMethod),
+            commitTitle: asString(input.commitTitle) ?? undefined,
+            commitMessage: asString(input.commitMessage) ?? undefined,
+        });
+        return { status: "sent", note: "merged GitHub pull request" };
+    }
+    throw new Error(`unknown GitHub delivery operation: ${operation}`);
+}
 function normalizeGithubRepoEvent(source, config, raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return null;
@@ -154,7 +283,11 @@ function normalizeGithubRepoEvent(source, config, raw) {
         deliveryHandle,
     };
 }
-function deriveGithubTrackedResource(filter) {
+function canonicalGithubPullRequestRef(source, number) {
+    const config = parseGithubSourceConfig(source);
+    return `repo:${config.owner}/${config.repo}:pr:${number}`;
+}
+function deriveGithubTrackedResource(filter, source) {
     const metadata = asRecord(filter.metadata);
     const payload = asRecord(filter.payload);
     const number = asNumber(metadata.number) ?? asNumber(payload.number) ?? asNumber(payload.ref);
@@ -162,13 +295,16 @@ function deriveGithubTrackedResource(filter) {
     if (!number || isPullRequest !== true) {
         return null;
     }
-    return { ref: `pr:${number}` };
+    return { ref: canonicalGithubPullRequestRef(source, number) };
 }
 function githubSubscriptionShortcutSpec() {
     return [{
             name: "pr",
             description: "Follow one pull request and auto-retire when it closes.",
-            argsSchema: [{ name: "number", type: "number", required: true, description: "Pull request number." }],
+            argsSchema: [
+                { name: "number", type: "number", required: true, description: "Pull request number." },
+                { name: "withCi", type: "boolean", required: false, description: "Also create a sibling ci_runs subscription under the same host and stream key." },
+            ],
         }];
 }
 function expandGithubSubscriptionShortcut(input) {
@@ -179,18 +315,32 @@ function expandGithubSubscriptionShortcut(input) {
     if (!number || !Number.isInteger(number) || number <= 0) {
         throw new Error("subscription shortcut pr requires a positive integer number");
     }
+    const trackedResourceRef = canonicalGithubPullRequestRef(input.source, number);
+    const withCi = input.args?.withCi === true;
     return {
-        filter: {
-            metadata: {
-                number,
-                isPullRequest: true,
+        members: [
+            {
+                streamKind: "repo_events",
+                filter: {
+                    metadata: {
+                        number,
+                        isPullRequest: true,
+                    },
+                },
+                trackedResourceRef,
+                cleanupPolicy: { mode: "on_terminal" },
             },
-        },
-        trackedResourceRef: `pr:${number}`,
-        cleanupPolicy: { mode: "on_terminal" },
+            ...(withCi
+                ? [{
+                        streamKind: "ci_runs",
+                        trackedResourceRef,
+                        cleanupPolicy: { mode: "on_terminal" },
+                    }]
+                : []),
+        ],
     };
 }
-function projectGithubLifecycleSignal(rawPayload) {
+function projectGithubLifecycleSignal(rawPayload, source) {
     const eventType = asString(rawPayload.type);
     if (eventType !== "PullRequestEvent") {
         return null;
@@ -206,7 +356,7 @@ function projectGithubLifecycleSignal(rawPayload) {
     }
     const merged = action === "merged" || asBoolean(rawPayload.merged) === true || asBoolean(pullRequest.merged) === true;
     return {
-        ref: `pr:${number}`,
+        ref: canonicalGithubPullRequestRef(source, number),
         terminal: true,
         state: "closed",
         result: merged ? "merged" : "closed",
@@ -300,6 +450,42 @@ function stringifyDeliveryPayload(payload) {
     }
     return JSON.stringify(payload, null, 2);
 }
+function canonicalGithubOperationForSurface(surface) {
+    if (surface === "issue_comment" || surface === "pull_request_comment") {
+        return "add_comment";
+    }
+    if (surface === "review_comment") {
+        return "reply_in_review_thread";
+    }
+    throw new Error(`deliver send only supports canonical GitHub text surfaces; use deliver invoke for ${surface}`);
+}
+function deliveryBodySchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["body"],
+        properties: {
+            body: { type: "string", minLength: 1 },
+        },
+    };
+}
+function emptyObjectSchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+    };
+}
+function requireDeliveryBody(input, operation) {
+    const body = asString(input.body);
+    if (!body || body.trim().length === 0) {
+        throw new Error(`${operation} requires input.body`);
+    }
+    return body;
+}
+function asMergeMethod(value) {
+    return value === "merge" || value === "squash" || value === "rebase" ? value : undefined;
+}
 function asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return {};

package/dist/src/sources/remote.js

@@ -65,7 +65,7 @@ class RemoteSourceRuntime {
     constructor(store, appendSourceEvent, options) {
         this.store = store;
         this.appendSourceEvent = appendSourceEvent;
-        this.moduleRegistry = options?.moduleRegistry ?? options?.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+        this.moduleRegistry = options?.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
         this.client = options?.client ?? new RpcUxcRemoteSourceClient();
         this.homeDir = options?.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     }
@@ -185,11 +185,12 @@ class RemoteSourceRuntime {
         if (typeof module.expandSubscriptionShortcut !== "function") {
             return null;
         }
-        return module.expandSubscriptionShortcut({
+        const expanded = module.expandSubscriptionShortcut({
             name: input.name,
             args: input.args,
             source: moduleInputSource(source),
         });
+        return normalizeExpandedSubscriptionPlan(expanded);
     }
     async deriveInlinePreview(source, item) {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
@@ -201,6 +202,26 @@ class RemoteSourceRuntime {
         }
         return module.deriveInlinePreview(item, moduleInputSource(source));
     }
+    async deriveNotificationGrouping(source, item) {
+        if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
+            return null;
+        }
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.deriveNotificationGrouping !== "function") {
+            return null;
+        }
+        return module.deriveNotificationGrouping(item, moduleInputSource(source));
+    }
+    async summarizeDigestThread(source, items, grouping) {
+        if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
+            return null;
+        }
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.summarizeDigestThread !== "function") {
+            return null;
+        }
+        return module.summarizeDigestThread(items, moduleInputSource(source), grouping);
+    }
     async syncAll() {
         const sources = this.store
             .listSources()
@@ -348,6 +369,32 @@ class RemoteSourceRuntime {
     }
 }
 exports.RemoteSourceRuntime = RemoteSourceRuntime;
+function normalizeExpandedSubscriptionPlan(value) {
+    if (!value) {
+        return null;
+    }
+    if (isExpandedSubscriptionPlan(value)) {
+        return {
+            members: value.members.map((member) => ({
+                streamKind: typeof member.streamKind === "string" ? member.streamKind : null,
+                filter: member.filter,
+                trackedResourceRef: member.trackedResourceRef ?? null,
+                cleanupPolicy: member.cleanupPolicy ?? null,
+            })),
+        };
+    }
+    return {
+        members: [{
+                streamKind: null,
+                filter: value.filter,
+                trackedResourceRef: value.trackedResourceRef ?? null,
+                cleanupPolicy: value.cleanupPolicy ?? null,
+            }],
+    };
+}
+function isExpandedSubscriptionPlan(value) {
+    return "members" in value && Array.isArray(value.members);
+}
 function moduleInputSource(source) {
     if (source.sourceType !== "remote_source") {
         return source;
@@ -355,7 +402,7 @@ function moduleInputSource(source) {
     const config = asRecord(source.config);
     return {
         ...source,
-        config: asRecord(config.profileConfig),
+        config: asRecord(config.moduleConfig),
     };
 }
 function defaultManagedBindingForSource(source) {