maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.47.20260922

package/node_modules/@maka/runtime/dist/openai-apply-patch.js

@@ -17,6 +17,11 @@
  * under the License.
  */
 import { openai } from '@ai-sdk/openai';
+import { CODEX_PATCH_DESCRIPTION, CODEX_PATCH_GRAMMAR } from './codex-v4a-patch.js';
+export const codexApplyPatchProviderTool = openai.tools.customTool({
+    description: `${CODEX_PATCH_DESCRIPTION}\nPass raw patch text, not JSON.`,
+    format: { type: 'grammar', syntax: 'lark', definition: CODEX_PATCH_GRAMMAR },
+});
 export const openAiApplyPatchProviderTool = openai.tools.applyPatch({});
 const inputSchema = openAiApplyPatchProviderTool.inputSchema;
 export const openAiApplyPatchInputSchema = typeof inputSchema === 'function' ? inputSchema() : inputSchema;

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -24,6 +24,8 @@ export class PluginExecutorBackend {
     sessionId;
     #cwd;
     #instructions;
+    #model;
+    #thinkingLevel;
     #binding;
     #newId;
     #now;
@@ -33,6 +35,8 @@ export class PluginExecutorBackend {
         this.sessionId = input.sessionId;
         this.#cwd = input.cwd;
         this.#instructions = input.instructions;
+        this.#model = input.model;
+        this.#thinkingLevel = input.thinkingLevel;
         this.#binding = input.binding;
         this.#newId = input.newId ?? randomUUID;
         this.#now = input.now ?? Date.now;
@@ -93,6 +97,8 @@ export class PluginExecutorBackend {
                 conversationKey: this.sessionId,
                 text: input.text,
                 cwd: this.#cwd,
+                ...(this.#model ? { model: this.#model } : {}),
+                reasoningEffort: this.#thinkingLevel ?? null,
                 ...(this.#instructions ? { instructions: this.#instructions } : {}),
                 ...(input.attachments ? { attachments: input.attachments } : {}),
                 ...(input.directoryReferences ? { directoryReferences: input.directoryReferences } : {}),

package/node_modules/@maka/runtime/dist/session-manager.js

@@ -547,14 +547,27 @@ export class SessionManager {
     async recoverInterruptedSessions() {
         return this.recoverInterruptedSessionsWithPolicy({ kind: 'best_effort' });
     }
+    /**
+     * Recover only the Sessions named by an already-held quiescent operation.
+     *
+     * Bundle export uses this after fencing a Session subtree. A persisted open
+     * invocation can survive a Host restart even though no live execution claim
+     * remains; settling that invocation is safe under the fence and lets export
+     * distinguish an interrupted run from a live one without scanning or
+     * mutating unrelated Sessions.
+     */
+    async recoverInterruptedSessionsForSessions(sessionIds) {
+        const scope = new Set(sessionIds);
+        return this.recoverInterruptedSessionsWithPolicy({ kind: 'best_effort' }, scope);
+    }
     async recoverInterruptedSessionsStrict(stores) {
         if (stores.sessionStore !== this.deps.store || stores.agentRunStore !== this.deps.runStore) {
             throw new Error('Strict recovery stores must match the SessionManager composition');
         }
         return this.recoverInterruptedSessionsWithPolicy({ kind: 'strict', stores });
     }
-    async recoverInterruptedSessionsWithPolicy(policy) {
-        const interrupted = (await listSessionsForRecovery(this.deps.store, policy)).filter((session) => !session.isArchived);
+    async recoverInterruptedSessionsWithPolicy(policy, scope) {
+        const interrupted = (await listSessionsForRecovery(this.deps.store, policy)).filter((session) => !session.isArchived && (scope === undefined || scope.has(session.id)));
         const recovered = new Set();
         for (const session of interrupted) {
             if (this.runtimeKernel.hasActiveRuns(session.id))

package/node_modules/@maka/runtime-host/dist/client/capability-provider-service.js

@@ -140,12 +140,14 @@ function snapshotProvider(provider) {
     const call = provider.call?.bind(provider);
     const callService = provider.callService?.bind(provider);
     const close = provider.close?.bind(provider);
+    const currentRegistrationRetired = provider.currentRegistrationRetired?.bind(provider);
     return {
         offers: () => canonical.offers,
         ...(canonical.services === undefined ? {} : { services: () => canonical.services ?? [] }),
         ...(call ? { call } : {}),
         ...(callService ? { callService } : {}),
         ...(close ? { close } : {}),
+        ...(currentRegistrationRetired ? { currentRegistrationRetired } : {}),
     };
 }
 async function closeProvider(provider) {

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

@@ -24,74 +24,82 @@ export class ClientCapabilityChannel {
     #registrations = new Map();
     #invocations = new Map();
     #releasedRegistrationIds = new Set();
-    #currentRegistrationId;
-    #mutationPending = false;
+    #currentRegistrationIds = new Map();
+    #pendingMutations = new Set();
     #closedError;
     constructor(options) {
         this.#options = options;
     }
-    async replace(provider, timeoutMs) {
+    async replace(provider, timeoutMs, sessionId) {
         this.#assertOpen();
-        if (this.#mutationPending) {
+        if (this.#pendingMutations.has(sessionId)) {
             throw new Error('A Client Capability registration mutation is already pending');
         }
-        this.#mutationPending = true;
+        this.#pendingMutations.add(sessionId);
         const registrationId = randomUUID();
         let registration;
         try {
             const services = provider.services?.() ?? [];
             const canonical = decodeClientCapabilityReplaceInput({
                 registrationId,
+                ...(sessionId === undefined ? {} : { sessionId }),
                 offers: provider.offers(),
                 ...(services.length === 0 ? {} : { services }),
             });
             registration = {
                 registrationId,
+                ...(canonical.sessionId === undefined ? {} : { sessionId: canonical.sessionId }),
                 provider,
                 offers: canonical.offers,
                 services: canonical.services ?? [],
             };
             this.#registrations.set(registrationId, registration);
             const result = await this.#options.replace(canonical, timeoutMs);
+            this.#assertOpen();
             if (result.registrationId !== registrationId) {
                 throw new Error('Runtime Host replaced a different Client Capability registration');
             }
-            this.#currentRegistrationId = registrationId;
+            this.#currentRegistrationIds.set(sessionId, registrationId);
             this.#collectReleasedRegistrations();
             return result;
         }
         catch (error) {
-            if (registration && this.#currentRegistrationId !== registrationId) {
+            if (registration && this.#currentRegistrationIds.get(sessionId) !== registrationId) {
                 this.#registrations.delete(registrationId);
             }
             throw error;
         }
         finally {
-            this.#mutationPending = false;
+            this.#pendingMutations.delete(sessionId);
+            this.#settleReleasedCurrentRegistration(sessionId);
+            this.#collectReleasedRegistrations();
         }
     }
-    async unregister(timeoutMs) {
+    async unregister(timeoutMs, sessionId) {
         this.#assertOpen();
-        if (this.#mutationPending) {
+        if (this.#pendingMutations.has(sessionId)) {
             throw new Error('A Client Capability registration mutation is already pending');
         }
-        const registrationId = this.#currentRegistrationId;
+        const registrationId = this.#currentRegistrationIds.get(sessionId);
         if (!registrationId)
             throw new Error('No Client Capability registration is active');
-        this.#mutationPending = true;
+        this.#pendingMutations.add(sessionId);
         try {
             const result = await this.#options.unregister({ registrationId }, timeoutMs);
+            this.#assertOpen();
             if (result.registrationId !== registrationId) {
                 throw new Error('Runtime Host unregistered a different Client Capability registration');
             }
-            if (this.#currentRegistrationId === registrationId) {
-                this.#currentRegistrationId = undefined;
+            if (this.#currentRegistrationIds.get(sessionId) === registrationId) {
+                this.#currentRegistrationIds.delete(sessionId);
             }
             this.#collectReleasedRegistrations();
             return result;
         }
         finally {
-            this.#mutationPending = false;
+            this.#pendingMutations.delete(sessionId);
+            this.#settleReleasedCurrentRegistration(sessionId);
+            this.#collectReleasedRegistrations();
         }
     }
     accept(frame) {
@@ -124,10 +132,17 @@ export class ClientCapabilityChannel {
                 this.#invocations.delete(frame.invocationId);
                 return;
             }
-            case 'client.capability.registration_release':
+            case 'client.capability.registration_release': {
+                const registration = this.#registrations.get(frame.registrationId);
                 this.#releasedRegistrationIds.add(frame.registrationId);
+                // A successful replacement can enqueue the old release before its response. Defer
+                // current-slot retirement until the in-flight mutation establishes which ID won.
+                if (registration && !this.#pendingMutations.has(registration.sessionId)) {
+                    this.#settleReleasedCurrentRegistration(registration.sessionId);
+                }
                 this.#collectReleasedRegistrations();
                 return;
+            }
             case 'client.capability.admitted': {
                 const invocation = this.#invocations.get(frame.invocationId);
                 if (!invocation?.admission || !invocation.admission.resolve()) {
@@ -161,7 +176,7 @@ export class ClientCapabilityChannel {
         const providers = new Set([...this.#registrations.values()].map((registration) => registration.provider));
         this.#registrations.clear();
         this.#releasedRegistrationIds.clear();
-        this.#currentRegistrationId = undefined;
+        this.#currentRegistrationIds.clear();
         for (const provider of providers)
             this.#closeProvider(provider);
     }
@@ -172,7 +187,11 @@ export class ClientCapabilityChannel {
         const registration = this.#registrations.get(frame.registrationId);
         const offer = registration?.offers.find((candidate) => candidate.offerId === frame.offerId);
         const offered = offer?.tools.some((tool) => tool.serverId === frame.serverId && tool.name === frame.toolName);
-        if (!registration || !offer || !offered || !registration.provider.call) {
+        if (!registration ||
+            (registration.sessionId !== undefined && registration.sessionId !== frame.sessionId) ||
+            !offer ||
+            !offered ||
+            !registration.provider.call) {
             void this.#options
                 .write({
                 kind: 'client.capability.rejected',
@@ -403,10 +422,12 @@ export class ClientCapabilityChannel {
     }
     #collectReleasedRegistrations() {
         for (const registrationId of this.#releasedRegistrationIds) {
-            if (registrationId === this.#currentRegistrationId)
+            if ([...this.#currentRegistrationIds.values()].includes(registrationId))
                 continue;
-            this.#releasedRegistrationIds.delete(registrationId);
             const registration = this.#registrations.get(registrationId);
+            if (registration && this.#pendingMutations.has(registration.sessionId))
+                continue;
+            this.#releasedRegistrationIds.delete(registrationId);
             if (!registration)
                 continue;
             this.#registrations.delete(registrationId);
@@ -415,6 +436,16 @@ export class ClientCapabilityChannel {
             }
         }
     }
+    #settleReleasedCurrentRegistration(sessionId) {
+        const registrationId = this.#currentRegistrationIds.get(sessionId);
+        if (!registrationId || !this.#releasedRegistrationIds.has(registrationId))
+            return;
+        const registration = this.#registrations.get(registrationId);
+        this.#currentRegistrationIds.delete(sessionId);
+        this.#collectReleasedRegistrations();
+        if (registration)
+            this.#notifyCurrentRegistrationRetired(registration.provider);
+    }
     #closeProvider(provider) {
         try {
             void Promise.resolve(provider.close?.()).catch((error) => this.#options.onFailure(asError(error)));
@@ -423,6 +454,14 @@ export class ClientCapabilityChannel {
             this.#options.onFailure(asError(error));
         }
     }
+    #notifyCurrentRegistrationRetired(provider) {
+        try {
+            void Promise.resolve(provider.currentRegistrationRetired?.()).catch((error) => this.#options.onFailure(asError(error)));
+        }
+        catch (error) {
+            this.#options.onFailure(asError(error));
+        }
+    }
     #assertOpen() {
         if (this.#closedError)
             throw this.#closedError;

package/node_modules/@maka/runtime-host/dist/client/connection.js

@@ -299,11 +299,13 @@ class RuntimeHostConnectionImpl {
         this.#fail(new RuntimeHostTransportError('closed', 'Runtime Host connection closed by Client'), true);
         await this.closed;
     }
-    async replaceClientCapabilities(provider, timeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS) {
-        return this.#clientCapabilities.replace(provider, timeoutMs);
+    async replaceClientCapabilities(provider, options) {
+        const { timeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS, sessionId } = typeof options === 'number' ? { timeoutMs: options } : (options ?? {});
+        return this.#clientCapabilities.replace(provider, timeoutMs, sessionId);
     }
-    async unregisterClientCapabilities(timeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS) {
-        return this.#clientCapabilities.unregister(timeoutMs);
+    async unregisterClientCapabilities(options) {
+        const { timeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS, sessionId } = typeof options === 'number' ? { timeoutMs: options } : (options ?? {});
+        return this.#clientCapabilities.unregister(timeoutMs, sessionId);
     }
     subscribeConfigurationChanges(listener) {
         this.#configurationChangeListeners.add(listener);

package/node_modules/@maka/runtime-host/dist/client/reconnecting-connection.js

@@ -142,13 +142,13 @@ class RuntimeHostReconnectingConnectionImpl {
     openSessionSubscriptionOnce(input, timeoutMs) {
         return this.#requireCurrent('subscription.open').openSessionSubscription(input, timeoutMs);
     }
-    async replaceClientCapabilities(provider, timeoutMs) {
+    async replaceClientCapabilities(provider, options) {
         const connection = this.#requireCurrent('client.capability.replace');
-        return connection.replaceClientCapabilities(provider, timeoutMs);
+        return connection.replaceClientCapabilities(provider, options);
     }
-    async unregisterClientCapabilities(timeoutMs) {
+    async unregisterClientCapabilities(options) {
         const connection = this.#requireCurrent('client.capability.unregister');
-        return connection.unregisterClientCapabilities(timeoutMs);
+        return connection.unregisterClientCapabilities(options);
     }
     subscribeConfigurationChanges(listener) {
         this.#configurationListeners.add(listener);

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

@@ -59,7 +59,7 @@ export const CLIENT_CAPABILITY_OPERATION_SPECS = {
 };
 export function decodeClientCapabilityReplaceInput(value) {
     const record = requireRecord(value, 'Client Capability replacement');
-    assertOptionalExactKeys(record, 'Client Capability replacement', ['registrationId', 'offers'], ['services']);
+    assertOptionalExactKeys(record, 'Client Capability replacement', ['registrationId', 'offers'], ['services', 'sessionId']);
     if (!Array.isArray(record.offers) || record.offers.length > CLIENT_CAPABILITY_MAX_OFFERS) {
         throw invalidProtocolFrame('Invalid Client Capability offers');
     }
@@ -67,11 +67,23 @@ export function decodeClientCapabilityReplaceInput(value) {
     if (!Array.isArray(serviceValues) || serviceValues.length > CLIENT_CAPABILITY_MAX_SERVICES) {
         throw invalidProtocolFrame('Invalid Client Capability services');
     }
-    if (record.offers.length === 0 && serviceValues.length === 0) {
+    // An empty Session snapshot clears lost contracts after reconnect and keeps
+    // a bounded registration through which the Host can signal Session retirement.
+    // Connection-wide publications still use unregister for withdrawal.
+    if (record.offers.length === 0 && serviceValues.length === 0 && record.sessionId === undefined) {
         throw invalidProtocolFrame('Client Capability registration is empty');
     }
     const offers = record.offers.map((offer) => decodeClientCapabilityOffer(offer));
     const services = serviceValues.map((service) => decodeClientCapabilityServiceOffer(service));
+    const sessionId = record.sessionId === undefined ? undefined : requireEntityId(record.sessionId, 'sessionId');
+    if (sessionId !== undefined &&
+        (services.length > 0 ||
+            offers.some((offer) => offer.affinity !== 'session' || offer.hostPathAccess !== 'none'))) {
+        throw invalidProtocolFrame('Session capabilities must be path-independent session tools');
+    }
+    if (offers.some((offer) => offer.admission === 'mcp') && sessionId === undefined) {
+        throw invalidProtocolFrame('MCP admission requires a target Session');
+    }
     const offerIds = new Set();
     const serviceContracts = new Set();
     const toolIdentities = new Set();
@@ -102,6 +114,7 @@ export function decodeClientCapabilityReplaceInput(value) {
     }
     const decoded = {
         registrationId: requireEntityId(record.registrationId, 'registrationId'),
+        ...(sessionId === undefined ? {} : { sessionId }),
         offers,
         ...(record.services === undefined ? {} : { services }),
     };
@@ -427,17 +440,21 @@ function decodeClientCapabilityFormResult(value) {
 }
 function decodeClientCapabilityOffer(value) {
     const record = requireRecord(value, 'Client Capability offer');
-    assertOptionalExactKeys(record, 'Client Capability offer', ['offerId', 'version', 'affinity', 'hostPathAccess', 'label', 'tools'], ['description']);
+    assertOptionalExactKeys(record, 'Client Capability offer', ['offerId', 'version', 'affinity', 'hostPathAccess', 'label', 'tools'], ['description', 'admission']);
     if (!Array.isArray(record.tools) ||
         record.tools.length === 0 ||
         record.tools.length > CLIENT_CAPABILITY_MAX_TOOLS_PER_OFFER) {
         throw invalidProtocolFrame('Invalid Client Capability offer tools');
     }
+    if (record.admission !== undefined && record.admission !== 'mcp') {
+        throw invalidProtocolFrame('Invalid Client Capability admission');
+    }
     return {
         offerId: requireEntityId(record.offerId, 'offerId'),
         version: requireString(record.version, 'version', 64),
         affinity: decodeClientCapabilityAffinity(record.affinity),
         hostPathAccess: decodeClientCapabilityHostPathAccess(record.hostPathAccess),
+        ...(record.admission === 'mcp' ? { admission: 'mcp' } : {}),
         label: requireString(record.label, 'label', 128),
         ...(record.description === undefined
             ? {}

package/node_modules/@maka/runtime-host/dist/protocol/external-session.js

@@ -120,15 +120,18 @@ export function decodeExternalSessionCatalogQueryResult(value) {
     return decoded;
 }
 export function decodeExternalSessionImportInput(value) {
-    const input = requireExactRecord(value, 'external Session import input', [
-        'adapterId',
-        'sourceSessionId',
-    ]);
+    const input = requireShapedRecord(value, 'external Session import input', ['adapterId', 'sourceSessionId'], ['workspace']);
     const sourceSessionId = requireUtf8String(input.sourceSessionId, 'external source Session id', EXTERNAL_SESSION_SOURCE_SESSION_ID_MAX_BYTES);
     if (/[\u0000-\u001f\u007f]/.test(sourceSessionId)) {
         throw invalidProtocolFrame('Invalid external source Session id');
     }
-    return { adapterId: adapterId(input.adapterId), sourceSessionId };
+    return {
+        adapterId: adapterId(input.adapterId),
+        sourceSessionId,
+        ...(Object.hasOwn(input, 'workspace')
+            ? { workspace: decodeWorkspaceTarget(input.workspace) }
+            : {}),
+    };
 }
 export function decodeExternalSessionImportResult(value) {
     const result = requireRecord(value, 'external Session import result');

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

@@ -62,7 +62,17 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 172;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 177;
+// 177: External Session import input may carry an optional Host-resolved
+// workspace target. Epoch-176 peers reject the unknown `workspace` key.
+// 176: Session-scoped capability publication and MCP admission require compatible
+// Client and Host builds; older peers do not enforce their isolation contract.
+// 175: WorkHub coordinator model configuration again accepts only native
+// explicit targets. Epoch-174 peers may send an executor target it must reject.
+// 174: WorkHub new-Work defaults may select an executor-specific model and
+// thinking level. Epoch-173 peers reject these fields on strict action shapes.
+// 173: Plugin executor Sessions may select an executor-specific model at
+// creation and configuration time, and propagate its reasoning effort.
 // 172: Usage screen requests and results accept fractional timestamps in the
 // persisted domain. Older peers reject these otherwise valid wire values.
 // 171: Removed the `connection.usage.read` operation along with the Command

package/node_modules/@maka/runtime-host/dist/protocol/session-catalog.js

@@ -20,7 +20,7 @@ import { isCollaborationMode } from '@maka/core/collaboration';
 import { isOrchestrationMode } from '@maka/core/orchestration';
 import { isPermissionMode } from '@maka/core/permission';
 import { isSessionStartMode } from '@maka/core/session-start-mode';
-import { isSessionBlockedReason, isSessionToolProfile, } from '@maka/core/session';
+import { isSessionBlockedReason, isSessionToolProfile, SESSION_MODEL_ID_MAX_BYTES, } from '@maka/core/session';
 import { isThinkingLevel } from '@maka/core/model-thinking';
 import { isExecutorId } from '@maka/core/executor-id';
 import { assertAllowedKeys, requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireRecord, requireShapedRecord, requireUtf8String, } from './codec.js';
@@ -36,7 +36,7 @@ export const SESSION_CATALOG_NAME_MAX_BYTES = 320;
 export const SESSION_CATALOG_LABEL_MAX_ITEMS = 32;
 export const SESSION_CATALOG_LABEL_MAX_BYTES = 128;
 export const SESSION_CATALOG_PREVIEW_MAX_BYTES = 4 * 1024;
-export const SESSION_CATALOG_MODEL_MAX_BYTES = 512;
+export const SESSION_CATALOG_MODEL_MAX_BYTES = SESSION_MODEL_ID_MAX_BYTES;
 export const SESSION_CATALOG_CONNECTION_SLUG_MAX_BYTES = 256;
 export const SESSION_CATALOG_LIVE_RUN_STATE_SCHEMA_VERSION = 1;
 export const SESSION_CATALOG_RUNNING_TURN_MAX_ITEMS = 64;
@@ -251,6 +251,7 @@ export function decodeSessionCreateInput(value) {
         'labels',
         'modelTarget',
         'executorId',
+        'executorModel',
         'thinkingLevel',
         'toolProfile',
         'permissionMode',
@@ -261,9 +262,15 @@ export function decodeSessionCreateInput(value) {
         ? executorIdValue(input.executorId)
         : undefined;
     const target = Object.hasOwn(input, 'modelTarget') ? modelTarget(input.modelTarget) : undefined;
+    const executorModel = Object.hasOwn(input, 'executorModel')
+        ? requireUtf8String(input.executorModel, 'Executor model', SESSION_CATALOG_MODEL_MAX_BYTES)
+        : undefined;
     if ((executorId === undefined) === (target === undefined)) {
         throw invalidProtocolFrame('Session creation requires exactly one model target or executor id');
     }
+    if (executorModel !== undefined && executorId === undefined) {
+        throw invalidProtocolFrame('Executor model requires an executor id');
+    }
     return {
         sessionId: requireEntityId(input.sessionId, 'sessionId'),
         workspace: decodeWorkspaceTarget(input.workspace),
@@ -272,6 +279,7 @@ export function decodeSessionCreateInput(value) {
         ...(Object.hasOwn(input, 'labels') ? { labels: labels(input.labels) } : {}),
         ...(target ? { modelTarget: target } : {}),
         ...(executorId ? { executorId } : {}),
+        ...(executorModel ? { executorModel } : {}),
         ...(Object.hasOwn(input, 'thinkingLevel')
             ? { thinkingLevel: input.thinkingLevel === null ? null : thinkingLevel(input.thinkingLevel) }
             : {}),
@@ -327,10 +335,20 @@ export function decodeSessionConfigurationUpdateInput(value) {
         'expectedRevision',
         'patch',
     ]);
-    const patch = requireShapedRecord(input.patch, 'Session configuration patch', [], ['modelTarget', 'thinkingLevel', 'permissionMode', 'collaborationMode', 'orchestrationMode']);
+    const patch = requireShapedRecord(input.patch, 'Session configuration patch', [], [
+        'modelTarget',
+        'executorTarget',
+        'thinkingLevel',
+        'permissionMode',
+        'collaborationMode',
+        'orchestrationMode',
+    ]);
     if (Object.keys(patch).length === 0) {
         throw invalidProtocolFrame('Session configuration patch is empty');
     }
+    if (Object.hasOwn(patch, 'modelTarget') && Object.hasOwn(patch, 'executorTarget')) {
+        throw invalidProtocolFrame('Session configuration cannot select two execution targets');
+    }
     return {
         sessionId: requireEntityId(input.sessionId, 'sessionId'),
         expectedRevision: positiveRevision(input.expectedRevision, 'expected Session revision'),
@@ -338,6 +356,9 @@ export function decodeSessionConfigurationUpdateInput(value) {
             ...(Object.hasOwn(patch, 'modelTarget')
                 ? { modelTarget: explicitModelTarget(patch.modelTarget) }
                 : {}),
+            ...(Object.hasOwn(patch, 'executorTarget')
+                ? { executorTarget: executorTarget(patch.executorTarget) }
+                : {}),
             ...(Object.hasOwn(patch, 'thinkingLevel')
                 ? {
                     thinkingLevel: patch.thinkingLevel === null ? null : thinkingLevel(patch.thinkingLevel),
@@ -659,6 +680,17 @@ function executorIdValue(value) {
     }
     return id;
 }
+function executorTarget(value) {
+    const exact = requireShapedRecord(value, 'Session executor target', ['executorId'], ['model']);
+    return {
+        executorId: executorIdValue(exact.executorId),
+        ...(Object.hasOwn(exact, 'model')
+            ? {
+                model: requireUtf8String(exact.model, 'Executor model', SESSION_CATALOG_MODEL_MAX_BYTES),
+            }
+            : {}),
+    };
+}
 function optionalExecutorId(record) {
     if (record.executorId === undefined)
         return {};

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

@@ -25,11 +25,7 @@ import { defineOperation } from './operation-spec.js';
 import { decodeWorkspaceProjection, decodeWorkspaceTarget, } from './workspace.js';
 import { decodeSessionConfigurationUpdateInput, decodeSessionUpdateResult, decodeSessionCatalogItem, SESSION_CATALOG_OPERATION_SPECS, } from './session-catalog.js';
 export function decodeWorkHubCoordinationConfigureModelInput(value) {
-    const input = requireExactRecord(value, 'WorkHub model configuration', [
-        'expectedRevision',
-        'modelTarget',
-        'thinkingLevel',
-    ]);
+    const input = requireShapedRecord(value, 'WorkHub model configuration', ['expectedRevision', 'modelTarget', 'thinkingLevel'], []);
     const decoded = decodeSessionConfigurationUpdateInput({
         sessionId: WORKHUB_COORDINATION_SESSION_ID,
         expectedRevision: input.expectedRevision,