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

package/node_modules/@maka/core/dist/runtime-event.js

@@ -31,6 +31,7 @@
  * Phase 1 scope: types + small pure helpers only. No storage, runner,
  * projection, or ledger logic lives here. Those arrive in later nodes.
  */
+import { isWorkHubActionReceipt } from './workhub-action-result.js';
 import { isModelRetryDecision } from './model-failure.js';
 import { isRuntimeHandoffPause, runtimeHandoffPause, } from './runtime-handoff.js';
 import { isMessageContent, normalizeMessageContent, } from './events.js';
@@ -229,6 +230,7 @@ const INVOCATION_ROOT_SHAPES = {
 };
 const RUNTIME_ACTIONS_SHAPE = defineObjectShape()([], [
     'handoffPause',
+    'coordination',
     'stateDelta',
     'artifactDelta',
     'permissionRequest',
@@ -583,6 +585,7 @@ function isRuntimeEventActions(value) {
         return false;
     }
     return ((value.handoffPause === undefined || isRuntimeHandoffPause(value.handoffPause)) &&
+        (value.coordination === undefined || isWorkHubActionReceipt(value.coordination)) &&
         (value.stateDelta === undefined || isRecord(value.stateDelta)) &&
         (value.artifactDelta === undefined ||
             (isRecord(value.artifactDelta) &&

package/node_modules/@maka/core/dist/session.js

@@ -16,9 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isWorkHubActionReceipt } from './workhub-action-result.js';
 import { MODEL_FAILURE_MESSAGE_MAX_BYTES, isModelRetryDecision, } from './model-failure.js';
 import { decodeMessageContent, TOOL_ACTIVITY_KINDS, } from './events.js';
-import { isToolCategory, } from './permission.js';
+import { isPermissionMode, isToolCategory, } from './permission.js';
 import { defineObjectShape, hasExactShape, isFiniteNumber, isOptionalString, isRecord, pickShape, } from './record-schema.js';
 import { isPermissionDecisionFields } from './interaction-record-schema.js';
 import { isTokenUsageFields } from './usage-record-schema.js';
@@ -64,7 +65,11 @@ export function isTurnStatus(value) {
 // ============================================================================
 // Header (JSONL line 1)
 // ============================================================================
-export const SESSION_TOOL_PROFILES = ['headless-coding-v1', 'workhub-coordination-v1'];
+export const SESSION_TOOL_PROFILES = [
+    'headless-coding-v1',
+    'workhub-coordination-v1',
+    'workhub-coordination-v2',
+];
 export function isSessionToolProfile(value) {
     return typeof value === 'string' && SESSION_TOOL_PROFILES.includes(value);
 }
@@ -283,6 +288,19 @@ export function isUserVisibleSessionSystemNote(kind) {
 export const WORKHUB_COORDINATION_RECORD_SCHEMA_VERSION = 1;
 export const WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION = 2;
 export const WORKHUB_COORDINATION_STOP_SCHEMA_VERSION = 3;
+export function isWorkHubCreateDefaults(value) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => key !== 'model' && key !== 'permissionMode'))
+        return false;
+    if (value.permissionMode !== undefined && !isPermissionMode(value.permissionMode))
+        return false;
+    if (value.model === undefined)
+        return true;
+    const model = value.model;
+    return (isRecord(model) &&
+        Object.keys(model).length === 3 &&
+        ['llmConnectionId', 'llmConnectionSlug', 'model'].every((key) => typeof model[key] === 'string' && model[key].trim().length > 0 && model[key].length <= 512));
+}
 function isWorkHubDelegationStopResolution(outcome, targetTurnId) {
     const hasTargetTurnId = typeof targetTurnId === 'string' && targetTurnId.length > 0;
     if (outcome === 'stop_delivered' || outcome === 'not_owned')
@@ -328,6 +346,7 @@ const USER_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 't
     'quotes',
     'inlineReferences',
     'steeringEventId',
+    'coordinationActionId',
     'origin',
 ]);
 const ASSISTANT_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'text', 'modelId'], ['thinking', 'contentOrder', 'providerOptions']);
