maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.27.20260910

package/node_modules/@maka/runtime-host/dist/protocol/plugin-platform.js

@@ -108,7 +108,7 @@ export const PLUGIN_PLATFORM_OPERATION_SPECS = {
 };
 function decodePluginPlatformQueryInput(value) {
     const input = requireShapedRecord(value, 'Plugin Platform query input', ['view'], ['rootId', 'cursor', 'limit']);
-    if (!['status', 'packages', 'entries', 'tools', 'failures'].includes(input.view)) {
+    if (!['status', 'packages', 'entries', 'tools', 'commands', 'failures'].includes(input.view)) {
         throw invalidProtocolFrame('Invalid Plugin Platform query view');
     }
     const view = input.view;
@@ -125,8 +125,8 @@ function decodePluginPlatformQueryInput(value) {
         (input.rootId !== undefined || cursor !== undefined || limit !== undefined)) {
         throw invalidProtocolFrame('Plugin Platform status query does not accept paging');
     }
-    if (input.rootId !== undefined && view !== 'entries' && view !== 'tools') {
-        throw invalidProtocolFrame('Plugin root identity is only valid for Entry and Tool queries');
+    if (input.rootId !== undefined && view !== 'entries' && view !== 'tools' && view !== 'commands') {
+        throw invalidProtocolFrame('Plugin root identity is only valid for Entry, Tool, and Command queries');
     }
     let rootId;
     if (input.rootId !== undefined) {
@@ -190,7 +190,7 @@ function decodePluginPlatformQueryResult(value) {
         ]);
         if (!Array.isArray(output.items) ||
             output.items.length > 64 ||
-            !['packages', 'entries', 'tools', 'failures'].includes(view)) {
+            !['packages', 'entries', 'tools', 'commands', 'failures'].includes(view)) {
             throw invalidProtocolFrame('Invalid Plugin Platform page');
         }
         const nextCursor = output.nextCursor === null
@@ -203,11 +203,36 @@ function decodePluginPlatformQueryResult(value) {
                     ? { view, items: decodeInspections(output.items), nextCursor }
                     : view === 'tools'
                         ? { view, items: output.items.map(decodeToolInspection), nextCursor }
-                        : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
+                        : view === 'commands'
+                            ? { view, items: output.items.map(decodeCommandInspection), nextCursor }
+                            : { view: 'failures', items: output.items.map(decodePlatformFailure), nextCursor };
     }
     requireEncodedByteLimit(decoded, 'Plugin Platform query result', PLUGIN_PLATFORM_QUERY_RESULT_MAX_BYTES);
     return decoded;
 }
+function decodeCommandInspection(value) {
+    const item = requireExactRecord(value, 'Plugin Command inspection', [
+        'entryId',
+        'scopeId',
+        'extensionId',
+        'generation',
+        'name',
+        'description',
+        'aliases',
+    ]);
+    if (!Array.isArray(item.aliases) || item.aliases.length > 64) {
+        throw invalidProtocolFrame('Invalid Plugin Command aliases');
+    }
+    return {
+        entryId: requireId(item.entryId, 'Plugin Entry identity'),
+        scopeId: requireString(item.scopeId, 'Plugin scope identity', 256),
+        extensionId: requireId(item.extensionId, 'Plugin package identity'),
+        generation: requireCount(item.generation, 'Plugin generation'),
+        name: requireString(item.name, 'Plugin Command name', 128),
+        description: requireString(item.description, 'Plugin Command description', 4096),
+        aliases: item.aliases.map((alias) => requireString(alias, 'Plugin Command alias', 128)),
+    };
+}
 function decodePlatformFailure(value) {
     const failure = requireShapedRecord(value, 'Plugin Platform failure', ['diagnostic'], ['entryId', 'extensionId']);
     if (failure.entryId === undefined && failure.extensionId === undefined) {

package/node_modules/@maka/runtime-host/dist/protocol/workhub-coordination.js

@@ -182,8 +182,10 @@ function decodeWorkHubCoordinationActionFields(input) {
     const proposal = decodeWorkHubCoordinationProposal(input.proposal);
     if (input.newWorkDefaults !== undefined &&
         (!isWorkHubCreateDefaults(input.newWorkDefaults) ||
-            !(proposal.disposition === 'create_new' ||
-                (proposal.disposition === 'replace' && proposal.target.disposition === 'create_new')))) {
+            !(('disposition' in proposal && proposal.disposition === 'create_new') ||
+                ('operation' in proposal &&
+                    proposal.operation === 'correct' &&
+                    proposal.target.disposition === 'create_new')))) {
         throw invalidProtocolFrame('Invalid WorkHub creation defaults');
     }
     const delegationText = input.delegationText === undefined
@@ -191,9 +193,7 @@ function decodeWorkHubCoordinationActionFields(input) {
         : requireUtf8String(input.delegationText, 'WorkHub delegation text', WORKHUB_COORDINATION_TEXT_MAX_BYTES);
     if (delegationText !== undefined &&
         (!delegationText.trim() ||
-            (proposal.disposition !== 'delegate_existing' &&
-                proposal.disposition !== 'create_new' &&
-                proposal.disposition !== 'replace'))) {
+            !('disposition' in proposal || ('operation' in proposal && proposal.operation === 'correct')))) {
         throw invalidProtocolFrame('Invalid WorkHub delegation text');
     }
     const base = {
@@ -204,19 +204,19 @@ function decodeWorkHubCoordinationActionFields(input) {
             : {}),
         ...(delegationText === undefined ? {} : { delegationText }),
     };
-    if (proposal.disposition === 'delegate_existing') {
+    if ('disposition' in proposal && proposal.disposition === 'delegate_existing') {
         if (input.create !== undefined || input.candidateSetId === undefined) {
             throw invalidProtocolFrame('Invalid WorkHub delegation context');
         }
         return { ...base, candidateSetId: candidateSetId(input.candidateSetId) };
     }
-    if (proposal.disposition === 'create_new') {
+    if ('disposition' in proposal && proposal.disposition === 'create_new') {
         if (input.candidateSetId !== undefined || input.create === undefined) {
             throw invalidProtocolFrame('Invalid WorkHub creation context');
         }
         return { ...base, create: decodeWorkHubCoordinationCreateContext(input.create) };
     }
-    if (proposal.disposition === 'replace') {
+    if ('operation' in proposal && proposal.operation === 'correct') {
         if (proposal.target.disposition === 'delegate_existing') {
             if (input.candidateSetId === undefined || input.create !== undefined) {
                 throw invalidProtocolFrame('Invalid WorkHub replacement context');
@@ -285,9 +285,9 @@ function decodeWorkHubCoordinationProposal(value) {
             title: requireUtf8String(exact.title, 'WorkHub Session title', COORDINATION_TITLE_MAX_BYTES),
         };
     }
-    if (proposal.disposition === 'replace') {
+    if (proposal.operation === 'correct') {
         const exact = requireExactRecord(proposal, 'WorkHub replacement proposal', [
-            'disposition',
+            'operation',
             'replacesActionId',
             'target',
         ]);
@@ -298,7 +298,7 @@ function decodeWorkHubCoordinationProposal(value) {
                 'candidateRef',
             ]);
             return {
-                disposition: 'replace',
+                operation: 'correct',
                 replacesActionId: requireEntityId(exact.replacesActionId, 'WorkHub replaced action id'),
                 target: {
                     disposition: 'delegate_existing',
@@ -312,7 +312,7 @@ function decodeWorkHubCoordinationProposal(value) {
                 'title',
             ]);
             return {
-                disposition: 'replace',
+                operation: 'correct',
                 replacesActionId: requireEntityId(exact.replacesActionId, 'WorkHub replaced action id'),
                 target: {
                     disposition: 'create_new',
@@ -322,29 +322,31 @@ function decodeWorkHubCoordinationProposal(value) {
         }
         throw invalidProtocolFrame('Invalid WorkHub replacement target');
     }
-    if (proposal.disposition === 'stop_work') {
-        const exact = requireExactRecord(proposal, 'WorkHub stop proposal', ['disposition', 'expects']);
+    if (proposal.operation === 'stop') {
+        const exact = requireExactRecord(proposal, 'WorkHub stop proposal', ['operation', 'expects']);
         return {
-            disposition: 'stop_work',
-            expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
+            operation: 'stop',
+            expects: decodeWorkHubCoordinationLinkedTargetPreconditions(exact.expects),
         };
     }
-    if (proposal.disposition === 'resume_work') {
+    if (proposal.operation === 'resume') {
         const exact = requireExactRecord(proposal, 'WorkHub resume proposal', [
-            'disposition',
+            'operation',
             'expects',
             'resumesActionId',
         ]);
         return {
-            disposition: 'resume_work',
+            operation: 'resume',
             resumesActionId: requireEntityId(exact.resumesActionId, 'WorkHub resume assignment'),
-            expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
+            expects: decodeWorkHubCoordinationLinkedTargetPreconditions(exact.expects),
         };
     }
-    throw invalidProtocolFrame('Invalid WorkHub Coordination proposal disposition');
+    throw invalidProtocolFrame('Invalid WorkHub Coordination proposal');
 }
-function decodeWorkHubCoordinationStopPreconditions(value) {
-    const expects = requireExactRecord(value, 'WorkHub stop preconditions', ['targetSessionId']);
+function decodeWorkHubCoordinationLinkedTargetPreconditions(value) {
+    const expects = requireExactRecord(value, 'WorkHub linked-target preconditions', [
+        'targetSessionId',
+    ]);
     return {
         targetSessionId: requireEntityId(expects.targetSessionId, 'WorkHub target Session id'),
     };

package/node_modules/@maka/runtime-host/dist/server/client-capability-coordinator.js

@@ -101,8 +101,8 @@ export class HostClientCapabilityCoordinator {
             },
         };
     }
-    async bindSession(sessionId, initiatingConnectionId) {
-        return this.#bindSession(sessionId, initiatingConnectionId, 'strict');
+    async bindSession(sessionId, initiatingConnectionId, requiredToolNames) {
+        return this.#bindSession(sessionId, initiatingConnectionId, 'strict', requiredToolNames);
     }
     async bindSessionSuccessor(sessionId) {
         const result = await this.#bindSession(sessionId, '', 'degrade');
@@ -129,17 +129,61 @@ export class HostClientCapabilityCoordinator {
                 this.#onModelToolsChanged();
         });
     }
-    async #bindSession(sessionId, initiatingConnectionId, mode) {
+    async #bindSession(sessionId, initiatingConnectionId, mode, requiredToolNames) {
         return this.#activation.runMutation(async () => {
             const selection = this.#selectSessionState(sessionId, initiatingConnectionId, mode);
             if (!selection.ok)
                 return selection;
+            const capabilityBinding = requiredToolNames
+                ? this.#toolProviderBinding(selection.state, requiredToolNames)
+                : undefined;
+            if (requiredToolNames && !capabilityBinding) {
+                return {
+                    ok: false,
+                    message: 'Required Client Capability tools do not have one available provider',
+                };
+            }
             this.#storeSessionState(sessionId, selection.state);
             if (selection.modelToolsChanged)
                 this.#onModelToolsChanged();
-            return { ok: true };
+            return { ok: true, ...(capabilityBinding ? { capabilityBinding } : {}) };
+        });
+    }
+    async bindRecoveredSession(sessionId, binding, toolNames) {
+        return this.#activation.runMutation(() => {
+            const provider = [...this.#providers.values()].find((candidate) => providerAuthorityDigest(candidate) === binding && this.#activeConnection(candidate));
+            if (!provider)
+                return false;
+            const connection = this.#activeConnection(provider);
+            const selection = this.#selectSessionState(sessionId, connection.connectionId, 'strict');
+            if (!selection.ok || this.#toolProviderBinding(selection.state, toolNames) !== binding)
+                return false;
+            this.#storeSessionState(sessionId, selection.state);
+            if (selection.modelToolsChanged)
+                this.#onModelToolsChanged();
+            return true;
         });
     }
+    #toolProviderBinding(state, toolNames) {
+        const missing = new Set(toolNames);
+        let selected;
+        for (const [contractId, binding] of state?.sessionBindings ?? []) {
+            if (binding.kind !== 'bound')
+                continue;
+            const provider = this.#providers.get(binding.providerId);
+            const offer = provider?.current?.offersByContract.get(contractId);
+            if (!provider || !this.#activeConnection(provider) || !offer)
+                continue;
+            for (const tool of offer.offer.tools) {
+                if (!missing.delete(mcpProxyToolName(tool.serverId, tool.name)))
+                    continue;
+                if (selected && selected !== provider)
+                    return undefined;
+                selected = provider;
+            }
+        }
+        return selected && missing.size === 0 ? providerAuthorityDigest(selected) : undefined;
+    }
     async runWithSessionBindingPreview(sessionId, initiatingConnectionId, operation) {
         return this.#activation.runReadActivation(async () => {
             const registryRevision = this.#revision;
@@ -1274,3 +1318,17 @@ function sessionCapabilityStatesEqual(left, right) {
 function asError(value) {
     return value instanceof Error ? value : new Error(String(value));
 }
+/** Registration IDs and connections rotate; authenticated provider authority must not. */
+function providerAuthorityDigest(provider) {
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify([
+        'maka.client-capability-authority.v1',
+        provider.principalKind,
+        provider.principalId,
+        provider.clientInstanceId,
+        provider.credentialBoundClientInstanceId ?? null,
+        provider.capabilityOwner?.principalId ?? null,
+        provider.capabilityOwner?.clientInstanceId ?? null,
+    ]))
+        .digest('hex')}`;
+}