@jini-ai/mcp 0.4.2 → 0.4.4

package/dist/tools/ask-choice/index.js

@@ -1,5 +1,5 @@
-import { parseQuestion, QuestionShapeError } from './question.js';
-import { ASK_CHOICE_INPUT_SCHEMA } from './schema.js';
+import { matchesOptions, parseQuestion, QuestionShapeError } from './question.js';
+import { ASK_CHOICE_INPUT_SCHEMA, ASK_CHOICE_INVOCATION_SCHEMA } from './schema.js';
 export { ASK_CHOICE_INPUT_SCHEMA } from './schema.js';
 export { createAskChoiceAnswerTicketStore } from './pending.js';
 /** Existing callback wire keys; the tool's identity is supplied by the host. */
@@ -14,7 +14,32 @@ function describeAnswer(params, messages) {
         return { submitted: false, reason: 'no-answer', note: messages.noAnswer };
     return { submitted: true, ...(choice === undefined ? {} : { choice }), ...(selections === undefined ? {} : { selections }), note: messages.submitted };
 }
-async function waitForAnswer({ exchange, ui, signal, messages }) {
+// Classifies a delivered form answer: cancel wins over typed text, typed text wins over picks,
+// and picks must stay inside the offered options and actions.
+function classifyReceived({ params, question, messages }) {
+    if (params[SURFACE_DISMISSED_PARAM] === true)
+        return { submitted: false, reason: 'cancelled', note: messages.cancelled };
+    const typed = params[SURFACE_TYPED_ANSWER_PARAM];
+    if (typeof typed === 'string' && typed.trim())
+        return { submitted: true, freeText: typed.trim(), note: messages.typed };
+    const described = describeAnswer(params, messages);
+    if (described.submitted !== true)
+        return described;
+    return withOfferedAction({ described, params, question, messages });
+}
+function withOfferedAction({ described, params, question, messages }) {
+    const invalid = { submitted: false, reason: 'invalid-answer', note: messages.noAnswer };
+    // Live exchanges need the same offered-option boundary as fallback tickets.
+    if (!matchesOptions({ question, params }))
+        return invalid;
+    if (!question.actions)
+        return described;
+    const action = params['__choiceAction'];
+    if (!question.actions.some(offered => offered.id === action))
+        return invalid;
+    return { ...described, action };
+}
+async function waitForAnswer({ exchange, ui, signal, messages, question }) {
     const close = () => exchange.close({});
     signal.addEventListener('abort', close, { once: true });
     try {
@@ -26,18 +51,31 @@ async function waitForAnswer({ exchange, ui, signal, messages }) {
         const answer = await exchange.receive({});
         if (answer.status !== 'received')
             return { submitted: false, reason: answer.status, note: messages[answer.status] };
-        if (answer.params[SURFACE_DISMISSED_PARAM] === true)
-            return { submitted: false, reason: 'cancelled', note: messages.cancelled };
-        const typed = answer.params[SURFACE_TYPED_ANSWER_PARAM];
-        if (typeof typed === 'string' && typed.trim())
-            return { submitted: true, freeText: typed.trim(), note: messages.typed };
-        return describeAnswer(answer.params, messages);
+        return classifyReceived({ params: answer.params, question, messages });
     }
     finally {
         signal.removeEventListener('abort', close);
         close();
     }
 }
+/** Run a trusted host question through the same abort, delivery, validation and cleanup lifecycle
+ * as the model-facing tool. The host owns presentation and action policy, never exchange mechanics.
+ * @returns Classified human answer, including an offered action when configured.
+ * @complexity O(n) offered options and selections.
+ */
+export async function askChoice({ exchange, question, toolId, principalId, presentation, signal, messages }, _options = {}) {
+    let ui;
+    try {
+        ui = presentation.render({ toolName: toolId, principalId, question,
+            baseParams: { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id },
+        }, { cancelParams: { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id, [SURFACE_DISMISSED_PARAM]: true } });
+    }
+    catch (error) {
+        exchange.close({});
+        throw error;
+    }
+    return waitForAnswer({ exchange, ui, signal, messages, question });
+}
 /** Creates a choice tool without a CMS, renderer, permission system, clock, or global store.
  * The host composes this descriptor/handler into its registry and mounts callbacks against the
  * same exchange and pending stores. Policy and presentation are required, with no product defaults.
@@ -49,50 +87,56 @@ export function createAskChoiceTool({ toolId, description, permission, policy, p
     };
     return {
         descriptor,
+        invocationSchema: ASK_CHOICE_INVOCATION_SCHEMA,
         async handler({ ctx }) {
             await policy.authorize({ ctx, toolId });
             const input = typeof ctx.input === 'object' && ctx.input !== null ? ctx.input : {};
-            const isAnswer = typeof input['title'] !== 'string' && (typeof input['choice'] === 'string' || Array.isArray(input['selections']));
-            if (isAnswer) {
-                const rawTicket = input[ASK_CHOICE_ANSWER_TICKET_PARAM];
-                const ticket = typeof rawTicket === 'string' ? rawTicket : undefined;
-                if (!pendingQuestions.redeem({ ticket, principalId: ctx.principalId, params: input })) {
-                    throw policy.inputError({ message: messages.forgedAnswer });
-                }
-                return describeAnswer(input, messages);
-            }
-            let question;
-            try {
-                question = parseQuestion({ input, toolId });
-            }
-            catch (error) {
-                if (!(error instanceof QuestionShapeError))
-                    throw error;
-                throw policy.shapeError({ message: error.message, toolId, inputSchema: ASK_CHOICE_INPUT_SCHEMA });
-            }
+            if (isAnswerCall(input))
+                return redeemAnswer({ input, ctx, pendingQuestions, policy, messages });
+            const question = parseOrRefuse({ input, toolId, policy });
             if (ctx.signal.aborted)
                 return { submitted: false, reason: 'abandoned', note: messages.abandoned };
             const exchange = ctx.emitSurface ? surfaceExchanges.open({ toolId, principalId: ctx.principalId, emit: ctx.emitSurface }) : undefined;
-            const ticket = exchange ? undefined : pendingQuestions.mint({ principalId: ctx.principalId, question });
-            const baseParams = exchange ? { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id } : { [ASK_CHOICE_ANSWER_TICKET_PARAM]: ticket };
-            let ui;
-            try {
-                ui = presentation.render({
-                    toolName: toolId, principalId: ctx.principalId, question, baseParams,
-                }, { ...(exchange ? { cancelParams: { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id, [SURFACE_DISMISSED_PARAM]: true } } : {}),
-                });
-                if (!exchange)
-                    return presentation.buildResult({ modelText: messages.pending, ui });
-            }
-            catch (error) {
-                exchange?.close({});
-                // A form that was not delivered must not leave a redeemable fallback ticket behind.
-                if (ticket !== undefined)
-                    pendingQuestions.redeem({ ticket, principalId: ctx.principalId, params: {} });
-                throw error;
-            }
-            return waitForAnswer({ exchange, ui, signal: ctx.signal, messages });
+            if (exchange)
+                return askChoice({ exchange, question, toolId, principalId: ctx.principalId, presentation, signal: ctx.signal, messages });
+            return presentFallback({ question, toolId, principalId: ctx.principalId, pendingQuestions, presentation, messages });
         },
     };
 }
+// A second call carrying a pick (and no question title) is an answer to a fallback form.
+function isAnswerCall(input) {
+    return typeof input['title'] !== 'string' && typeof input['question'] !== 'string' && (typeof input['choice'] === 'string' || Array.isArray(input['selections']));
+}
+// The ticket is the only proof the answer came from a rendered form: redeem is fail-closed.
+function redeemAnswer({ input, ctx, pendingQuestions, policy, messages }) {
+    const rawTicket = input[ASK_CHOICE_ANSWER_TICKET_PARAM];
+    const ticket = typeof rawTicket === 'string' ? rawTicket : undefined;
+    if (!pendingQuestions.redeem({ ticket, principalId: ctx.principalId, params: input })) {
+        throw policy.inputError({ message: messages.forgedAnswer });
+    }
+    return describeAnswer(input, messages);
+}
+function parseOrRefuse({ input, toolId, policy }) {
+    try {
+        return parseQuestion({ input, toolId });
+    }
+    catch (error) {
+        if (!(error instanceof QuestionShapeError))
+            throw error;
+        throw policy.shapeError({ message: error.message, toolId, inputSchema: ASK_CHOICE_INPUT_SCHEMA });
+    }
+}
+// No emit seam: return the form itself, bound to a freshly minted single-use ticket.
+function presentFallback({ question, toolId, principalId, pendingQuestions, presentation, messages }) {
+    const ticket = pendingQuestions.mint({ principalId, question });
+    try {
+        const ui = presentation.render({ toolName: toolId, principalId, question, baseParams: { [ASK_CHOICE_ANSWER_TICKET_PARAM]: ticket } });
+        return presentation.buildResult({ modelText: messages.pending, ui });
+    }
+    catch (error) {
+        // A form that was not delivered must not leave a redeemable fallback ticket behind.
+        pendingQuestions.redeem({ ticket, principalId, params: {} });
+        throw error;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/tools/ask-choice/question.d.ts

@@ -5,10 +5,14 @@ export declare class QuestionShapeError extends Error {
         message: string;
     }, options?: ErrorOptions);
 }
+/** Normalize the flat model question into the existing UI/answer contract.
+ * @throws QuestionShapeError for malformed questions or ambiguous mixed forms.
+ * @complexity O(n) in offered options; no effects.
+ */
 export declare function parseQuestion({ input, toolId }: {
     input: Record<string, unknown>;
     toolId: string;
-}): AskChoiceQuestion;
+}, _options?: {}): AskChoiceQuestion;
 export declare function matchesOptions({ question, params }: {
     question: AskChoiceQuestion;
     params: Record<string, unknown>;

package/dist/tools/ask-choice/question.js

@@ -21,11 +21,45 @@ function readSelect(raw, field, toolId) {
         if (typeof value !== 'string' || !value || typeof label !== 'string' || !label) {
             throw new QuestionShapeError({ message: `${toolId}: every '${field}' option requires a string 'value' and 'label'.` });
         }
-        return { value, label };
+        return { value, label, ...(typeof option['description'] === 'string' ? { description: option['description'] } : {}) };
     });
     return { label: spec['label'], options, ...(typeof spec['hint'] === 'string' ? { hint: spec['hint'] } : {}) };
 }