@@ -405,7 +424,15 @@ const WORKHUB_DELEGATION_ASSIGNED_MESSAGE_SHAPE = defineObjectShape()([
     'targetTurnId',
     'targetMessageId',
     'targetSessionName',
-], ['create', 'steered', 'replacesActionId', 'replacesDelegationId']);
+], [
+    'attachments',
+    'targetAttachments',
+    'create',
+    'steered',
+    'replacesActionId',
+    'replacesDelegationId',
+    'delegationText',
+]);
 const WORKHUB_DELEGATION_REPLACEMENT_REQUESTED_MESSAGE_SHAPE = defineObjectShape()([
     'type',
     'id',
@@ -424,7 +451,7 @@ const WORKHUB_DELEGATION_REPLACEMENT_REQUESTED_MESSAGE_SHAPE = defineObjectShape
     'replacedTargetSessionId',
     'replacedTargetMessageId',
     'targetSessionName',
-], ['create']);
+], ['attachments', 'create', 'delegationText']);
 const WORKHUB_DELEGATION_SUPERSEDED_MESSAGE_SHAPE = defineObjectShape()([
     'type',
     'id',
@@ -486,7 +513,7 @@ const WORKHUB_DELEGATION_STOP_RESOLVED_MESSAGE_SHAPE = defineObjectShape()([
     'targetSessionId',
     'outcome',
 ], ['targetTurnId']);
-const WORKHUB_DELEGATION_CREATE_SHAPE = defineObjectShape()(['title', 'workspace'], []);
+const WORKHUB_DELEGATION_CREATE_SHAPE = defineObjectShape()(['title', 'workspace'], ['defaults']);
 const WORKHUB_DELEGATION_PROJECT_WORKSPACE_SHAPE = defineObjectShape()(['kind', 'projectId'], []);
 const WORKHUB_DELEGATION_HOST_PATH_WORKSPACE_SHAPE = defineObjectShape()(['kind', 'path'], []);
 const SYSTEM_NOTE_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'ts', 'kind'], ['turnId', 'data']);
@@ -510,7 +537,10 @@ function decodeMessage(value, decodeToolResultContent) {
         case 'user':
             if (hasExactShape(message, USER_MESSAGE_SHAPE) &&
                 hasMessageEnvelope(message, true) &&
-                (message.origin === undefined || decodeTurnOrigin(message.origin) !== undefined)) {
+                (message.origin === undefined || decodeTurnOrigin(message.origin) !== undefined) &&
+                (message.coordinationActionId === undefined ||
+                    (typeof message.coordinationActionId === 'string' &&
+                        message.coordinationActionId.length > 0))) {
                 const { displayText, attachments, directoryReferences, quotes, inlineReferences, origin, ...envelope } = message;
                 const decodedOrigin = origin === undefined ? undefined : decodeTurnOrigin(origin);
                 try {
@@ -619,6 +649,11 @@ function decodeMessage(value, decodeToolResultContent) {
     throw new Error('Invalid stored message schema');
 }
 function isWorkHubCoordinationMessage(message) {
+    if (message.kind === 'action_receipt')
+        return (hasMessageEnvelope(message, true) &&
+            message.schemaVersion === 1 &&
+            Object.keys(message).every((k) => ['type', 'kind', 'schemaVersion', 'id', 'turnId', 'ts', 'receipt'].includes(k)) &&
+            isWorkHubActionReceipt(message.receipt));
     if (message.kind === 'delegation_stop_requested') {
         return (hasMessageEnvelope(message, true) &&
             hasExactShape(message, WORKHUB_DELEGATION_STOP_REQUESTED_MESSAGE_SHAPE) &&
@@ -694,6 +729,9 @@ function isWorkHubCoordinationMessage(message) {
         typeof message.targetSessionId === 'string' &&
         typeof message.userText === 'string' &&
         message.userText.trim().length > 0 &&
+        isWorkHubMessageAttachments(message.attachments) &&
+        (message.delegationText === undefined ||
+            (typeof message.delegationText === 'string' && message.delegationText.trim().length > 0)) &&
         ((message.disposition === 'delegate_existing' && message.create === undefined) ||
             (message.disposition === 'create_new' && isWorkHubDelegationCreateSpec(message.create))) &&
         (message.disposition === 'delegate_existing' || message.disposition === 'create_new');
@@ -715,6 +753,7 @@ function isWorkHubCoordinationMessage(message) {
     }
     return (message.kind === 'delegation_assigned' &&
         hasExactShape(message, WORKHUB_DELEGATION_ASSIGNED_MESSAGE_SHAPE) &&
+        isWorkHubMessageAttachments(message.targetAttachments) &&
         typeof message.delegationId === 'string' &&
         typeof message.targetTurnId === 'string' &&
         typeof message.targetMessageId === 'string' &&
@@ -739,9 +778,21 @@ function isWorkHubActionIdentity(message) {
         message.coordinationTurnId.length > 0 &&
         message.turnId === message.coordinationTurnId);
 }
+function isWorkHubMessageAttachments(value) {
+    if (value === undefined)
+        return true;
+    try {
+        decodeMessageContent({ text: '', attachments: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function isWorkHubDelegationCreateSpec(value) {
     if (!isRecord(value) ||
         !hasExactShape(value, WORKHUB_DELEGATION_CREATE_SHAPE) ||
+        (value.defaults !== undefined && !isWorkHubCreateDefaults(value.defaults)) ||
         typeof value.title !== 'string' ||
         value.title.trim().length === 0 ||
         !isRecord(value.workspace)) {

package/node_modules/@maka/core/dist/slash-command-catalog.js

@@ -40,6 +40,7 @@ export const SLASH_COMMAND_CATALOG = [
     { id: 'skill', session: 'required', surfaces: ['tui'] },
     { id: 'swarm', session: 'none', surfaces: ['desktop', 'tui'] },
     { id: 'thinking', session: 'required', surfaces: ['tui'] },
+    { id: 'todo', session: 'required', surfaces: ['tui'] },
     { id: 'transcript', session: 'required', surfaces: ['tui'] },
     { id: 'update', session: 'none', surfaces: ['tui'] },
 ];

package/node_modules/@maka/core/dist/tool-result-record-schema.js

@@ -37,7 +37,7 @@ const ARCHIVED_SHAPE = defineObjectShape()([
     'originalBytes',
     'rewriteVersion',
     'reason',
-], ['artifactId', 'bodySha256']);
+], ['artifactId', 'resourceRef', 'bodySha256']);
 const IMAGE_SHAPE = defineObjectShape()(['kind', 'mimeType', 'ref'], []);
 const SUMMARY_SHAPE = defineObjectShape()(['kind', 'original', 'summarized', 'reason'], []);
 const WEB_SEARCH_SHAPE = defineObjectShape()(['kind', 'provider', 'query', 'rows'], []);
@@ -157,6 +157,7 @@ function isNonShellToolResultContent(value) {
                 typeof value.toolCallId === 'string' &&
                 typeof value.toolName === 'string' &&
                 isOptionalString(value.artifactId) &&
+                isOptionalString(value.resourceRef) &&
                 isOptionalString(value.bodySha256) &&
                 isFiniteNumber(value.originalEstimatedTokens) &&
                 isFiniteNumber(value.originalBytes) &&

package/node_modules/@maka/core/dist/workhub-action-result.js

@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { isRecord } from './record-schema.js';
+export function isWorkHubActionReceipt(value) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((k) => !['actionId', 'userText', 'result', 'clarification'].includes(k)) ||
+        typeof value.actionId !== 'string' ||
+        !value.actionId ||
+        typeof value.userText !== 'string' ||
+        !value.userText.trim() ||
+        (value.clarification !== undefined && typeof value.clarification !== 'string'))
+        return false;
+    return isWorkHubActionResult(value.result);
+}
+/** Shared closed result contract for Runtime receipts and Host protocol replies. */
+export function isWorkHubActionResult(r) {
+    if (!isRecord(r))
+        return false;
+    const text = (k) => typeof r[k] === 'string' && /^[A-Za-z0-9_-]{1,128}$/u.test(r[k]);
+    const keys = (allowed) => Object.keys(r).every((k) => allowed.includes(k));
+    if (r.disposition === 'answer_here' || r.disposition === 'clarify')
+        return keys(['disposition', 'coordinationTurnId']) && text('coordinationTurnId');
+    if (r.disposition === 'delegate_existing' ||
+        r.disposition === 'create_new' ||
+        r.disposition === 'replace')
+        return (keys([
+            'disposition',
+            'targetSessionId',
+            'targetTurnId',
+            'steered',
+            ...(r.disposition === 'replace' ? ['replacementDisposition'] : []),
+        ]) &&
+            text('targetSessionId') &&
+            text('targetTurnId') &&
+            (r.steered === undefined || r.steered === true) &&
+            (r.disposition !== 'replace' ||
+                r.replacementDisposition === 'delegate_existing' ||
+                r.replacementDisposition === 'create_new'));
+    if (r.disposition === 'stop_work' || r.disposition === 'resume_work')
+        return ((r.disposition === 'stop_work'
+            ? ((r.outcome !== 'stop_delivered' && r.outcome !== 'not_owned') ||
+                r.targetTurnId !== undefined) &&
+                (r.outcome !== 'cancelled_pending' || r.targetTurnId === undefined)
+            : (r.outcome === 'resume_started') === (r.targetTurnId !== undefined)) &&
+            keys(['disposition', 'outcome', 'targetSessionId', 'targetTurnId']) &&
+            text('targetSessionId') &&
+            (r.targetTurnId === undefined || text('targetTurnId')) &&
+            (r.disposition === 'stop_work'
+                ? ['cancelled_pending', 'stop_delivered', 'already_terminal', 'not_owned']
+                : ['resume_started', 'already_running']).includes(String(r.outcome)));
+    return false;
+}

package/node_modules/@maka/core/package.json

@@ -9,6 +9,7 @@
     "./durable-tool-result-projection": "./dist/durable-tool-result-projection.js",
     "./model-projection-transition": "./dist/model-projection-transition.js",
     "./canonical-runtime-event": "./dist/canonical-runtime-event.js",
+    "./canonical-json": "./dist/canonical-json.js",
     "./runtime-boundary": "./dist/runtime-boundary.js",
     "./runtime-handoff": "./dist/runtime-handoff.js",
     "./runtime-logical-execution": "./dist/runtime-logical-execution.js",
@@ -82,8 +83,6 @@
     "./deep-research-client-progress": "./dist/deep-research-client-progress.js",
     "./daily-review": "./dist/daily-review.js",
     "./work-board": "./dist/work-board.js",
-    "./workhub-creation-intent": "./dist/workhub-creation-intent.js",
-    "./workhub-session-resolver": "./dist/workhub-session-resolver.js",
     "./deep-research": "./dist/deep-research.js",
     "./session-start-mode": "./dist/session-start-mode.js",
     "./long-term-memory": "./dist/long-term-memory.js",
@@ -155,7 +154,8 @@
     "./ui-locale": "./dist/ui-locale.js",
     "./unified-diff": "./dist/unified-diff.js",
     "./dev-single-instance": "./dist/dev-single-instance.js",
-    "./maka-wordmark": "./dist/maka-wordmark.js"
+    "./maka-wordmark": "./dist/maka-wordmark.js",
+    "./workhub-action-result": "./dist/workhub-action-result.js"
   },
   "dependencies": {
     "intl-messageformat": "11.2.14"

package/node_modules/@maka/eval/dist/experiment-directory.js

@@ -19,13 +19,14 @@
 import { randomUUID } from 'node:crypto';
 import { link, mkdir, open, readFile, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
+import { stableJsonStringify } from '@maka/core/canonical-json';
 import { FileAttemptStore } from './attempt-store.js';
 import { parseExperimentSpec } from './spec.js';
 export async function openExperimentDirectory(root, spec) {
     await mkdir(root, { recursive: true });
     const specPath = join(root, 'experiment.json');
     const temporaryPath = join(root, `.experiment-${randomUUID()}.tmp`);
-    const canonical = `${canonicalJson(spec)}\n`;
+    const canonical = `${stableJsonStringify(spec)}\n`;
     const temporary = await open(temporaryPath, 'wx', 0o600);
     try {
         await temporary.writeFile(canonical);
@@ -37,8 +38,9 @@ export async function openExperimentDirectory(root, spec) {
         if (error.code !== 'EEXIST')
             throw error;
         const existing = parseExperimentSpec(JSON.parse(await readFile(specPath, 'utf8')));
-        if (canonicalJson(existing) !== canonicalJson(spec))
+        if (stableJsonStringify(existing) !== stableJsonStringify(spec)) {
             throw new Error('experiment spec differs');
+        }
     }
     finally {
         await temporary.close().catch(() => undefined);
@@ -46,14 +48,3 @@ export async function openExperimentDirectory(root, spec) {
     }
     return { root, specPath, attempts: new FileAttemptStore(join(root, 'attempts')) };
 }
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonicalJson).join(',')}]`;
-    if (value && typeof value === 'object') {
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`)
-            .join(',')}}`;
-    }
-    return JSON.stringify(value);
-}

package/node_modules/@maka/eval/dist/toolchain-verification.js

@@ -60,7 +60,7 @@ export const TOOLCHAIN_IDENTITIES = {
     'deepseek-harness': {
         root: '/opt/maka-deepseek-harness-toolchain',
         version: '0.1.0-rc.6',
-        fingerprint: 'sha256:a0882b448718ddfb7b64e33a12369c92b0064baf8388fe08a8ff64fe3dd98896',
+        fingerprint: 'sha256:5314e15659d4c35381ce15ca4802933d61bc3af718d7eeb8260f4fa32ccf5860',
     },
 };
 // The identity table is the profile registry: a profile without a pinned

package/node_modules/@maka/mcp/dist/form-elicitation.js

@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { decodeInteractionAnswer, decodeInteractionRequest, interactionFormAnswerMatchesRequest, projectInteractionFormRequest, } from '@maka/core/interaction';
+// Unbounded protocol strings need a visible client input limit: Core reserves
+// the worst-case JSON-escaped answer within its serialized interaction budget.
+// Explicit server bounds are preserved and still checked by Core admission.
+const DEFAULT_STRING_MAX_LENGTH = 256;
+/** Inspect raw keys and values before projection can escape control characters.
+ * This is a containment check, not a comparison with redacted output: a state
+ * may itself be identical to the redaction marker.
+ */
+export function containsMcpFormState(value, states) {
+    const pending = [value];
+    while (pending.length) {
+        const item = pending.pop();
+        if (typeof item === 'string') {
+            if (states.some((state) => state.length > 0 && item.includes(state)))
+                return true;
+        }
+        else if (item !== null && typeof item === 'object') {
+            for (const [key, child] of Object.entries(item))
+                pending.push(key, child);
+        }
+    }
+    return false;
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error();
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw new Error();
+    return value;
+}
+function keys(value, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        throw new Error();
+}
+function select(value, names) {
+    return Object.fromEntries(names.filter((name) => Object.hasOwn(value, name)).map((name) => [name, value[name]]));
+}
+function options(value, titles) {
+    if (!Array.isArray(value) ||
+        (titles !== undefined && (!Array.isArray(titles) || titles.length !== value.length)))
+        throw new Error();
+    return value.map((entry, index) => ({
+        value: entry,
+        label: Array.isArray(titles) ? titles[index] : entry,
+    }));
+}
+function titledOptions(value) {
+    if (!Array.isArray(value))
+        throw new Error();
+    return value.map((entry) => {
+        const option = record(entry);
+        keys(option, ['const', 'title']);
+        return { value: option.const, label: option.title };
+    });
+}
+function field(name, value, required) {
+    const schema = record(value);
+    const sharedKeys = ['type', 'title', 'description', 'default'];
+    const shared = {
+        name,
+        label: Object.hasOwn(schema, 'title') ? schema.title : name,
+        required,
+        ...select(schema, ['description', 'default']),
+    };
+    if (schema.type === 'string') {
+        if (Object.hasOwn(schema, 'enum')) {
+            keys(schema, [...sharedKeys, 'enum', 'enumNames']);
+            return { ...shared, kind: 'single_select', options: options(schema.enum, schema.enumNames) };
+        }
+        if (Object.hasOwn(schema, 'oneOf')) {
+            keys(schema, [...sharedKeys, 'oneOf']);
+            return { ...shared, kind: 'single_select', options: titledOptions(schema.oneOf) };
+        }
+        keys(schema, [...sharedKeys, 'minLength', 'maxLength', 'format']);
+        return {
+            ...shared,
+            kind: 'string',
+            ...select(schema, ['minLength', 'maxLength', 'format']),
+            ...(schema.maxLength === undefined ? { maxLength: DEFAULT_STRING_MAX_LENGTH } : {}),
+        };
+    }
+    if (schema.type === 'number' || schema.type === 'integer') {
+        keys(schema, [...sharedKeys, 'minimum', 'maximum']);
+        // Core validates numeric ranges; an integer-only interval may additionally be empty.
+        if (schema.type === 'integer' &&
+            typeof schema.minimum === 'number' &&
+            typeof schema.maximum === 'number' &&
+            Math.ceil(schema.minimum) > Math.floor(schema.maximum))
+            throw new Error();
+        return { ...shared, kind: schema.type, ...select(schema, ['minimum', 'maximum']) };
+    }
+    if (schema.type === 'boolean') {
+        keys(schema, sharedKeys);
+        return { ...shared, kind: 'boolean' };
+    }
+    if (schema.type === 'array') {
+        keys(schema, [...sharedKeys, 'items', 'minItems', 'maxItems']);
+        const items = record(schema.items);
+        let choices;
+        if (Object.hasOwn(items, 'anyOf')) {
+            keys(items, ['anyOf']);
+            choices = titledOptions(items.anyOf);
+        }
+        else {
+            keys(items, ['type', 'enum']);
+            if (items.type !== 'string')
+                throw new Error();
+            choices = options(items.enum);
+        }
+        return {
+            ...shared,
+            kind: 'multi_select',
+            options: choices,
+            ...select(schema, ['minItems', 'maxItems']),
+        };
+    }
+    throw new Error();
+}
+/** Adapt one embedded MCP form request without exposing protocol state to the UI. */
+export function prepareMcpForm(request, requester) {
+    try {
+        const embedded = record(request);
+        keys(embedded, ['method', 'params']);
+        if (embedded.method !== 'elicitation/create')
+            throw new Error();
+        const params = record(embedded.params);
+        keys(params, ['mode', 'message', 'requestedSchema', '_meta']);
+        if (params.mode !== undefined && params.mode !== 'form')
+            throw new Error();
+        const schema = record(params.requestedSchema);
+        keys(schema, [
+            'type',
+            'properties',
+            'required',
+            '$schema',
+            'title',
+            'description',
+            'additionalProperties',
+        ]);
+        if (schema.type !== 'object' ||
+            (schema.additionalProperties !== undefined && schema.additionalProperties !== false))
+            throw new Error();
+        for (const annotation of ['$schema', 'title', 'description']) {
+            if (schema[annotation] !== undefined && typeof schema[annotation] !== 'string')
+                throw new Error();
+        }
+        const properties = record(schema.properties);
+        const required = schema.required === undefined ? [] : schema.required;
+        if (!Array.isArray(required) ||
+            required.some((name) => typeof name !== 'string' || !Object.hasOwn(properties, name)) ||
+            new Set(required).size !== required.length)
+            throw new Error();
+        const decoded = decodeInteractionRequest({
+            kind: 'form',
+            toolUseId: 'mcp-form',
+            message: params.message,
+            requester,
+            fields: Object.entries(properties).map(([name, schema]) => field(name, schema, required.includes(name))),
+        });
+        if (decoded.kind !== 'form')
+            throw new Error();
+        const projected = projectInteractionFormRequest(decoded);
+        return {
+            form: {
+                message: projected.message,
+                requester: projected.requester,
+                fields: projected.fields,
+            },
+            respond(result) {
+                try {
+                    const answer = decodeInteractionAnswer({ ...result, kind: 'form' });
+                    if (answer.kind !== 'form' || !interactionFormAnswerMatchesRequest(projected, answer))
+                        throw new Error();
+                    if (answer.action !== 'accept')
+                        return { action: answer.action };
+                    return {
+                        action: 'accept',
+                        content: Object.fromEntries(Object.entries(answer.values).map(([name, value]) => [
+                            name,
+                            typeof value === 'object' ? [...value] : value,
+                        ])),
+                    };
+                }
+                catch {
+                    throw new Error('Invalid MCP form response');
+                }
+            },
+        };
+    }
+    catch {
+        throw new Error('Unsupported or invalid MCP form request');
+    }
+}