-export function parseQuestion({ input, toolId }) {
+function normalizeFlatQuestion({ input, toolId }, _options = {}) {
+    const question = input['question'];
+    if (typeof question !== 'string' || !question.trim())
+        throw new QuestionShapeError({ message: `${toolId}: 'question' is required.` });
+    if (input['multiple'] !== undefined && typeof input['multiple'] !== 'boolean') {
+        throw new QuestionShapeError({ message: `${toolId}: 'multiple' must be a boolean.` });
+    }
+    const options = normalizeFlatOptions({ rawOptions: input['options'] });
+    const select = { label: question, options };
+    return { title: question, ...(typeof input['description'] === 'string' ? { description: input['description'] } : {}),
+        ...(typeof input['submitLabel'] === 'string' ? { submitLabel: input['submitLabel'] } : {}),
+        [input['multiple'] === true ? 'multiSelect' : 'singleSelect']: select };
+}
+function normalizeFlatOptions({ rawOptions }, _options = {}) {
+    return Array.isArray(rawOptions) ? rawOptions.map(entry => {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry))
+            return entry;
+        const option = entry;
+        return { ...option, value: option['value'] === undefined ? option['label'] : option['value'] };
+    }) : rawOptions;
+}
+function normalizeQuestion({ input, toolId }, _options = {}) {
+    if (input['question'] === undefined && input['options'] === undefined && input['multiple'] === undefined)
+        return input;
+    if (input['title'] !== undefined || input['singleSelect'] !== undefined || input['multiSelect'] !== undefined) {
+        throw new QuestionShapeError({ message: `${toolId}: use {question, options, multiple?} or the legacy nested selects; do not mix them.` });
+    }
+    return normalizeFlatQuestion({ input, toolId });
+}
+/** Normalize the flat model question into the existing UI/answer contract.
+ * @throws QuestionShapeError for malformed questions or ambiguous mixed forms.
+ * @complexity O(n) in offered options; no effects.
+ */
+export function parseQuestion({ input, toolId }, _options = {}) {
+    input = normalizeQuestion({ input, toolId });
     const title = input['title'];
     if (typeof title !== 'string' || !title)
         throw new QuestionShapeError({ message: `${toolId}: 'title' is required.` });

package/dist/tools/ask-choice/schema.d.ts

@@ -1,16 +1,51 @@
-/** Model input schema. Callback correlation params are carried by the rendered form only. */
+/** Model-authored question. Legacy nested selects remain aliases; answers are form-only. */
 export declare const ASK_CHOICE_INPUT_SCHEMA: {
     readonly type: "object";
     readonly additionalProperties: false;
-    readonly required: readonly ["title"];
     readonly anyOf: readonly [{
-        readonly required: readonly ["singleSelect"];
+        readonly required: readonly ["question", "options"];
     }, {
-        readonly required: readonly ["multiSelect"];
+        readonly required: readonly ["title", "singleSelect"];
+    }, {
+        readonly required: readonly ["title", "multiSelect"];
     }];
     readonly properties: {
+        readonly question: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "The question to ask the human.";
+        };
+        readonly options: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["label"];
+                readonly properties: {
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly value: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Defaults to label when omitted.";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly multiple: {
+            readonly type: "boolean";
+            readonly description: "Allow several selections. Defaults to false.";
+        };
         readonly title: {
             readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Legacy alias: title with singleSelect or multiSelect.";
         };
         readonly description: {
             readonly type: "string";
@@ -19,25 +54,33 @@ export declare const ASK_CHOICE_INPUT_SCHEMA: {
             readonly type: "string";
         };
         readonly singleSelect: {
+            readonly description: "Legacy nested single-choice alias.";
             readonly type: "object";
             readonly additionalProperties: false;
             readonly required: readonly ["label", "options"];
             readonly properties: {
                 readonly label: {
                     readonly type: "string";
+                    readonly minLength: 1;
                 };
                 readonly options: {
                     readonly type: "array";
                     readonly minItems: 1;
                     readonly items: {
+                        readonly required: readonly ["value", "label"];
                         readonly type: "object";
                         readonly additionalProperties: false;
-                        readonly required: readonly ["value", "label"];
                         readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
                             readonly value: {
                                 readonly type: "string";
+                                readonly minLength: 1;
+                                readonly description: "Defaults to label when omitted.";
                             };
-                            readonly label: {
+                            readonly description: {
                                 readonly type: "string";
                             };
                         };
@@ -46,25 +89,33 @@ export declare const ASK_CHOICE_INPUT_SCHEMA: {
             };
         };
         readonly multiSelect: {
+            readonly description: "Legacy nested multiple-choice alias.";
             readonly properties: {
                 readonly hint: {
                     readonly type: "string";
                 };
                 readonly label: {
                     readonly type: "string";
+                    readonly minLength: 1;
                 };
                 readonly options: {
                     readonly type: "array";
                     readonly minItems: 1;
                     readonly items: {
+                        readonly required: readonly ["value", "label"];
                         readonly type: "object";
                         readonly additionalProperties: false;
-                        readonly required: readonly ["value", "label"];
                         readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
                             readonly value: {
                                 readonly type: "string";
+                                readonly minLength: 1;
+                                readonly description: "Defaults to label when omitted.";
                             };
-                            readonly label: {
+                            readonly description: {
                                 readonly type: "string";
                             };
                         };
@@ -75,17 +126,152 @@ export declare const ASK_CHOICE_INPUT_SCHEMA: {
             readonly additionalProperties: false;
             readonly required: readonly ["label", "options"];
         };
+    };
+};
+/** Execution-only callback fields. The same handler still verifies the principal-bound ticket. */
+export declare const ASK_CHOICE_INVOCATION_SCHEMA: {
+    readonly anyOf: readonly [{
+        readonly required: readonly ["question", "options"];
+    }, {
+        readonly required: readonly ["title", "singleSelect"];
+    }, {
+        readonly required: readonly ["title", "multiSelect"];
+    }, {
+        readonly required: readonly ["choice", "__askChoiceAnswerTicket"];
+    }, {
+        readonly required: readonly ["selections", "__askChoiceAnswerTicket"];
+    }];
+    readonly properties: {
         readonly choice: {
             readonly type: "string";
-            readonly description: "Set by the rendered form; never by the model.";
         };
         readonly selections: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
-            readonly description: "Set by the rendered form; never by the model.";
+        };
+        readonly __askChoiceAnswerTicket: {
+            readonly type: "string";
+        };
+        readonly question: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "The question to ask the human.";
+        };
+        readonly options: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["label"];
+                readonly properties: {
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly value: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Defaults to label when omitted.";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly multiple: {
+            readonly type: "boolean";
+            readonly description: "Allow several selections. Defaults to false.";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Legacy alias: title with singleSelect or multiSelect.";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly submitLabel: {
+            readonly type: "string";
+        };
+        readonly singleSelect: {
+            readonly description: "Legacy nested single-choice alias.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["label", "options"];
+            readonly properties: {
+                readonly label: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly options: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly required: readonly ["value", "label"];
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly value: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly description: "Defaults to label when omitted.";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly multiSelect: {
+            readonly description: "Legacy nested multiple-choice alias.";
+            readonly properties: {
+                readonly hint: {
+                    readonly type: "string";
+                };
+                readonly label: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly options: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly required: readonly ["value", "label"];
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly value: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly description: "Defaults to label when omitted.";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+            };
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["label", "options"];
         };
     };
+    readonly type: "object";
+    readonly additionalProperties: false;
 };
 //# sourceMappingURL=schema.d.ts.map

package/dist/tools/ask-choice/schema.js

@@ -1,27 +1,48 @@
 const optionSchema = {
-    type: 'object', additionalProperties: false, required: ['value', 'label'],
-    properties: { value: { type: 'string' }, label: { type: 'string' } },
+    type: 'object', additionalProperties: false, required: ['label'],
+    properties: {
+        label: { type: 'string', minLength: 1 },
+        value: { type: 'string', minLength: 1, description: 'Defaults to label when omitted.' },
+        description: { type: 'string' },
+    },
 };
 const selectSchema = {
     type: 'object', additionalProperties: false, required: ['label', 'options'],
     properties: {
-        label: { type: 'string' },
-        options: { type: 'array', minItems: 1, items: optionSchema },
+        label: { type: 'string', minLength: 1 },
+        options: { type: 'array', minItems: 1, items: { ...optionSchema, required: ['value', 'label'] } },
     },
 };
-/** Model input schema. Callback correlation params are carried by the rendered form only. */
+/** Model-authored question. Legacy nested selects remain aliases; answers are form-only. */
 export const ASK_CHOICE_INPUT_SCHEMA = {
-    type: 'object', additionalProperties: false, required: ['title'],
-    anyOf: [{ required: ['singleSelect'] }, { required: ['multiSelect'] }],
+    type: 'object', additionalProperties: false,
+    anyOf: [
+        { required: ['question', 'options'] },
+        { required: ['title', 'singleSelect'] },
+        { required: ['title', 'multiSelect'] },
+    ],
     properties: {
-        title: { type: 'string' }, description: { type: 'string' }, submitLabel: { type: 'string' },
-        singleSelect: selectSchema,
+        question: { type: 'string', minLength: 1, description: 'The question to ask the human.' },
+        options: { type: 'array', minItems: 1, items: optionSchema },
+        multiple: { type: 'boolean', description: 'Allow several selections. Defaults to false.' },
+        title: { type: 'string', minLength: 1, description: 'Legacy alias: title with singleSelect or multiSelect.' },
+        description: { type: 'string' }, submitLabel: { type: 'string' },
+        singleSelect: { ...selectSchema, description: 'Legacy nested single-choice alias.' },
         multiSelect: {
-            ...selectSchema,
+            ...selectSchema, description: 'Legacy nested multiple-choice alias.',
             properties: { ...selectSchema.properties, hint: { type: 'string' } },
         },
-        choice: { type: 'string', description: 'Set by the rendered form; never by the model.' },
-        selections: { type: 'array', items: { type: 'string' }, description: 'Set by the rendered form; never by the model.' },
+    },
+};
+/** Execution-only callback fields. The same handler still verifies the principal-bound ticket. */
+export const ASK_CHOICE_INVOCATION_SCHEMA = {
+    ...ASK_CHOICE_INPUT_SCHEMA,
+    anyOf: [...ASK_CHOICE_INPUT_SCHEMA.anyOf, { required: ['choice', '__askChoiceAnswerTicket'] }, { required: ['selections', '__askChoiceAnswerTicket'] }],
+    properties: {
+        ...ASK_CHOICE_INPUT_SCHEMA.properties,
+        choice: { type: 'string' },
+        selections: { type: 'array', items: { type: 'string' } },
+        __askChoiceAnswerTicket: { type: 'string' },
     },
 };
 //# sourceMappingURL=schema.js.map

package/dist/tools/ask-choice/types.d.ts

@@ -2,9 +2,12 @@
 export interface AskChoiceSelect {
     readonly label: string;
     readonly hint?: string;
+    /** Host-supplied checked defaults; answers are still validated against offered options. */
+    readonly value?: readonly string[];
     readonly options: ReadonlyArray<{
         value: string;
         label: string;
+        description?: string;
     }>;
 }
 export interface AskChoiceQuestion {
@@ -13,6 +16,11 @@ export interface AskChoiceQuestion {
     readonly submitLabel?: string;
     readonly singleSelect?: AskChoiceSelect;
     readonly multiSelect?: AskChoiceSelect;
+    /** Trusted host actions, carried by the form under __choiceAction. */
+    readonly actions?: readonly {
+        id: string;
+        label: string;
+    }[];
 }
 export interface AskChoiceMessages {
     readonly pending: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/mcp",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Model Context Protocol adapters: server config schema and IO, an MCP client, and agent-side MCP server installation.",
   "license": "Apache-2.0",
   "repository": {
@@ -83,11 +83,11 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.9"
   },
   "peerDependencies": {
     "@cfworker/json-schema": "^4.1.1",
-    "@jini-ai/platform": "^0.5.1",
+    "@jini-ai/platform": "^0.5.3",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "peerDependenciesMeta": {
@@ -104,8 +104,9 @@
   "devDependencies": {
     "@cfworker/json-schema": "^4.1.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/platform": "^0.5.2"
+    "@jini-ai/core": "^0.4.9",
+    "@jini-ai/platform": "^0.5.10",
+    "@jini-ai/daemon": "^0.6.9"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/bin/serve.js",